hfscommon/Misc/VolumeAllocation.c

153 					allocation block's bit, and scans it from the starting bit until either the ending bit or
239 		u_int32_t		bit,
1293 	u_int32_t bit;
1303 	bit = VCBTOHFS(vcb)->hfs_metazone_start;
1304 	if (bit == 1)
1305 		bit = 0;
1311 	 *  Count all the bits from bit to lastbit.
1313 	while (bit < lastbit) {
1322 			if (ReadBitmapBlock(vcb, bit, &currCache, &blockRef) != 0) {
1331 		bit += kBitsPerByte;
1342  * Obtain the next allocation block (bit) that's
1347 		u_int32_t		bit)
1352 		return (bit);
1356 	if ((bit >= hfsmp->hfs_metazone_start) &&
1357 			(bit <= hfsmp->hfs_metazone_end)) {
1358 		bit = hfsmp->hfs_metazone_end + 1;
1360 	return (bit);
1370 ;			block (bit).  Return a pointer to the bitmap block.
1374 ;	bit			--	Allocation block whose bitmap block is desired
1383 		u_int32_t		bit,
1394 		KERNEL_DEBUG_CONSTANT(HFSDBG_READ_BITMAP_BLOCK | DBG_FUNC_START, bit, 0, 0, 0, 0);
1402 	block = (daddr64_t)(bit / (blockSize * kBitsPerByte));
1942 		//	Next bit
2056 		//	Next bit
2267 	u_int32_t		firstBit;		//	Bit index within word of first bit to allocate
2496 	 * Calculate the first bit in the bitmap block next to
2497 	 * the bitmap block containing the bit for startingBlock.
2515 	 * Check a full bitmap block for any 'used' bit.  If any bit is used,
2521 	 * marks entire bitmap block as free only if any bit in that bitmap
2524 	 * caller-specified last bit and if any bit is set, only mark that
2581 	u_int32_t	currentBit;		//	Bit index within word of current bit to allocate
2636 		// Move currentWord/bitMask back by one bit
2758 		// Move currentWord/bitMask/wordsLeft forward one bit
2947 			//	Did we find an unused bit (bitMask != 0), or run out of bits (bitMask == 0)?
3014 				 * through this loop again and set the appropriate summary bit as fully allocated.
3024 				//	Figure out which bit is clear
3032 				break;		//	Found the free bit; break out to FoundUnused.
3042 		//	Make sure the unused bit is early enough to use
3071 			//	Did we find a used bit (bitMask != 0), or run out of bits (bitMask == 0)?
3114 				//	Figure out which bit is set
3122 				break;		//	Found the used bit; break out to FoundUsed.
3235  * Count number of bits set in the given 32-bit unsigned number
3282 	u_int32_t  firstBit;       // Bit index within word of first bit to allocate
3494  * 		allocblock - allocation block number. Will be used to infer the correct summary bit.
3519 			/* Ok, now that we have the bit index into the array, what byte is it in ? */
3576 			/* Can't jump to the next summary bit. */
3649  * bit, then keep iterating over the summary bits in order to find the first free one.
3704 		 * Get the starting summary bit, and find it in the array
3726 				 * contain the proper allocation block # based on the bit
3756  * Convert a summary bit into an allocation block number to use to start searching for free blocks.
3760  * 		summarybit 		- summmary bit index
3790  * The argument 'inuse' will set the value of the bit in question to one or zero
3795  *		summarybit	- the bit index into the summary table to set/unset.
3796  * 		inuse		- the value to assign to the bit.
3816 			/* Ok, now that we have the bit index into the array, what byte is it in ? */
3840  * This is a helper function which determines what summary bit represents the vcbVBMIOSize worth
4112 		/* Compute the corresponding allocation block for the summary bit. */
4130 		/* Query the status of the bit and then make sure we match */
4200  *		bitToScan 	- Return the next bit to scan if this function is called again.
4233 	 * hfs_scan_range_size will validate that the start bit
4285 	 * bytes though, so clip our ending bit to what we actually read in.
4310 		 * summary_bit should now be set to the summary bit corresponding to
4311 		 * the allocation block of the first bit that we're supposed to scan
4317 		u_int32_t bit;
4338 					panic ("hfs_alloc_scan_range: backwards summary bit?\n");
4346 			 * bit.
4350 					/* Mark the bit as totally consumed in the summary table */
4354 					/* Mark the bit as potentially free in summary table */
4360 				 * what the last bit that was fully marked in the summary table.
4362 				 * Then reset our marker which says we haven't seen a free bit yet.
4370 		/* Iterate through the word 1 bit at a time... */
4371 		for (bit = 0 ; bit < kBitsPerWord ; bit++, curAllocBlock++) {
4375 			u_int32_t allocated = (current_word & (kHighBitInWordMask >> bit));
4410 	 * but one thing we may not have done is updated that last summary bit for
4412 	 * a vcbVBMIOSize boundary again.  Check for that and update the last bit
4415 	 * Note that 'last_bitmap_block' is *not* inclusive WRT the very last bit in the bitmap
4426 				panic ("hfs_alloc_scan_range: end bit curAllocBlock %u, last_bitmap_block %u", curAllocBlock, last_bitmap_block);
4473  *		bitmap_off 	-- bit offset into the bitmap file
4485 	 * with 32 bit math in this function.
4493 	/* Is this bit index not word aligned?  If so, immediately fail. */
4496 			panic ("hfs_scan_range_size unaligned start bit! bitmap_st %d \n", bitmap_st);
4567  * one bit is active, and that we're going to pass in the buf to use, since GenerateTree
4576 	u_int32_t  firstBit;       // Bit index within word of first bit to allocate