Lines Matching defs:bit
28 * 1. Full if the coresponding segment map bit is set
73 * the gFullSegmentList (a bit string).
206 * 1. Calculate the segment number for given bit.
219 * 1. startBit - bit number (block number) to lookup
299 * bit in gFullSegmentList, and update counters.
354 * Note: This function is independent of the previous state of the bit
355 * to be set. Therefore single bit can be set multiple times. Setting a
356 * bit multiple times might result in incorrect total number of blocks used
360 * 2. If first bit does not start on word boundary, special case it.
367 * startBit - bit number in segment bitmap to start set operation.
413 * If the first bit to check doesn't start on a word
448 startBit += kBitsPerSegment; // generate a bit in the next bitmap segment
508 * Note: This function is independent of the previous state of the bit
509 * to clear. Therefore single bit can be cleared multiple times. Clearing a
510 * bit multiple times might result in incorrect total number of blocks used
514 * 2. If first bit does not start on word boundary, special case it.
521 * startBit - bit number in segment bitmap to start clear operation.
567 * If the first bit to check doesn't start on a word
602 startBit += kBitsPerSegment; // generate a bit in the next bitmap segment
675 UInt64 bit; /* 64-bit to avoid wrap around on volumes with 2^32 - 1 blocks */
708 for (bit = 0; bit < gTotalBits; bit += kBitsPerSegment) {
709 (void) GetSegmentBitmap(bit, &buffer, kTestingBits);
714 if ((bit & bitsWithinFileBlkMask) == 0) {
735 if (memcmp(buffer, vbmBlockP + (bit & bitsWithinFileBlkMask)/8, kBytesPerSegment) == 0)
739 bcopy(buffer, vbmBlockP + (bit & bitsWithinFileBlkMask)/8, kBytesPerSegment);
749 plog(" disk buffer + %d\n", (bit & bitsWithinFileBlkMask)/8);
750 plog("start block number for segment = %qu\n", bit);
751 plog("segment %qd\n", bit / kBitsPerSegment);
760 disk_buffer = (UInt32*) (vbmBlockP + (bit & bitsWithinFileBlkMask)/8);
773 /* If two words are different, compare each bit in the word */
777 block_num = bit + (i * kBitsPerWord) + j;
802 diskp = vbmBlockP + (bit & bitsWithinFileBlkMask)/8;
852 UInt32 bit;
858 for (bit = 0; bit < gTotalBits; bit += kBitsPerSegment) {
859 (void) GetSegmentBitmap(bit, &buffer, kTestingBits);
905 * a count of contigous cleared bits and the first cleared bit seen in
907 * If it sees a set bit, it re-intializes the count to the number of
908 * blocks to be found and first cleared bit as zero.
909 * If it sees a cleared bit, it decrements the count of number of blocks
910 * to be found cleared. If the first cleared bit was set to zero,
911 * it initializes it with the current bit. If the count of number
934 UInt32 bit;
940 UInt32 startBlock = 0; /* start bit for free bits sequence */
953 for (bit = 0; bit < gTotalBits; bit += kBitsPerSegment) {
954 (void) GetSegmentBitmap(bit, &buffer, kTestingBits);
957 if ((gTotalBits - bit) < kBitsPerSegment) {
958 validBitsInSegment = gTotalBits - bit;
973 startBlock = bit;
1012 /* Check every bit in the word */
1015 /* The bit is set, reset our counters */
1019 /* The bit is clear */
1021 startBlock = bit + (i * kBitsPerWord) + j;
1144 UInt32 bit;
1159 for (bit = 0; bit < gTotalBits; /* bit incremented below */) {
1160 assert((bit % kBitsPerSegment) == 0);
1162 (void) GetSegmentBitmap(bit, &buffer, kTestingBits);
1174 bit += kBitsPerSegment;
1184 startBlock = bit;
1186 if (gTotalBits - bit < kBitsPerSegment) {
1187 blockCount += gTotalBits - bit;
1191 bit += kBitsPerSegment;
1200 wordWithinSegment < kWordsPerSegment && bit < gTotalBits;
1203 assert((bit % kBitsPerWord) == 0);
1209 bitWithinWordMask != 0 && bit < gTotalBits;
1210 ++bit, bitWithinWordMask >>= 1)
1225 startBlock = bit;
1272 * 1. Full if the coresponding segment map bit is set