/*
* Initialize our volume bitmap data structures
*/
int BitMapCheckBegin(SGlobPtr g)
{
Boolean isHFSPlus;
if (gBitMapInited)
return (0);
isHFSPlus = VolumeObjectIsHFSPlus( );
gFullBitmapSegment = (UInt32 *)malloc(kBytesPerSegment);
memset((void *)gFullBitmapSegment, 0xff, kBytesPerSegment);
gEmptyBitmapSegment = (UInt32 *)malloc(kBytesPerSegment);
memset((void *)gEmptyBitmapSegment, 0x00, kBytesPerSegment);
gTotalBits = g->calculatedVCB->vcbTotalBlocks;
gTotalSegments = (gTotalBits / kBitsPerSegment);
if (gTotalBits % kBitsPerSegment)
++gTotalSegments;
gFullSegmentList = bit_alloc(gTotalSegments);
bit_nclear(gFullSegmentList, 0, gTotalSegments - 1);
BMS_InitTree();
gBitMapInited = 1;
gBitsMarked = 0;
if (isHFSPlus) {
UInt16 alignBits;
/*
* Allocate the VolumeHeader in the volume bitmap.
* Since the VH is the 3rd sector in we may need to
* add some alignment allocation blocks before it.
*/
if (g->calculatedVCB->vcbBlockSize == 512)
alignBits = 2;
else if (g->calculatedVCB->vcbBlockSize == 1024)
alignBits = 1;
else
alignBits = 0;
(void) CaptureBitmapBits(0, 1 + alignBits);
if (g->calculatedVCB->vcbBlockSize == 512)
alignBits = 1;
else
alignBits = 0;
(void) CaptureBitmapBits(gTotalBits - 1 - alignBits, 1 + alignBits);
}
return (0);
}
/*
_______________________________________________________________________
Routine: BlockAllocateAny
Function: Allocate one or more allocation blocks. If there are fewer
free blocks than requested, all free blocks will be
allocated. The caller guarantees that there is at least
one free block.
The function uses on-disk volume bitmap for allocation
and updates it with newly allocated blocks. It also
updates the in-memory volume bitmap.
Inputs:
vcb Pointer to volume where space is to be allocated
startingBlock Preferred first block for allocation
endingBlock Last block to check + 1
maxBlocks Maximum number of contiguous blocks to allocate
Outputs:
actualStartBlock First block of range allocated, or 0 if error
actualNumBlocks Number of blocks allocated, or 0 if error
_______________________________________________________________________
*/
static OSErr BlockAllocateAny(
SVCB *vcb,
UInt32 startingBlock,
register UInt32 endingBlock,
UInt32 maxBlocks,
UInt32 *actualStartBlock,
UInt32 *actualNumBlocks)
{
OSErr err;
register UInt32 block = 0; // current block number
register UInt32 currentWord; // Pointer to current word within bitmap block
register UInt32 bitMask; // Word with given bits already set (ready to OR in)
register UInt32 wordsLeft; // Number of words left in this bitmap block
UInt32 *buffer;
BlockDescriptor bd = {0};
OptionBits relOpt = kReleaseBlock;
// Since this routine doesn't wrap around
if (maxBlocks > (endingBlock - startingBlock)) {
maxBlocks = endingBlock - startingBlock;
}
//
// Pre-read the first bitmap block
//
err = ReadBitmapBlock(vcb, startingBlock, &bd);
if (err != noErr) goto Exit;
relOpt = kMarkBlockDirty;
buffer = (UInt32 *) bd.buffer;
//
// Set up the current position within the block
//
{
UInt32 wordIndexInBlock;
wordIndexInBlock = (startingBlock & kBitsWithinBlockMask) / kBitsPerWord;
buffer += wordIndexInBlock;
wordsLeft = kWordsPerBlock - wordIndexInBlock;
currentWord = SWAP_BE32(*buffer);
bitMask = kHighBitInWordMask >> (startingBlock & kBitsWithinWordMask);
}
//
// Find the first unallocated block
//
block = startingBlock;
while (block < endingBlock) {
if ((currentWord & bitMask) == 0)
break;
// Next bit
++block;
bitMask >>= 1;
if (bitMask == 0) {
// Next word
bitMask = kHighBitInWordMask;
++buffer;
if (--wordsLeft == 0) {
// Next block
err = ReleaseBitmapBlock(vcb, relOpt, &bd);
bd.buffer = NULL;
if (err != noErr) goto Exit;
err = ReadBitmapBlock(vcb, block, &bd);
if (err != noErr) goto Exit;
buffer = (UInt32 *) bd.buffer;
relOpt = kMarkBlockDirty;
wordsLeft = kWordsPerBlock;
}
currentWord = SWAP_BE32(*buffer);
}
}
// Did we get to the end of the bitmap before finding a free block?
// If so, then couldn't allocate anything.
if (block == endingBlock) {
err = dskFulErr;
goto Exit;
}
// Return the first block in the allocated range
*actualStartBlock = block;
// If we could get the desired number of blocks before hitting endingBlock,
// then adjust endingBlock so we won't keep looking. Ideally, the comparison
// would be (block + maxBlocks) < endingBlock, but that could overflow. The
// comparison below yields identical results, but without overflow.
if (block < (endingBlock-maxBlocks)) {
endingBlock = block + maxBlocks; // if we get this far, we've found enough
}
//
// Allocate all of the consecutive blocks
//
while ((currentWord & bitMask) == 0) {
// Allocate this block
currentWord |= bitMask;
// Move to the next block. If no more, then exit.
++block;
if (block == endingBlock)
break;
// Next bit
bitMask >>= 1;
if (bitMask == 0) {
*buffer = SWAP_BE32(currentWord); // update value in bitmap
// Next word
bitMask = kHighBitInWordMask;
++buffer;
if (--wordsLeft == 0) {
// Next block
err = ReleaseBitmapBlock(vcb, relOpt, &bd);
if (err != noErr) goto Exit;
bd.buffer = NULL;
err = ReadBitmapBlock(vcb, block, &bd);
if (err != noErr) goto Exit;
buffer = (UInt32 *) bd.buffer;
relOpt = kMarkBlockDirty;
wordsLeft = kWordsPerBlock;
}
currentWord = SWAP_BE32(*buffer);
}
}
*buffer = SWAP_BE32(currentWord); // update the last change
Exit:
if (err == noErr) {
*actualNumBlocks = block - *actualStartBlock;
/* Update the in-memory copy of bitmap */
(void) CaptureBitmapBits (*actualStartBlock, *actualNumBlocks);
}
else {
*actualStartBlock = 0;
*actualNumBlocks = 0;
}
if (bd.buffer != NULL)
(void) ReleaseBitmapBlock(vcb, relOpt, &bd);
return err;
}