Factorized _Update() and _Check() out of Mark(), Unmark(), CheckMarked() and CheckUnmarked().

Inline some methods.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@40223 a95241bf-73f2-0310-859d-f6bbb57e9c96

src/add-ons/kernel/file_systems/ext2/BitmapBlock.cpp

@@ -37,7 +37,7 @@ BitmapBlock::~BitmapBlock()
 }
 
 
-/*virtual*/ bool
+bool
 BitmapBlock::SetTo(off_t block)
 {
 	fData = NULL;
@@ -47,7 +47,7 @@ BitmapBlock::SetTo(off_t block)
 }
 
 
-/*virtual*/ bool
+bool
 BitmapBlock::SetToWritable(Transaction& transaction, off_t block, bool empty)
 {
 	fReadOnlyData = NULL;
@@ -57,8 +57,8 @@ BitmapBlock::SetToWritable(Transaction& transaction, off_t block, bool empty)
 }
 
 
-/*virtual*/ bool
+bool
-BitmapBlock::CheckUnmarked(uint32 start, uint32 length)
+BitmapBlock::_Check(uint32 start, uint32 length, bool marked)
 {
 	const uint32* data = fData == NULL ? fReadOnlyData : fData;
 	if (data == NULL)
@@ -82,24 +82,20 @@ BitmapBlock::CheckUnmarked(uint32 start, uint32 length)
 			uint32 mask = (1 << (startBit + length)) - 1;
 			mask &= ~((1 << startBit) - 1);
 		       
-			return (bits & mask) == 0;
+			return (bits & mask) == (marked ? mask : 0);
 		} else
 			iterations = 0;
 	} else
 		iterations = (length - 32 + startBit) >> 5;
 
 	uint32 index = startIndex;
-	uint32 mask = 0;
-
-	TRACE("BitmapBlock::CheckUnmarked(): startBit: %lu iterations %lu remainingbits %lu\n",
-		startBit, iterations, remainingBits);
 	
 	if (startBit != 0) {
-		mask = ~((1 << startBit) - 1);
+		uint32 mask = ~((1 << startBit) - 1);
 		uint32 bits = B_LENDIAN_TO_HOST_INT32(data[index]);
 
-		if ((bits & mask) != 0) {
+		if ((bits & mask) != (marked ? mask : 0)) {
-			TRACE("BitmapBlock::CheckUnmarked(): start %lx mask %lx\n", bits, mask);
+			TRACE("BitmapBlock::_Check(): start %lx mask %lx\n", bits, mask);
 			return false;
 		}
 
@@ -108,19 +104,19 @@ BitmapBlock::CheckUnmarked(uint32 start, uint32 length)
 		iterations++;
 
 	for (; iterations > 0; --iterations) {
-		if (data[index++] != 0) {
+		if (data[index++] != (marked ? 0xFFFFFFFF : 0)) {
-			TRACE("BitmapBlock::CheckUnmarked(): iterations %lu bits: %lX\n", iterations,
+			TRACE("BitmapBlock::_Check(): iterations %lu bits: %lX\n", iterations,
 				data[index - 1]);
 			return false;
 		}
 	}
 
 	if (remainingBits != 0) {
-		mask = (1 << remainingBits) - 1;
+		uint32 mask = (1 << remainingBits) - 1;
 
 		uint32 bits = B_LENDIAN_TO_HOST_INT32(data[index]);
-		if ((bits & mask) != 0) {
+		if ((bits & mask) != (marked ? mask : 0)) {
-			TRACE("BitmapBlock::CheckUnmarked(): remainingBits %ld remaining %lX mask %lX\n",
+			TRACE("BitmapBlock::_Check(): remainingBits %ld remaining %lX mask %lX\n",
 				remainingBits, bits, mask);
 			return false;
 		}
@@ -130,171 +126,11 @@ BitmapBlock::CheckUnmarked(uint32 start, uint32 length)
 }
 
 
-/*virtual*/ bool
+bool
-BitmapBlock::CheckMarked(uint32 start, uint32 length)
+BitmapBlock::_Update(uint32 start, uint32 length, bool mark, bool force)
 {
-	const uint32* data = fData == NULL ? fReadOnlyData : fData;
+	TRACE("BitmapBlock::_Update(%lu, %lu, %c, %c)\n", start, length,
-	if (data == NULL)
+		unmark ? 't' : 'f', force ? 't' : 'f');
-		return false;
-
-	if (start + length > fNumBits)
-		return false;
-	if (length == 0)
-		return true;
-
-	uint32 startIndex = start >> 5;
-	uint32 startBit = start & 0x1F;
-	uint32 remainingBits = (length + startBit) & 0x1F;
-
-	uint32 iterations;
-	
-	if (length < 32) {
-		if (startBit + length < 32) {
-			uint32 bits = B_LENDIAN_TO_HOST_INT32(data[startIndex]);
-
-			uint32 mask = (1 << (startBit + length)) - 1;
-			mask &= ~((1 << startBit) - 1);
-			
-			return (bits & mask) != 0;
-		} else
-			iterations = 0;
-	} else
-		iterations = (length - 32 + startBit) >> 5;
-
-	uint32 index = startIndex;
-	uint32 mask = 0;
-
-	if (startBit != 0) {
-		mask = ~((1 << startBit) - 1);
-		uint32 bits = B_LENDIAN_TO_HOST_INT32(data[index]);
-
-		if ((bits & mask) != mask) {
-			TRACE("BitmapBlock::CheckMarked(): failed\n");
-			return false;
-		}
-
-		index += 1;
-	} else
-		iterations++;
-
-	mask = 0xFFFFFFFF;
-	for (; iterations > 0; --iterations) {
-		if (data[index++] != mask) {
-			TRACE("BitmapBlock::CheckMarked(): failed at index %ld\n", index);
-			return false;
-		}
-	}
-
-	if (remainingBits != 0) {
-		mask = (1 << remainingBits) - 1;
-		uint32 bits = B_HOST_TO_LENDIAN_INT32(data[index]);
-
-		if ((bits & mask) != mask) {
-			TRACE("BitmapBlock::CheckMarked(): failed remaining\n");
-			return false;
-		}
-	}
-
-	return true;
-}
-
-
-/*virtual*/ bool
-BitmapBlock::Mark(uint32 start, uint32 length, bool force)
-{
-	if (fData == NULL || start + length > fNumBits)
-		return false;
-
-	uint32 startIndex = start >> 5;
-	uint32 startBit = start & 0x1F;
-	uint32 remainingBits = (length + startBit) & 0x1F;
-
-	uint32 iterations;
-	
-	if (length < 32) {
-		if (startBit + length < 32) {
-			uint32 bits = B_LENDIAN_TO_HOST_INT32(fData[startIndex]);
-
-			uint32 mask = (1 << (startBit + length)) - 1;
-			mask &= ~((1 << startBit) - 1);
-			
-			if ((bits & mask) != 0) {
-				ERROR("BitmapBlock::Mark() Marking failed bits %lx "
-					"startBit %ld\n", bits, startBit);
-				return false;
-			}
-			
-			bits |= mask;
-			
-			fData[startIndex] = B_HOST_TO_LENDIAN_INT32(bits);
-			
-			return true;
-		} else
-			iterations = 0;
-	} else
-		iterations = (length - 32 + startBit) >> 5;
-
-	uint32 index = startIndex;
-	uint32 mask = 0;
-	
-	TRACE("BitmapBlock::Mark(): start: %lu, length: %lu, startIndex: %lu, "
-		"startBit: %lu, iterations: %lu, remainingBits: %lu\n", start, length,
-		startIndex, startBit, iterations, remainingBits);
-
-	if (startBit != 0) {
-		mask = ~((1 << startBit) - 1);
-		uint32 bits = B_LENDIAN_TO_HOST_INT32(fData[index]);
-		
-		TRACE("BitmapBlock::Mark(): index %lu mask: %lX, bits: %lX\n", index,
-			mask, bits);
-
-		if (!force && (bits & mask) != 0) {
-			ERROR("BitmapBlock::Mark() Marking failed bits %lx "
-					"startBit %ld\n", bits, startBit);
-			return false;
-		}
-
-		bits |= mask;
-		fData[index] = B_HOST_TO_LENDIAN_INT32(bits);
-
-		index += 1;
-	} else
-		iterations++;
-
-	mask = 0xFFFFFFFF;
-	for (; iterations > 0; --iterations) {
-		if (!force && fData[index] != 0) {
-			ERROR("BitmapBlock::Mark() Marking failed "
-				"index %ld, iterations %ld\n", index, iterations);
-			return false;
-		}
-		fData[index++] |= mask;
-	}
-
-	if (remainingBits != 0) {
-		mask = (1 << remainingBits) - 1;
-		uint32 bits = B_LENDIAN_TO_HOST_INT32(fData[index]);
-		TRACE("BitmapBlock::Mark(): marking index %lu remaining %lu bits: %lX,"
-			" mask: %lX\n", index, remainingBits, bits, mask);
-
-		if (!force && (bits & mask) != 0) {
-			ERROR("BitmapBlock::Mark() Marking failed remaining\n");
-			return false;
-		}
-
-		bits |= mask;
-		fData[index] = B_HOST_TO_LENDIAN_INT32(bits);
-	}
-
-	return true;
-}
-
-
-/*virtual*/ bool
-BitmapBlock::Unmark(uint32 start, uint32 length, bool force)
-{
-	TRACE("BitmapBlock::Unmark(%lu, %lu, %c)\n", start, length,
-		force ? 't' : 'f');
 
 	if (fData == NULL || start + length > fNumBits)
 		return false;
@@ -303,29 +139,32 @@ BitmapBlock::Unmark(uint32 start, uint32 length, bool force)
 	uint32 startBit = start & 0x1F;
 	uint32 remainingBits = (length + startBit) & 0x1F;
 
-	TRACE("BitmapBlock::Unmark(): start index: %lu, start bit: %lu, remaining "
+	TRACE("BitmapBlock::_Update(): start index: %lu, start bit: %lu, remaining "
 		"bits: %lu)\n", startIndex, startBit, remainingBits);
 	uint32 iterations;
        
 	if (length < 32) {
 		if (startBit + length < 32) {
 			uint32 bits = B_LENDIAN_TO_HOST_INT32(fData[startIndex]);
-			TRACE("BitmapBlock::Unmark(): bits: %lx\n", bits);
+			TRACE("BitmapBlock::_Update(): bits: %lx\n", bits);
 
 			uint32 mask = (1 << (startBit + length)) - 1;
 			mask &= ~((1 << startBit) - 1);
 		       
-			TRACE("BitmapBlock::Unmark(): mask: %lx\n", mask);
+			TRACE("BitmapBlock::_Update(): mask: %lx\n", mask);
 
-			if ((bits & mask) != mask) {
+			if ((bits & mask) != (mark ? 0 : mask)) {
-				ERROR("BitmapBlock::Unmark() Marking failed bits %lx "
+				ERROR("BitmapBlock::_Update() Marking failed bits %lx "
 					"startBit %ld\n", bits, startBit);
 				return false;
 			}
 		       
+			if (mark)
+			    bits |= mask;
+			else
 			    bits &= ~mask;
 		       
-			TRACE("BitmapBlock::Unmark(): updated bits: %lx\n", bits);
+			TRACE("BitmapBlock::_Update(): updated bits: %lx\n", bits);
 			fData[startIndex] = B_HOST_TO_LENDIAN_INT32(bits);
 		       
 			return true;
@@ -334,74 +173,64 @@ BitmapBlock::Unmark(uint32 start, uint32 length, bool force)
 	} else
 		iterations = (length - 32 + startBit) >> 5;
 
-	TRACE("BitmapBlock::Unmark(): iterations: %lu\n", iterations);
+	TRACE("BitmapBlock::_Update(): iterations: %lu\n", iterations);
 	uint32 index = startIndex;
-	uint32 mask = 0;
 	
 	if (startBit != 0) {
-		mask = ~((1 << startBit) - 1);
+		uint32 mask = ~((1 << startBit) - 1);
 		uint32 bits = B_LENDIAN_TO_HOST_INT32(fData[index]);
 
-		TRACE("BitmapBlock::Unmark(): mask: %lx, bits: %lx\n", mask, bits);
+		TRACE("BitmapBlock::_Update(): mask: %lx, bits: %lx\n", mask, bits);
 
-		if (!force && (bits & mask) != mask)
+		if (!force && (bits & mask) != (mark ? 0 : mask))
 			return false;
 
+		if (mark)
+			bits |= mask;
+		else
 			bits &= ~mask;
 		fData[index] = B_HOST_TO_LENDIAN_INT32(bits);
 
-		TRACE("BitmapBlock::Unmark(): updated bits: %lx\n", bits);
+		TRACE("BitmapBlock::_Update(): updated bits: %lx\n", bits);
 		index += 1;
 	} else
 		iterations++;
 
-	mask = 0xFFFFFFFF;
 	for (; iterations > 0; --iterations) {
-		if (!force && fData[index] != mask) {
+		if (!force && fData[index] != (mark ? 0 : 0xFFFFFFFF)) {
-			ERROR("BitmapBlock::Unmark() Marking failed "
+			ERROR("BitmapBlock::_Update() Marking failed "
 				"index %ld, iterations %ld\n", index, iterations);
 			return false;
 		}
-		fData[index++] = 0;
+		fData[index++] = (mark ? 0xFFFFFFFF : 0);
 	}
 
-	TRACE("BitmapBlock::Unmark(): Finished iterations\n");
+	TRACE("BitmapBlock::_Update(): Finished iterations\n");
 
 	if (remainingBits != 0) {
-		mask = (1 << remainingBits) - 1;
+		uint32 mask = (1 << remainingBits) - 1;
 		uint32 bits = B_LENDIAN_TO_HOST_INT32(fData[index]);
 
-		TRACE("BitmapBlock::Unmark(): mask: %lx, bits: %lx\n", mask, bits);
+		TRACE("BitmapBlock::_Update(): mask: %lx, bits: %lx\n", mask, bits);
 
-		if (!force && (bits & mask) != mask) {
+		if (!force && (bits & mask) != (mark ? 0 : mask)) {
-			ERROR("BitmapBlock::Unmark() Marking failed remaining\n");
+			ERROR("BitmapBlock::_Update() Marking failed remaining\n");
 			return false;
 		}
 
+		if (mark)
+			bits |= mask;
+		else
 			bits &= ~mask;
 		fData[index] = B_HOST_TO_LENDIAN_INT32(bits);
 
-		TRACE("BitmapBlock::Unmark(): updated bits: %lx\n", bits);
+		TRACE("BitmapBlock::_Update(): updated bits: %lx\n", bits);
 	}
 
 	return true;
 }
 
 
-void
-BitmapBlock::FindNextMarked(uint32& pos)
-{
-	_FindNext(pos, true);
-}
-
-
-void
-BitmapBlock::FindNextUnmarked(uint32& pos)
-{
-	_FindNext(pos, false);
-}
-
-
 void
 BitmapBlock::_FindNext(uint32& pos, bool marked)
 {

src/add-ons/kernel/file_systems/ext2/BitmapBlock.h

@@ -40,7 +40,10 @@ public:
 			uint32			NumBits() const { return fNumBits; }
 
 private:
+			bool			_Check(uint32 start, uint32 length, bool marked);
 			void			_FindNext(uint32& pos, bool marked);
+			bool			_Update(uint32 start, uint32 length, bool mark,
+								bool force);
 
 			uint32*			fData;
 			const uint32*	fReadOnlyData;
@@ -49,4 +52,47 @@ private:
 			uint32			fMaxIndex;
 };
 
+
+inline bool
+BitmapBlock::CheckUnmarked(uint32 start, uint32 length)
+{
+	return _Check(start, length, false);
+}
+
+
+inline bool
+BitmapBlock::CheckMarked(uint32 start, uint32 length)
+{
+	return _Check(start, length, true);
+}
+
+
+inline bool
+BitmapBlock::Mark(uint32 start, uint32 length, bool force)
+{
+	return _Update(start, length, true, force);
+}
+
+
+inline bool
+BitmapBlock::Unmark(uint32 start, uint32 length, bool force)
+{
+	return _Update(start, length, false, force);
+}
+
+
+inline void
+BitmapBlock::FindNextMarked(uint32& pos)
+{
+	_FindNext(pos, true);
+}
+
+
+inline void
+BitmapBlock::FindNextUnmarked(uint32& pos)
+{
+	_FindNext(pos, false);
+}
+
+
 #endif	// BITMAPBLOCK_H