From ce4e12ca3e341178e3df50ef67cf7c1d724e9559 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=A9r=C3=B4me=20Duval?= <jerome.duval@gmail.com>
Date: Wed, 10 Oct 2018 22:08:43 +0200
Subject: [PATCH] ext2: implements metadata_csum and 64bit features.

* Some PVS-Studio warnings are removed.
* fixes hardlink count in source and destination folders on rename.
* tested with fstorture and fsx (one job).
* add new definitions.
* import crc32c code from BSD.
* add some consistency checks at mount.
* DirectoryIterator::_AllocateBestEntryInBlock(), the direntry is checked for
consistency before using it, which should avoid crashing on bad data.
* DirectoryIterator::_SplitIndexedBlock(): the dotdot entry length should
include the dot and dotdot entries length.

Change-Id: I0f80d73b65b1ae6ddb2e746a6f85ef806f23dbb0
Reviewed-on: https://review.haiku-os.org/c/haiku/+/1735
Reviewed-by: waddlesplash <waddlesplash@gmail.com>
---
 .../kernel/file_systems/ext2/BitmapBlock.cpp  |  13 +
 .../kernel/file_systems/ext2/BitmapBlock.h    |   2 +
 .../file_systems/ext2/BlockAllocator.cpp      |  75 +-
 .../kernel/file_systems/ext2/CRCTable.h       |   8 +
 .../kernel/file_systems/ext2/DataStream.cpp   |   4 +-
 .../file_systems/ext2/DirectoryIterator.cpp   | 198 ++++-
 .../file_systems/ext2/DirectoryIterator.h     |  14 +
 .../kernel/file_systems/ext2/ExtentStream.cpp |  11 +-
 .../kernel/file_systems/ext2/ExtentStream.h   |   6 +-
 .../kernel/file_systems/ext2/HTree.cpp        |   1 +
 .../file_systems/ext2/HTreeEntryIterator.cpp  |  58 +-
 .../file_systems/ext2/HTreeEntryIterator.h    |   4 +
 .../file_systems/ext2/HashRevokeManager.cpp   |   4 +-
 .../file_systems/ext2/HashRevokeManager.h     |   2 +-
 .../kernel/file_systems/ext2/Inode.cpp        | 186 ++++-
 src/add-ons/kernel/file_systems/ext2/Inode.h  |  13 +
 .../file_systems/ext2/InodeAllocator.cpp      |  49 +-
 .../kernel/file_systems/ext2/InodeAllocator.h |   8 +-
 .../kernel/file_systems/ext2/InodeJournal.cpp |   2 +-
 src/add-ons/kernel/file_systems/ext2/Jamfile  |   2 +
 .../kernel/file_systems/ext2/Journal.cpp      | 121 ++-
 .../kernel/file_systems/ext2/Journal.h        |  88 +-
 .../file_systems/ext2/RevokeManager.cpp       |   5 +-
 .../kernel/file_systems/ext2/RevokeManager.h  |   3 +-
 .../kernel/file_systems/ext2/Volume.cpp       | 117 ++-
 src/add-ons/kernel/file_systems/ext2/Volume.h |  21 +-
 src/add-ons/kernel/file_systems/ext2/crc32.c  | 763 ++++++++++++++++++
 src/add-ons/kernel/file_systems/ext2/ext2.h   |  72 +-
 .../file_systems/ext2/kernel_interface.cpp    |  88 +-
 29 files changed, 1761 insertions(+), 177 deletions(-)
 create mode 100644 src/add-ons/kernel/file_systems/ext2/crc32.c

diff --git a/src/add-ons/kernel/file_systems/ext2/BitmapBlock.cpp b/src/add-ons/kernel/file_systems/ext2/BitmapBlock.cpp
index fcd5147640..65eec84a68 100644
--- a/src/add-ons/kernel/file_systems/ext2/BitmapBlock.cpp
+++ b/src/add-ons/kernel/file_systems/ext2/BitmapBlock.cpp
@@ -10,6 +10,8 @@
 
 #include "BitmapBlock.h"
 
+#include "CRCTable.h"
+
 
 //#define TRACE_EXT2
 #ifdef TRACE_EXT2
@@ -23,6 +25,7 @@
 BitmapBlock::BitmapBlock(Volume* volume, uint32 numBits)
 	:
 	CachedBlock(volume),
+	fVolume(volume),
 	fData(NULL),
 	fReadOnlyData(NULL),
 	fNumBits(numBits),
@@ -513,3 +516,13 @@ BitmapBlock::FindLargestUnmarkedRange(uint32& start, uint32& length)
 	}
 }
 
+
+uint32
+BitmapBlock::Checksum(uint32 unitsPerGroup) const
+{
+	const uint32* data = fData == NULL ? fReadOnlyData : fData;
+	if (data == NULL)
+		panic("BitmapBlock::Checksum() data is NULL\n");
+	return calculate_crc32c(fVolume->ChecksumSeed(),
+		(uint8*)data, unitsPerGroup / 8);
+}
diff --git a/src/add-ons/kernel/file_systems/ext2/BitmapBlock.h b/src/add-ons/kernel/file_systems/ext2/BitmapBlock.h
index 4dc626d4bf..183c9cd539 100644
--- a/src/add-ons/kernel/file_systems/ext2/BitmapBlock.h
+++ b/src/add-ons/kernel/file_systems/ext2/BitmapBlock.h
@@ -38,6 +38,7 @@ public:
 								uint32& length);
 
 			uint32			NumBits() const { return fNumBits; }
+			uint32			Checksum(uint32 unitsPerGroup) const;
 
 private:
 			bool			_Check(uint32 start, uint32 length, bool marked);
@@ -45,6 +46,7 @@ private:
 			bool			_Update(uint32 start, uint32 length, bool mark,
 								bool force);
 
+			Volume*			fVolume;
 			uint32*			fData;
 			const uint32*	fReadOnlyData;
 
diff --git a/src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp b/src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp
index bb4f85edfc..5151f8cd5d 100644
--- a/src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp
+++ b/src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp
@@ -57,12 +57,14 @@ public:
 			void		RemovedFromTransaction();
 
 private:
-			status_t	_ScanFreeRanges();
+			status_t	_ScanFreeRanges(bool verify = false);
 			void		_AddFreeRange(uint32 start, uint32 length);
 			void		_LockInTransaction(Transaction& transaction);
 			status_t	_InitGroup(Transaction& transaction);
 			bool		_IsSparse();
 			uint32		_FirstFreeBlock();
+			void		_SetBlockBitmapChecksum(BitmapBlock& block);
+			bool		_VerifyBlockBitmapChecksum(BitmapBlock& block);
 
 			Volume*		fVolume;
 			uint32		fBlockGroup;
@@ -93,6 +95,7 @@ AllocationBlockGroup::AllocationBlockGroup()
 	fVolume(NULL),
 	fBlockGroup(0),
 	fGroupDescriptor(NULL),
+	fCurrentTransaction(-1),
 	fStart(0),
 	fNumBits(0),
 	fBitmapBlock(0),
@@ -131,6 +134,11 @@ AllocationBlockGroup::Initialize(Volume* volume, uint32 blockGroup,
 		return status;
 
 	fBitmapBlock = fGroupDescriptor->BlockBitmap(fVolume->Has64bitFeature());
+	if (fBitmapBlock == 0) {
+		ERROR("AllocationBlockGroup(%" B_PRIu32 ")::Initialize(): "
+			"blockBitmap is zero\n", fBlockGroup);
+		return B_BAD_VALUE;
+	}
 
 	if (fGroupDescriptor->Flags() & EXT2_BLOCK_GROUP_BLOCK_UNINIT) {
 		fFreeBits = fGroupDescriptor->FreeBlocks(fVolume->Has64bitFeature());
@@ -140,7 +148,7 @@ AllocationBlockGroup::Initialize(Volume* volume, uint32 blockGroup,
 		return B_OK;
 	}
 	
-	status = _ScanFreeRanges();
+	status = _ScanFreeRanges(true);
 	if (status != B_OK)
 		return status;
 
@@ -164,7 +172,7 @@ AllocationBlockGroup::Initialize(Volume* volume, uint32 blockGroup,
 
 
 status_t
-AllocationBlockGroup::_ScanFreeRanges()
+AllocationBlockGroup::_ScanFreeRanges(bool verify)
 {
 	TRACE("AllocationBlockGroup::_ScanFreeRanges() for group %" B_PRIu32 "\n",
 		fBlockGroup);
@@ -173,6 +181,12 @@ AllocationBlockGroup::_ScanFreeRanges()
 	if (!block.SetTo(fBitmapBlock))
 		return B_ERROR;
 
+	if (verify && !_VerifyBlockBitmapChecksum(block)) {
+		ERROR("AllocationBlockGroup(%" B_PRIu32 ")::_ScanFreeRanges(): "
+			"blockGroup verification failed\n", fBlockGroup);
+		return B_BAD_DATA;
+	}
+
 	fFreeBits = 0;
 	uint32 start = 0;
 	uint32 end = 0;
@@ -235,6 +249,7 @@ AllocationBlockGroup::Allocate(Transaction& transaction, fsblock_t _start,
 
 	fFreeBits -= length;
 	fGroupDescriptor->SetFreeBlocks(fFreeBits, fVolume->Has64bitFeature());
+	_SetBlockBitmapChecksum(block);
 	fVolume->WriteBlockGroup(transaction, fBlockGroup);
 
 	if (start == fLargestStart) {
@@ -338,6 +353,7 @@ AllocationBlockGroup::Free(Transaction& transaction, uint32 start,
 
 	fFreeBits += length;
 	fGroupDescriptor->SetFreeBlocks(fFreeBits, fVolume->Has64bitFeature());
+	_SetBlockBitmapChecksum(block);
 	fVolume->WriteBlockGroup(transaction, fBlockGroup);
 
 	return B_OK;
@@ -434,10 +450,12 @@ AllocationBlockGroup::_InitGroup(Transaction& transaction)
 	BitmapBlock blockBitmap(fVolume, fNumBits);
 	if (!blockBitmap.SetToWritable(transaction, fBitmapBlock))
 		return B_ERROR;
+
 	blockBitmap.Mark(0, _FirstFreeBlock(), true);
 	blockBitmap.Unmark(0, fNumBits, true);
 	
 	fGroupDescriptor->SetFlags(flags & ~EXT2_BLOCK_GROUP_BLOCK_UNINIT);
+	_SetBlockBitmapChecksum(blockBitmap);
 	fVolume->WriteBlockGroup(transaction, fBlockGroup);
 
 	status_t status = _ScanFreeRanges();
@@ -504,6 +522,36 @@ AllocationBlockGroup::_FirstFreeBlock()
 }
 
 
+void
+AllocationBlockGroup::_SetBlockBitmapChecksum(BitmapBlock& block)
+{
+	if (fVolume->HasMetaGroupChecksumFeature()) {
+		uint32 checksum = block.Checksum(fVolume->BlocksPerGroup());
+		fGroupDescriptor->block_bitmap_csum = checksum & 0xffff;
+		if (fVolume->GroupDescriptorSize() >= offsetof(ext2_block_group,
+			inode_bitmap_high)) {
+			fGroupDescriptor->block_bitmap_csum_high = checksum >> 16;
+		}
+	}
+}
+
+
+bool
+AllocationBlockGroup::_VerifyBlockBitmapChecksum(BitmapBlock& block) {
+	if (fVolume->HasMetaGroupChecksumFeature()) {
+		uint32 checksum = block.Checksum(fVolume->BlocksPerGroup());
+		uint32 provided = fGroupDescriptor->block_bitmap_csum;
+		if (fVolume->GroupDescriptorSize() >= offsetof(ext2_block_group,
+			inode_bitmap_high)) {
+			provided |= (fGroupDescriptor->block_bitmap_csum_high << 16);
+		} else
+			checksum &= 0xffff;
+		return provided == checksum;
+	}
+	return true;
+}
+
+
 void
 AllocationBlockGroup::TransactionDone(bool success)
 {
@@ -539,7 +587,8 @@ BlockAllocator::BlockAllocator(Volume* volume)
 	fGroups(NULL),
 	fBlocksPerGroup(0),
 	fNumBlocks(0),
-	fNumGroups(0)
+	fNumGroups(0),
+	fFirstBlock(0)
 {
 	mutex_init(&fLock, "ext2 block allocator");
 }
@@ -576,18 +625,19 @@ BlockAllocator::Initialize()
 	mutex_lock(&fLock);
 		// Released by _Initialize
 
-	thread_id id = -1; // spawn_kernel_thread(
-		// (thread_func)BlockAllocator::_Initialize, "ext2 block allocator",
-		// B_LOW_PRIORITY, this);
+#if 0
+	thread_id id = spawn_kernel_thread(
+		(thread_func)BlockAllocator::_Initialize, "ext2 block allocator",
+		B_LOW_PRIORITY, this);
 	if (id < B_OK)
 		return _Initialize(this);
 
-	// mutex_transfer_lock(&fLock, id);
+	mutex_transfer_lock(&fLock, id);
 
-	// return resume_thread(id);
-	panic("Failed to fall back to synchronous block allocator"
-		"initialization.\n");
-	return B_ERROR;
+	return resume_thread(id);
+#else
+	return _Initialize(this);
+#endif
 }
 
 
@@ -866,3 +916,4 @@ BlockAllocator::_Initialize(BlockAllocator* allocator)
 
 	return B_OK;
 }
+
diff --git a/src/add-ons/kernel/file_systems/ext2/CRCTable.h b/src/add-ons/kernel/file_systems/ext2/CRCTable.h
index fc42724579..04d802d2aa 100644
--- a/src/add-ons/kernel/file_systems/ext2/CRCTable.h
+++ b/src/add-ons/kernel/file_systems/ext2/CRCTable.h
@@ -6,6 +6,14 @@
  *		Jérôme Duval
  */
 
+
+#include <sys/cdefs.h>
+
+
 uint16 calculate_crc(uint16 crc, uint8 *data, uint16 length);
 
+__BEGIN_DECLS
+uint32 calculate_crc32c(uint32 crc32c, const unsigned char *buffer,
+	unsigned int length);
+__END_DECLS
 
diff --git a/src/add-ons/kernel/file_systems/ext2/DataStream.cpp b/src/add-ons/kernel/file_systems/ext2/DataStream.cpp
index 54ed139f56..8d6891ef0a 100644
--- a/src/add-ons/kernel/file_systems/ext2/DataStream.cpp
+++ b/src/add-ons/kernel/file_systems/ext2/DataStream.cpp
@@ -166,7 +166,7 @@ DataStream::FindBlock(off_t offset, fsblock_t& block, uint32 *_count)
 		ASSERT(block != 0);
 	} else {
 		// Outside of the possible data stream
-		dprintf("ext2: block outside datastream!\n");
+		ERROR("ext2: block outside datastream!\n");
 		return B_ERROR;
 	}
 
@@ -384,6 +384,8 @@ DataStream::_GetBlock(Transaction& transaction, uint32& blockNum)
 			ERROR("DataStream::_GetBlock(): AllocateBlocks() failed()\n");
 			return status;
 		}
+		if (fAllocatedPos > UINT_MAX)
+			return B_FILE_TOO_LARGE;
 
 		fWaiting -= fAllocated;
 
diff --git a/src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp b/src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp
index a1e4eb312e..25616a5279 100644
--- a/src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp
+++ b/src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp
@@ -12,6 +12,7 @@
 #include <util/VectorSet.h>
 
 #include "CachedBlock.h"
+#include "CRCTable.h"
 #include "HTree.h"
 #include "Inode.h"
 
@@ -19,8 +20,10 @@
 //#define TRACE_EXT2
 #ifdef TRACE_EXT2
 #	define TRACE(x...) dprintf("\33[34mext2:\33[0m " x)
+#	define ASSERT(x) { if (!(x)) kernel_debugger("ext2: assert failed: " #x "\n"); }
 #else
 #	define TRACE(x...) ;
+#	define ASSERT(x) ;
 #endif
 
 
@@ -94,6 +97,8 @@ DirectoryIterator::Get(char* name, size_t* _nameLength, ino_t* _id)
 	if (block == NULL)
 		return B_IO_ERROR;
 
+	ASSERT(_CheckBlock(block));
+
 	TRACE("DirectoryIterator::Get(): Displacement: %" B_PRIu32 "\n",
 		fDisplacement);
 	const ext2_dir_entry* entry = (const ext2_dir_entry*)&block[fDisplacement];
@@ -161,6 +166,9 @@ DirectoryIterator::Next()
 	if (block == NULL)
 		return B_IO_ERROR;
 
+	ASSERT(_CheckBlock(block));
+	uint32 maxSize = _MaxSize();
+
 	entry = (ext2_dir_entry*)(block + fDisplacement);
 
 	do {
@@ -176,9 +184,9 @@ DirectoryIterator::Next()
 			fPreviousDisplacement = fDisplacement;
 			fDisplacement += entry->Length();
 		} else 
-			fDisplacement = fBlockSize;
+			fDisplacement = maxSize;
 
-		if (fDisplacement == fBlockSize) {
+		if (fDisplacement == maxSize) {
 			TRACE("Reached end of block\n");
 
 			fDisplacement = 0;
@@ -199,7 +207,9 @@ DirectoryIterator::Next()
 			block = cached.SetTo(fPhysicalBlock);
 			if (block == NULL)
 				return B_IO_ERROR;
-		} else if (fDisplacement > fBlockSize) {
+			ASSERT(_CheckBlock(block));
+
+		} else if (fDisplacement > maxSize) {
 			TRACE("The entry isn't block aligned.\n");
 			// TODO: Is block alignment obligatory?
 			return B_BAD_DATA;
@@ -344,6 +354,7 @@ DirectoryIterator::RemoveEntry(Transaction& transaction)
 	CachedBlock cached(fVolume);
 
 	uint8* block = cached.SetToWritable(transaction, fPhysicalBlock);
+	uint32 maxSize = _MaxSize();
 
 	if (fDisplacement == 0) {
 		previousEntry = (ext2_dir_entry*)&block[fDisplacement];
@@ -351,11 +362,11 @@ DirectoryIterator::RemoveEntry(Transaction& transaction)
 		fPreviousDisplacement = fDisplacement;
 		fDisplacement += previousEntry->Length();
 
-		if (fDisplacement == fBlockSize) {
+		if (fDisplacement == maxSize) {
 			previousEntry->SetInodeID(0);
 			fDisplacement = 0;
 			return B_OK;
-		} else if (fDisplacement > fBlockSize) {
+		} else if (fDisplacement > maxSize) {
 			TRACE("DirectoryIterator::RemoveEntry(): Entry isn't aligned to "
 				"block entry.");
 			return B_BAD_DATA;
@@ -368,6 +379,10 @@ DirectoryIterator::RemoveEntry(Transaction& transaction)
 		previousEntry->SetLength(fDisplacement - fPreviousDisplacement
 			+ previousEntry->Length());
 
+		fDirectory->SetDirEntryChecksum(block);
+
+		ASSERT(_CheckBlock(block));
+
 		return B_OK;
 	}
 
@@ -397,6 +412,10 @@ DirectoryIterator::RemoveEntry(Transaction& transaction)
 	memset(&block[fDisplacement], 0, 
 		fPreviousDisplacement + previousEntry->Length() - fDisplacement);
 
+	fDirectory->SetDirEntryChecksum(block);
+
+	ASSERT(_CheckBlock(block));
+
 	return B_OK;
 }
 
@@ -415,6 +434,10 @@ DirectoryIterator::ChangeEntry(Transaction& transaction, ino_t id,
 	dirEntry->SetInodeID(id);
 	dirEntry->file_type = fileType;
 
+	fDirectory->SetDirEntryChecksum(block);
+
+	ASSERT(_CheckBlock(block));
+
 	return B_OK;
 }
 
@@ -427,24 +450,28 @@ DirectoryIterator::_AllocateBestEntryInBlock(uint8 nameLength, uint16& pos,
 	CachedBlock cached(fVolume);
 	const uint8* block = cached.SetTo(fPhysicalBlock);
 
-	uint16 requiredLength = nameLength + 8;
-	if (requiredLength % 4 != 0)
-		requiredLength += 4 - requiredLength % 4;
+	ASSERT(_CheckBlock(block));
+
+	uint16 requiredLength = EXT2_DIR_REC_LEN(nameLength);
+	uint32 maxSize = _MaxSize();
 	
-	uint16 bestPos = fBlockSize;
-	uint16 bestLength = fBlockSize;
-	uint16 bestRealLength = fBlockSize;
+	uint16 bestPos = maxSize;
+	uint16 bestLength = maxSize;
+	uint16 bestRealLength = maxSize;
 	ext2_dir_entry* dirEntry;
 	
-	while (pos < fBlockSize) {
+	while (pos < maxSize) {
 		dirEntry = (ext2_dir_entry*)&block[pos];
+		if (!_CheckDirEntry(dirEntry, block)) {
+			TRACE("DirectoryIterator::_AllocateBestEntryInBlock(): invalid "
+				"dirEntry->Length() pos %d\n", pos);
+			return B_BAD_DATA;
+		}
 
-		uint16 realLength = dirEntry->NameLength() + 8;
-
-		if (realLength % 4 != 0)
-			realLength += 4 - realLength % 4;
-
-		uint16 emptySpace = dirEntry->Length() - realLength;
+		uint16 realLength = EXT2_DIR_REC_LEN(dirEntry->NameLength());
+		uint16 emptySpace = dirEntry->Length();
+		if (dirEntry->InodeID() != 0)
+			emptySpace -= realLength;
 		if (emptySpace == requiredLength) {
 			// Found an exact match
 			TRACE("DirectoryIterator::_AllocateBestEntryInBlock(): Found an "
@@ -461,7 +488,7 @@ DirectoryIterator::_AllocateBestEntryInBlock(uint8 nameLength, uint16& pos,
 		pos += dirEntry->Length();
 	}
 	
-	if (bestPos == fBlockSize)
+	if (bestPos == maxSize)
 		return B_DEVICE_FULL;
 
 	TRACE("DirectoryIterator::_AllocateBestEntryInBlock(): Found a suitable "
@@ -503,6 +530,10 @@ DirectoryIterator::_AddEntry(Transaction& transaction, const char* name,
 	dirEntry->file_type = type;
 	memcpy(dirEntry->name, name, nameLength);
 
+	fDirectory->SetDirEntryChecksum(block);
+
+	ASSERT(_CheckBlock(block));
+
 	TRACE("DirectoryIterator::_AddEntry(): Done\n");
 
 	return B_OK;
@@ -526,6 +557,7 @@ DirectoryIterator::_SplitIndexedBlock(Transaction& transaction,
 	ArrayDeleter<uint8> bufferDeleter(buffer);
 
 	fsblock_t firstPhysicalBlock = 0;
+	uint32 maxSize = _MaxSize();
 
 	// Prepare block to hold the first half of the entries and fill the buffer
 	CachedBlock cachedFirst(fVolume);
@@ -576,13 +608,13 @@ DirectoryIterator::_SplitIndexedBlock(Transaction& transaction,
 		root = (HTreeRoot*)secondBlock;
 
 		HTreeFakeDirEntry* dotdot = &root->dotdot;
-		dotdot->SetEntryLength(fBlockSize - (sizeof(HTreeFakeDirEntry) + 4));
+		dotdot->SetEntryLength(maxSize);
 
 		root->hash_version = fVolume->DefaultHashVersion();
 		root->root_info_length = 8;
 		root->indirection_levels = 0;
 
-		root->count_limit->SetLimit((fBlockSize
+		root->count_limit->SetLimit((maxSize
 			- ((uint8*)root->count_limit - secondBlock)) / sizeof(HTreeEntry));
 		root->count_limit->SetCount(2);
 	}
@@ -600,7 +632,7 @@ DirectoryIterator::_SplitIndexedBlock(Transaction& transaction,
 	HashedEntry entry;
 	ext2_dir_entry* dirEntry = NULL;
 
-	while (displacement < fBlockSize) {
+	while (displacement < maxSize) {
 		entry.position = &buffer[displacement];
 		dirEntry = (ext2_dir_entry*)entry.position;
 
@@ -626,9 +658,7 @@ DirectoryIterator::_SplitIndexedBlock(Transaction& transaction,
 	// Prepare the new entry to be included as well
 	ext2_dir_entry newEntry;
 
-	uint16 newLength = (uint16)nameLength + 8;
-	if (newLength % 4 != 0)
-		newLength += 4 - newLength % 4;
+	uint16 newLength = EXT2_DIR_REC_LEN(nameLength);
 
 	newEntry.name_length = nameLength;
 	newEntry.SetLength(newLength);
@@ -656,9 +686,7 @@ DirectoryIterator::_SplitIndexedBlock(Transaction& transaction,
 		dirEntry = (ext2_dir_entry*)(*iterator).position;
 		previousHash = (*iterator).hash;
 
-		uint32 realLength = (uint32)dirEntry->name_length + 8;
-		if (realLength % 4 != 0)
-			realLength += 4 - realLength % 4;
+		uint32 realLength = EXT2_DIR_REC_LEN(dirEntry->name_length);
 
 		dirEntry->SetLength((uint16)realLength);
 		memcpy(&firstBlock[displacement], dirEntry, realLength);
@@ -670,7 +698,9 @@ DirectoryIterator::_SplitIndexedBlock(Transaction& transaction,
 	// Update last entry in the block
 	uint16 oldLength = dirEntry->Length();
 	dirEntry = (ext2_dir_entry*)&firstBlock[displacement - oldLength];
-	dirEntry->SetLength(fBlockSize - displacement + oldLength);
+	dirEntry->SetLength(maxSize - displacement + oldLength);
+
+	fDirectory->SetDirEntryChecksum(firstBlock);
 
 	bool collision = false;
 
@@ -681,7 +711,7 @@ DirectoryIterator::_SplitIndexedBlock(Transaction& transaction,
 		// This isn't the ideal solution, but it is a rare occurance
 		dirEntry = (ext2_dir_entry*)(*iterator).position;
 
-		if (displacement + dirEntry->Length() > fBlockSize) {
+		if (displacement + dirEntry->Length() > maxSize) {
 			// Doesn't fit on the block
 			collision = true;
 			break;
@@ -707,8 +737,10 @@ DirectoryIterator::_SplitIndexedBlock(Transaction& transaction,
 		htreeEntry->SetBlock(2);
 		htreeEntry->SetHash(medianHash);
 
+
 		off_t start = (off_t)root->root_info_length
 			+ 2 * (sizeof(HTreeFakeDirEntry) + 4);
+		_SetHTreeEntryChecksum(secondBlock, start, 2);
 		fParent = new(std::nothrow) HTreeEntryIterator(start, fDirectory);
 		if (fParent == NULL)
 			return B_NO_MEMORY;
@@ -750,9 +782,7 @@ DirectoryIterator::_SplitIndexedBlock(Transaction& transaction,
 	while (iterator != end) {
 		dirEntry = (ext2_dir_entry*)(*iterator).position;
 
-		uint32 realLength = (uint32)dirEntry->name_length + 8;
-		if (realLength % 4 != 0)
-			realLength += 4 - realLength % 4;
+		uint32 realLength = EXT2_DIR_REC_LEN(dirEntry->name_length);
 
 		dirEntry->SetLength((uint16)realLength);
 		memcpy(&secondBlock[displacement], dirEntry, realLength);
@@ -764,7 +794,12 @@ DirectoryIterator::_SplitIndexedBlock(Transaction& transaction,
 	// Update last entry in the block
 	oldLength = dirEntry->Length();
 	dirEntry = (ext2_dir_entry*)&secondBlock[displacement - oldLength];
-	dirEntry->SetLength(fBlockSize - displacement + oldLength);
+	dirEntry->SetLength(maxSize - displacement + oldLength);
+
+	fDirectory->SetDirEntryChecksum(secondBlock);
+
+	ASSERT(_CheckBlock(firstBlock));
+	ASSERT(_CheckBlock(secondBlock));
 
 	TRACE("DirectoryIterator::_SplitIndexedBlock(): Done\n");
 	return B_OK;
@@ -793,3 +828,98 @@ DirectoryIterator::_NextBlock()
 
 	return B_OK;
 }
+
+
+bool
+DirectoryIterator::_CheckDirEntry(const ext2_dir_entry* dirEntry, const uint8* buffer)
+{
+	const char *errmsg = NULL;
+	if (dirEntry->Length() < EXT2_DIR_REC_LEN(1))
+		errmsg = "Length is too small";
+	else if (dirEntry->Length() % 4 != 0)
+		errmsg = "Length is not a multiple of 4";
+	else if (dirEntry->Length() < EXT2_DIR_REC_LEN(dirEntry->NameLength()))
+		errmsg = "Length is too short for the name";
+	else if (((uint8*)dirEntry - buffer) + dirEntry->Length() > fBlockSize)
+		errmsg = "Length is too big for the blocksize";
+
+	TRACE("DirectoryIterator::_CheckDirEntry() %s\n", errmsg);
+	return errmsg == NULL;
+}
+
+
+status_t
+DirectoryIterator::_CheckBlock(const uint8* buffer)
+{
+	uint32 maxSize = fBlockSize;
+	if (fVolume->HasMetaGroupChecksumFeature())
+		maxSize -= sizeof(ext2_dir_entry_tail);
+
+	status_t err = B_OK;
+	uint16 pos = 0;
+	while (pos < maxSize) {
+		const ext2_dir_entry *dirEntry = (const ext2_dir_entry*)&buffer[pos];
+
+		if (!_CheckDirEntry(dirEntry, buffer)) {
+			TRACE("DirectoryIterator::_CheckBlock(): invalid "
+				"dirEntry pos %d\n", pos);
+			err = B_BAD_DATA;
+		}
+
+		pos += dirEntry->Length();
+	}
+	return err;
+}
+
+
+ext2_htree_tail*
+DirectoryIterator::_HTreeEntryTail(uint8* block, uint16 offset) const
+{
+	HTreeEntry* entries = (HTreeEntry*)block;
+	uint16 firstEntry = offset % fBlockSize / sizeof(HTreeEntry);
+	HTreeCountLimit* countLimit = (HTreeCountLimit*)&entries[firstEntry];
+	uint16 limit = countLimit->Limit();
+	TRACE("HTreeEntryIterator::_HTreeEntryTail() %p %p\n", block, &entries[firstEntry + limit]);
+	return (ext2_htree_tail*)(&entries[firstEntry + limit]);
+}
+
+
+uint32
+DirectoryIterator::_HTreeRootChecksum(uint8* block, uint16 offset, uint16 count) const
+{
+	uint32 number = fDirectory->ID();
+	uint32 checksum = calculate_crc32c(fVolume->ChecksumSeed(),
+		(uint8*)&number, sizeof(number));
+	uint32 gen = fDirectory->Node().generation;
+	checksum = calculate_crc32c(checksum, (uint8*)&gen, sizeof(gen));
+	checksum = calculate_crc32c(checksum, block,
+		offset + count * sizeof(HTreeEntry));
+	TRACE("HTreeEntryIterator::_HTreeRootChecksum() size %u\n", offset + count * sizeof(HTreeEntry));
+	ext2_htree_tail dummy;
+	dummy.reserved = 0;
+	checksum = calculate_crc32c(checksum, (uint8*)&dummy, sizeof(dummy));
+	return checksum;
+}
+
+
+void
+DirectoryIterator::_SetHTreeEntryChecksum(uint8* block, uint16 offset, uint16 count)
+{
+	TRACE("DirectoryIterator::_SetHTreeEntryChecksum()\n");
+	if (fVolume->HasMetaGroupChecksumFeature()) {
+		ext2_htree_tail* tail = _HTreeEntryTail(block, offset);
+		tail->reserved = 0x0;
+		tail->checksum = _HTreeRootChecksum(block, offset, count);
+	}
+}
+
+
+uint32
+DirectoryIterator::_MaxSize()
+{
+	uint32 maxSize = fBlockSize;
+	if (fVolume->HasMetaGroupChecksumFeature())
+		maxSize -= sizeof(ext2_dir_entry_tail);
+	return maxSize;
+}
+
diff --git a/src/add-ons/kernel/file_systems/ext2/DirectoryIterator.h b/src/add-ons/kernel/file_systems/ext2/DirectoryIterator.h
index 0c88cdd4e4..1a7487a421 100644
--- a/src/add-ons/kernel/file_systems/ext2/DirectoryIterator.h
+++ b/src/add-ons/kernel/file_systems/ext2/DirectoryIterator.h
@@ -62,6 +62,20 @@ protected:
 			off_t		_Offset() { return fLogicalBlock * fBlockSize
 							+ fDisplacement; }
 
+			bool		_CheckDirEntry(const ext2_dir_entry* dirEntry,
+							const uint8* buffer);
+			status_t	_CheckBlock(const uint8* buffer);
+			uint32		_MaxSize();
+
+#if 0
+			ext2_dir_entry_tail* _DirEntryTail(uint8* block) const;
+			uint32		_Checksum(uint8* block) const;
+			void		_SetDirEntryChecksum(uint8* block);
+#endif
+			ext2_htree_tail* _HTreeEntryTail(uint8* block, uint16 offset) const;
+			uint32		_HTreeRootChecksum(uint8* block, uint16 offset, uint16 count) const;
+			void		_SetHTreeEntryChecksum(uint8* block, uint16 offset, uint16 count);
+
 
 	Inode*				fDirectory;
 	Volume*				fVolume;
diff --git a/src/add-ons/kernel/file_systems/ext2/ExtentStream.cpp b/src/add-ons/kernel/file_systems/ext2/ExtentStream.cpp
index 3374d1b5aa..6d3ac2b545 100644
--- a/src/add-ons/kernel/file_systems/ext2/ExtentStream.cpp
+++ b/src/add-ons/kernel/file_systems/ext2/ExtentStream.cpp
@@ -12,6 +12,7 @@
 #include <string.h>
 
 #include "CachedBlock.h"
+#include "Inode.h"
 #include "Volume.h"
 
 
@@ -27,10 +28,11 @@
 #define ERROR(x...)	dprintf("\33[34mext2:\33[0m ExtentStream::" x)
 
 
-ExtentStream::ExtentStream(Volume* volume, ext2_extent_stream* stream,
-	off_t size)
+ExtentStream::ExtentStream(Volume* volume, Inode* inode,
+	ext2_extent_stream* stream, off_t size)
 	:
 	fVolume(volume),
+	fInode(inode),
 	fStream(stream),
 	fFirstBlock(volume->FirstDataBlock()),
 	fAllocatedPos(fFirstBlock),
@@ -75,6 +77,10 @@ ExtentStream::FindBlock(off_t offset, fsblock_t& block, uint32 *_count)
 			stream->extent_index[i - 1].PhysicalBlock());
 		if (!stream->extent_header.IsValid())
 			panic("ExtentStream::FindBlock() invalid header\n");
+		if (!fInode->VerifyExtentChecksum(stream)) {
+			panic("ExtentStream::FindBlock() invalid checksum\n");
+			return B_BAD_DATA;
+		}
 	}
 
 	// find the extend following the one that should contain the logical block
@@ -556,3 +562,4 @@ ExtentStream::_CheckBlock(ext2_extent_stream *stream, fsblock_t block)
 	}
 	return B_OK;
 }
+
diff --git a/src/add-ons/kernel/file_systems/ext2/ExtentStream.h b/src/add-ons/kernel/file_systems/ext2/ExtentStream.h
index dc12a5bc20..98fed30726 100644
--- a/src/add-ons/kernel/file_systems/ext2/ExtentStream.h
+++ b/src/add-ons/kernel/file_systems/ext2/ExtentStream.h
@@ -13,14 +13,15 @@
 #include "Transaction.h"
 
 
+class Inode;
 class Volume;
 
 
 class ExtentStream
 {
 public:
-					ExtentStream(Volume* volume, ext2_extent_stream* stream,
-						off_t size);
+					ExtentStream(Volume* volume, Inode* inode,
+						ext2_extent_stream* stream, off_t size);
 					~ExtentStream();
 
 	status_t		FindBlock(off_t offset, fsblock_t& block,
@@ -36,6 +37,7 @@ private:
 	status_t		_CheckBlock(ext2_extent_stream *stream, fsblock_t block);
 
 	Volume*			fVolume;
+	Inode*			fInode;
 	ext2_extent_stream* fStream;
 	fsblock_t		fFirstBlock;
 
diff --git a/src/add-ons/kernel/file_systems/ext2/HTree.cpp b/src/add-ons/kernel/file_systems/ext2/HTree.cpp
index 07acc7e7fe..feffdab85b 100644
--- a/src/add-ons/kernel/file_systems/ext2/HTree.cpp
+++ b/src/add-ons/kernel/file_systems/ext2/HTree.cpp
@@ -51,6 +51,7 @@ HTreeRoot::IsValid() const
 HTree::HTree(Volume* volume, Inode* directory)
 	:
 	fDirectory(directory),
+	fHashVersion(HTREE_HASH_LEGACY),
 	fRootEntry(NULL)
 {
 	fBlockSize = volume->BlockSize();
diff --git a/src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.cpp b/src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.cpp
index 8f4bf2d0a6..af3f5da2c7 100644
--- a/src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.cpp
+++ b/src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.cpp
@@ -12,6 +12,7 @@
 #include <new>
 
 #include "CachedBlock.h"
+#include "CRCTable.h"
 #include "HTree.h"
 #include "Inode.h"
 
@@ -30,6 +31,8 @@ HTreeEntryIterator::HTreeEntryIterator(off_t offset, Inode* directory)
 	fDirectory(directory),
 	fVolume(directory->GetVolume()),
 	fHasCollision(false),
+	fLimit(0),
+	fCount(0),
 	fBlockSize(directory->GetVolume()->BlockSize()),
 	fParent(NULL),
 	fChild(NULL)
@@ -53,6 +56,8 @@ HTreeEntryIterator::HTreeEntryIterator(uint32 block, uint32 blockSize,
 	fDirectory(directory),
 	fVolume(directory->GetVolume()),
 	fHasCollision(hasCollision),
+	fLimit(0),
+	fCount(0),
 	fFirstEntry(1),
 	fCurrentEntry(1),
 	fBlockSize(blockSize),
@@ -98,10 +103,14 @@ HTreeEntryIterator::Init()
 		return B_ERROR;
 	}
 
-	if (fLimit != fBlockSize / sizeof(HTreeEntry) - fFirstEntry) {
+	uint32 maxSize = fBlockSize;
+	if (fVolume->HasMetaGroupChecksumFeature())
+		maxSize -= sizeof(ext2_htree_tail);
+
+	if (fLimit != maxSize / sizeof(HTreeEntry) - fFirstEntry) {
 		ERROR("HTreeEntryIterator::Init() bad fLimit %u should be %" B_PRIu32
 			" at block %" B_PRIu64 "\n", fLimit,
-			(uint32)(fBlockSize / sizeof(HTreeEntry) - fFirstEntry), fBlockNum);
+			(uint32)(maxSize / sizeof(HTreeEntry) - fFirstEntry), fBlockNum);
 		fCount = fLimit = 0;
 		return B_ERROR;
 	}
@@ -336,6 +345,10 @@ HTreeEntryIterator::InsertEntry(Transaction& transaction, uint32 hash,
 		if (secondBlockData == NULL)
 			return B_IO_ERROR;
 
+		uint32 maxSize = fBlockSize;
+		if (fVolume->HasMetaGroupChecksumFeature())
+			maxSize -= sizeof(ext2_dir_entry_tail);
+
 		HTreeFakeDirEntry* fakeEntry = (HTreeFakeDirEntry*)secondBlockData;
 		fakeEntry->inode_id = 0; // ?
 		fakeEntry->SetEntryLength(fBlockSize);
@@ -345,6 +358,7 @@ HTreeEntryIterator::InsertEntry(Transaction& transaction, uint32 hash,
 		HTreeEntry* secondBlockEntries = (HTreeEntry*)secondBlockData;
 		memmove(&entries[fFirstEntry + count / 2], &secondBlockEntries[1],
 			(count - count / 2) * sizeof(HTreeEntry));
+		_SetHTreeEntryChecksum(secondBlockData);
 	}
 
 	TRACE("HTreeEntryIterator::InsertEntry(): Inserting node. Count: %u, "
@@ -366,5 +380,45 @@ HTreeEntryIterator::InsertEntry(Transaction& transaction, uint32 hash,
 
 	countLimit->SetCount(count + 1);
 
+	_SetHTreeEntryChecksum(blockData);
+
 	return B_OK;
 }
+
+
+ext2_htree_tail*
+HTreeEntryIterator::_HTreeEntryTail(uint8* block) const
+{
+	HTreeEntry* entries = (HTreeEntry*)block;
+	HTreeCountLimit* countLimit = (HTreeCountLimit*)&entries[fFirstEntry];
+	uint16 limit = countLimit->Limit();
+	return (ext2_htree_tail*)(&entries[fFirstEntry + limit]);
+}
+
+
+uint32
+HTreeEntryIterator::_Checksum(uint8* block) const
+{
+	uint32 number = fDirectory->ID();
+	uint32 checksum = calculate_crc32c(fVolume->ChecksumSeed(),
+		(uint8*)&number, sizeof(number));
+	uint32 gen = fDirectory->Node().generation;
+	checksum = calculate_crc32c(checksum, (uint8*)&gen, sizeof(gen));
+	checksum = calculate_crc32c(checksum, block,
+		(fFirstEntry + fCount) * sizeof(HTreeEntry));
+	ext2_htree_tail dummy;
+	checksum = calculate_crc32c(checksum, (uint8*)&dummy, sizeof(dummy));
+	return checksum;
+}
+
+
+void
+HTreeEntryIterator::_SetHTreeEntryChecksum(uint8* block)
+{
+	if (fVolume->HasMetaGroupChecksumFeature()) {
+		ext2_htree_tail* tail = _HTreeEntryTail(block);
+		tail->reserved = 0xde00000c;
+		tail->checksum = _Checksum(block);
+	}
+}
+
diff --git a/src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.h b/src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.h
index 73a432eec2..af050f5d24 100644
--- a/src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.h
+++ b/src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.h
@@ -42,6 +42,10 @@ private:
 									HTreeEntryIterator* parent,
 									bool hasCollision);
 
+			ext2_htree_tail*	_HTreeEntryTail(uint8* block) const;
+			uint32				_Checksum(uint8* block) const;
+			void				_SetHTreeEntryChecksum(uint8* block);
+
 private:
 			Inode*				fDirectory;
 			Volume*				fVolume;
diff --git a/src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp b/src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp
index 653d6e09b3..d2e5ecc5f6 100644
--- a/src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp
+++ b/src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp
@@ -20,8 +20,8 @@
 #endif
 
 
-HashRevokeManager::HashRevokeManager()
-	:
+HashRevokeManager::HashRevokeManager(bool has64bits)
+	: RevokeManager(has64bits),
 	fHash(NULL),
 	kInitialHashSize(128)
 		// TODO: Benchmark and find an optimal value
diff --git a/src/add-ons/kernel/file_systems/ext2/HashRevokeManager.h b/src/add-ons/kernel/file_systems/ext2/HashRevokeManager.h
index 0be41abed5..e4f26aac49 100644
--- a/src/add-ons/kernel/file_systems/ext2/HashRevokeManager.h
+++ b/src/add-ons/kernel/file_systems/ext2/HashRevokeManager.h
@@ -51,7 +51,7 @@ typedef BOpenHashTable<RevokeHash> RevokeTable;
 
 class HashRevokeManager : public RevokeManager {
 public:
-						HashRevokeManager();
+						HashRevokeManager(bool has64bits);
 	virtual				~HashRevokeManager();
 
 			status_t	Init();
diff --git a/src/add-ons/kernel/file_systems/ext2/Inode.cpp b/src/add-ons/kernel/file_systems/ext2/Inode.cpp
index 95eb2011a0..ade9bf02d6 100644
--- a/src/add-ons/kernel/file_systems/ext2/Inode.cpp
+++ b/src/add-ons/kernel/file_systems/ext2/Inode.cpp
@@ -12,6 +12,7 @@
 #include <NodeMonitor.h>
 
 #include "CachedBlock.h"
+#include "CRCTable.h"
 #include "DataStream.h"
 #include "DirectoryIterator.h"
 #include "ExtentStream.h"
@@ -37,10 +38,12 @@ Inode::Inode(Volume* volume, ino_t id)
 	fID(id),
 	fCache(NULL),
 	fMap(NULL),
+	fUnlinked(false),
 	fHasExtraAttributes(false)
 {
 	rw_lock_init(&fLock, "ext2 inode");
 	recursive_lock_init(&fSmallDataLock, "ext2 inode small data");
+	memset(&fNode, 0, sizeof(fNode));
 
 	TRACE("Inode::Inode(): ext2_inode: %lu, disk inode: %" B_PRIu32
 		"\n", sizeof(ext2_inode), fVolume->InodeSize());
@@ -69,10 +72,12 @@ Inode::Inode(Volume* volume)
 	fID(0),
 	fCache(NULL),
 	fMap(NULL),
+	fUnlinked(false),
 	fInitStatus(B_NO_INIT)
 {
 	rw_lock_init(&fLock, "ext2 inode");
 	recursive_lock_init(&fSmallDataLock, "ext2 inode small data");
+	memset(&fNode, 0, sizeof(fNode));
 
 	TRACE("Inode::Inode(): ext2_inode: %lu, disk inode: %" B_PRIu32 "\n",
 		sizeof(ext2_inode), fVolume->InodeSize());
@@ -130,6 +135,14 @@ Inode::WriteBack(Transaction& transaction)
 	if (inodeBlockData == NULL)
 		return B_IO_ERROR;
 
+	if (fVolume->HasMetaGroupChecksumFeature()) {
+		uint32 checksum = _InodeChecksum();
+		fNode.checksum = checksum & 0xffff;
+		if (fNodeSize > EXT2_INODE_NORMAL_SIZE
+			&& fNodeSize >= offsetof(ext2_inode, change_time_extra)) {
+			fNode.checksum_high = checksum >> 16;
+		}
+	}
 	TRACE("Inode::WriteBack(): Inode ID: %" B_PRIdINO ", inode block: %"
 		B_PRIdOFF ", data: %p, index: %" B_PRIu32 ", inode size: %" B_PRIu32
 		", node size: %" B_PRIu32 ", this: %p, node: %p\n",
@@ -172,6 +185,21 @@ Inode::UpdateNodeFromDisk()
 
 	memcpy(&fNode, inode, fNodeSize);
 
+	if (fVolume->HasMetaGroupChecksumFeature()) {
+		uint32 checksum = _InodeChecksum();
+		uint32 provided = fNode.checksum;
+		if (fNodeSize > EXT2_INODE_NORMAL_SIZE
+			&& fNodeSize >= offsetof(ext2_inode, change_time_extra)) {
+			provided |= (fNode.checksum_high << 16);
+		} else
+			checksum &= 0xffff;
+		if (provided != checksum) {
+			ERROR("Inode::UpdateNodeFromDisk(%" B_PRIu32 "): "
+			"verification failed\n", blockNum);
+			return B_BAD_DATA;
+		}
+	}
+
 	uint32 numLinks = fNode.NumLinks();
 	fUnlinked = numLinks == 0 || (IsDirectory() && numLinks == 1);
 
@@ -195,7 +223,7 @@ status_t
 Inode::FindBlock(off_t offset, fsblock_t& block, uint32 *_count)
 {
 	if (Flags() & EXT2_INODE_EXTENTS) {
-		ExtentStream stream(fVolume, &fNode.extent_stream, Size());
+		ExtentStream stream(fVolume, this, &fNode.extent_stream, Size());
 		return stream.FindBlock(offset, block, _count);
 	}
 	DataStream stream(fVolume, &fNode.stream, Size());
@@ -373,7 +401,7 @@ Inode::InitDirectory(Transaction& transaction, Inode* parent)
 
 	fsblock_t blockNum;
 	if (Flags() & EXT2_INODE_EXTENTS) {
-		ExtentStream stream(fVolume, &fNode.extent_stream, Size());
+		ExtentStream stream(fVolume, this, &fNode.extent_stream, Size());
 		status = stream.FindBlock(0, blockNum);
 	} else {
 		DataStream stream(fVolume, &fNode.stream, Size());
@@ -393,7 +421,10 @@ Inode::InitDirectory(Transaction& transaction, Inode* parent)
 	root->dot_entry_name[0] = '.';
 
 	root->dotdot.inode_id = parent == NULL ? fID : parent->ID();
-	root->dotdot.entry_length = blockSize - 12;
+	uint32 dotdotlength = blockSize - 12;
+	if (fVolume->HasMetaGroupChecksumFeature())
+		dotdotlength -= sizeof(ext2_dir_entry_tail);
+	root->dotdot.entry_length = dotdotlength;
 	root->dotdot.name_length = 2;
 	root->dotdot.file_type = EXT2_TYPE_DIRECTORY;
 	root->dotdot_entry_name[0] = '.';
@@ -401,6 +432,8 @@ Inode::InitDirectory(Transaction& transaction, Inode* parent)
 
 	parent->IncrementNumLinks(transaction);
 
+	SetDirEntryChecksum((uint8*)root);
+
 	return parent->WriteBack(transaction);
 }
 
@@ -411,8 +444,10 @@ Inode::Unlink(Transaction& transaction)
 	uint32 numLinks = fNode.NumLinks();
 	TRACE("Inode::Unlink(): Current links: %" B_PRIu32 "\n", numLinks);
 
-	if (numLinks == 0)
+	if (numLinks == 0) {
+		ERROR("Inode::Unlink(): no links\n");
 		return B_BAD_VALUE;
+	}
 
 	if ((IsDirectory() && numLinks == 2) || (numLinks == 1))  {
 		fUnlinked = true;
@@ -442,7 +477,7 @@ Inode::Unlink(Transaction& transaction)
 		status = remove_vnode(fVolume->FSVolume(), fID);
 		if (status != B_OK)
 			return status;
-	} else
+	} else if (!IsDirectory() || numLinks > 2)
 		fNode.SetNumLinks(--numLinks);
 
 	return WriteBack(transaction);
@@ -463,6 +498,13 @@ Inode::Create(Transaction& transaction, Inode* parent, const char* name,
 	if (parent != NULL) {
 		parent->WriteLockInTransaction(transaction);
 
+		// don't create anything in removed directories
+		bool removed;
+		if (get_vnode_removed(volume->FSVolume(), parent->ID(), &removed)
+				== B_OK && removed) {
+			return B_ENTRY_NOT_FOUND;
+		}
+
 		TRACE("Inode::Create(): Looking up entry destination\n");
 		HTree htree(volume, parent);
 
@@ -587,7 +629,7 @@ Inode::Create(Transaction& transaction, Inode* parent, const char* name,
 	if (volume->HasExtentsFeature()
 		&& (inode->IsDirectory() || inode->IsFile())) {
 		node.SetFlag(EXT2_INODE_EXTENTS);
-		ExtentStream stream(volume, &node.extent_stream, 0);
+		ExtentStream stream(volume, inode, &node.extent_stream, 0);
 		stream.Init();
 		ASSERT(stream.Check());
 	}
@@ -758,17 +800,8 @@ Inode::TransactionDone(bool success)
 {
 	if (!success) {
 		// Revert any changes to the inode
-		if (fInitStatus == B_OK && UpdateNodeFromDisk() != B_OK)
+		if (UpdateNodeFromDisk() != B_OK)
 			panic("Failed to reload inode from disk!\n");
-		else if (fInitStatus == B_NO_INIT) {
-			// TODO: Unpublish vnode?
-			panic("Failed to finish creating inode\n");
-		}
-	} else {
-		if (fInitStatus == B_NO_INIT) {
-			TRACE("Inode::TransactionDone(): Inode creation succeeded\n");
-			fInitStatus = B_OK;
-		}
 	}
 }
 
@@ -808,7 +841,7 @@ Inode::_EnlargeDataStream(Transaction& transaction, off_t size)
 
 	off_t end = size == 0 ? 0 : (size - 1) / fVolume->BlockSize() + 1;
 	if (Flags() & EXT2_INODE_EXTENTS) {
-		ExtentStream stream(fVolume, &fNode.extent_stream, Size());
+		ExtentStream stream(fVolume, this, &fNode.extent_stream, Size());
 		stream.Enlarge(transaction, end);
 		ASSERT(stream.Check());
 	} else {
@@ -849,7 +882,7 @@ Inode::_ShrinkDataStream(Transaction& transaction, off_t size)
 
 	off_t end = size == 0 ? 0 : (size - 1) / fVolume->BlockSize() + 1;
 	if (Flags() & EXT2_INODE_EXTENTS) {
-		ExtentStream stream(fVolume, &fNode.extent_stream, Size());
+		ExtentStream stream(fVolume, this, &fNode.extent_stream, Size());
 		stream.Shrink(transaction, end);
 		ASSERT(stream.Check());
 	} else {
@@ -907,3 +940,120 @@ Inode::IncrementNumLinks(Transaction& transaction)
 		fVolume->ActivateDirNLink(transaction);
 	}
 }
+
+
+uint32
+Inode::_InodeChecksum()
+{
+	size_t offset = offsetof(ext2_inode, checksum);
+	size_t offset2 = offsetof(ext2_inode, reserved);
+	uint32 number = fID;
+	uint32 checksum = calculate_crc32c(fVolume->ChecksumSeed(), (uint8*)&number,
+		sizeof(number));
+	uint32 gen = fNode.generation;
+	checksum = calculate_crc32c(checksum, (uint8*)&gen, sizeof(gen));
+	checksum = calculate_crc32c(checksum, (uint8*)&fNode, offset);
+	uint16 dummy = 0;
+	checksum = calculate_crc32c(checksum, (uint8*)&dummy, sizeof(dummy));
+	checksum = calculate_crc32c(checksum, (uint8*)&fNode + offset2,
+		EXT2_INODE_NORMAL_SIZE - offset2);
+	if (fNodeSize > EXT2_INODE_NORMAL_SIZE) {
+		offset = offsetof(ext2_inode, checksum_high);
+		offset2 = offsetof(ext2_inode, change_time_extra);
+		checksum = calculate_crc32c(checksum, (uint8*)&fNode + EXT2_INODE_NORMAL_SIZE,
+			offset - EXT2_INODE_NORMAL_SIZE);
+		checksum = calculate_crc32c(checksum, (uint8*)&dummy, sizeof(dummy));
+		checksum = calculate_crc32c(checksum, (uint8*)&fNode + offset2,
+			fNodeSize - offset2);
+	}
+	return checksum;
+}
+
+
+ext2_dir_entry_tail*
+Inode::_DirEntryTail(uint8* block) const
+{
+	return (ext2_dir_entry_tail*)(block + fVolume->BlockSize()
+		- sizeof(ext2_dir_entry_tail));
+}
+
+
+uint32
+Inode::_DirEntryChecksum(uint8* block, uint32 id, uint32 gen) const
+{
+	uint32 number = id;
+	uint32 checksum = calculate_crc32c(fVolume->ChecksumSeed(),
+		(uint8*)&number, sizeof(number));
+	checksum = calculate_crc32c(checksum, (uint8*)&gen, sizeof(gen));
+	checksum = calculate_crc32c(checksum, block,
+		fVolume->BlockSize() - sizeof(ext2_dir_entry_tail));
+	return checksum;
+}
+
+
+void
+Inode::SetDirEntryChecksum(uint8* block, uint32 id, uint32 gen)
+{
+	if (fVolume->HasMetaGroupChecksumFeature()) {
+		ext2_dir_entry_tail* tail = _DirEntryTail(block);
+		tail->twelve = 12;
+		tail->hexade = 0xde;
+		tail->checksum = _DirEntryChecksum(block, id, gen);
+	}
+}
+
+
+void
+Inode::SetDirEntryChecksum(uint8* block)
+{
+	SetDirEntryChecksum(block, fID, fNode.generation);
+}
+
+
+uint32
+Inode::_ExtentLength(ext2_extent_stream* stream) const
+{
+	return sizeof(struct ext2_extent_header)
+		+ stream->extent_header.MaxEntries()
+			* sizeof(struct ext2_extent_entry);
+}
+
+
+uint32
+Inode::_ExtentChecksum(ext2_extent_stream* stream) const
+{
+	uint32 number = fID;
+	uint32 checksum = calculate_crc32c(fVolume->ChecksumSeed(),
+		(uint8*)&number, sizeof(number));
+	checksum = calculate_crc32c(checksum, (uint8*)&fNode.generation,
+		sizeof(fNode.generation));
+	checksum = calculate_crc32c(checksum, (uint8*)stream,
+		_ExtentLength(stream));
+	return checksum;
+}
+
+
+void
+Inode::SetExtentChecksum(ext2_extent_stream* stream)
+{
+	if (fVolume->HasMetaGroupChecksumFeature()) {
+		uint32 checksum = _ExtentChecksum(stream);
+		struct ext2_extent_tail *tail = (struct ext2_extent_tail *)
+			((uint8*)stream + _ExtentLength(stream));
+		tail->checksum = checksum;
+	}
+}
+
+
+bool
+Inode::VerifyExtentChecksum(ext2_extent_stream* stream)
+{
+	if (fVolume->HasMetaGroupChecksumFeature()) {
+		uint32 checksum = _ExtentChecksum(stream);
+		struct ext2_extent_tail *tail = (struct ext2_extent_tail *)
+			((uint8*)stream + _ExtentLength(stream));
+		return tail->checksum == checksum;
+	}
+	return true;
+}
+
diff --git a/src/add-ons/kernel/file_systems/ext2/Inode.h b/src/add-ons/kernel/file_systems/ext2/Inode.h
index d4fe2cca1b..3d770e9948 100644
--- a/src/add-ons/kernel/file_systems/ext2/Inode.h
+++ b/src/add-ons/kernel/file_systems/ext2/Inode.h
@@ -120,7 +120,11 @@ public:
 
 			status_t	Sync();
 
+			void		SetDirEntryChecksum(uint8* block, uint32 id, uint32 gen);
+			void		SetDirEntryChecksum(uint8* block);
 
+			void		SetExtentChecksum(ext2_extent_stream* stream);
+			bool		VerifyExtentChecksum(ext2_extent_stream* stream);
 
 protected:
 	virtual	void		TransactionDone(bool success);
@@ -141,6 +145,15 @@ private:
 			uint64		_NumBlocks();
 			status_t	_SetNumBlocks(uint64 numBlocks);
 
+			uint32		_InodeChecksum();
+
+			ext2_dir_entry_tail*	_DirEntryTail(uint8* block) const;
+			uint32		_DirEntryChecksum(uint8* block, uint32 id,
+							uint32 gen) const;
+
+			uint32		_ExtentLength(ext2_extent_stream* stream) const;
+			uint32		_ExtentChecksum(ext2_extent_stream* stream) const;
+
 			rw_lock		fLock;
 			::Volume*	fVolume;
 			ino_t		fID;
diff --git a/src/add-ons/kernel/file_systems/ext2/InodeAllocator.cpp b/src/add-ons/kernel/file_systems/ext2/InodeAllocator.cpp
index 04186c45d7..806ab10d6a 100644
--- a/src/add-ons/kernel/file_systems/ext2/InodeAllocator.cpp
+++ b/src/add-ons/kernel/file_systems/ext2/InodeAllocator.cpp
@@ -84,12 +84,14 @@ InodeAllocator::Free(Transaction& transaction, ino_t id, bool isDirectory)
 			fVolume->Has64bitFeature());
 	}
 
-	status = fVolume->WriteBlockGroup(transaction, blockGroup);
+	uint32 checksum = 0;
+	status = _UnmarkInBitmap(transaction,
+		group->InodeBitmap(fVolume->Has64bitFeature()), numInodes, id,
+		checksum);
 	if (status != B_OK)
 		return status;
-
-	return _UnmarkInBitmap(transaction,
-		group->InodeBitmap(fVolume->Has64bitFeature()), numInodes, id);
+	_SetInodeBitmapChecksum(group, checksum);
+	return fVolume->WriteBlockGroup(transaction, blockGroup);
 }
 
 
@@ -135,6 +137,12 @@ InodeAllocator::_AllocateInGroup(Transaction& transaction, uint32 blockGroup,
 	}
 
 	fsblock_t block = group->InodeBitmap(fVolume->Has64bitFeature());
+	if (block == 0) {
+		ERROR("_AllocateInGroup(%" B_PRIu32 "): inodeBitmap is zero\n",
+			blockGroup);
+		return B_BAD_VALUE;
+	}
+
 	_InitGroup(transaction, group, block, fVolume->InodesPerGroup());
 	uint32 freeInodes = group->FreeInodes(fVolume->Has64bitFeature());
 	if (freeInodes == 0)
@@ -149,17 +157,19 @@ InodeAllocator::_AllocateInGroup(Transaction& transaction, uint32 blockGroup,
 	}
 	
 	uint32 pos = 0;
+	uint32 checksum = 0;
 	status = _MarkInBitmap(transaction, block, blockGroup, 
-		fVolume->InodesPerGroup(), pos);
+		fVolume->InodesPerGroup(), pos, checksum);
 	if (status != B_OK)
 		return status;
 
-	if (fVolume->HasChecksumFeature() && pos > (fVolume->InodesPerGroup() - 1
-		- group->UnusedInodes(fVolume->Has64bitFeature()))) {
-		group->SetUnusedInodes(fVolume->InodesPerGroup() - 1 - pos,
+	if ((fVolume->HasChecksumFeature() || fVolume->HasMetaGroupChecksumFeature())
+		&& pos > (fVolume->InodesPerGroup()
+			- group->UnusedInodes(fVolume->Has64bitFeature()) - 1)) {
+		group->SetUnusedInodes(fVolume->InodesPerGroup() - pos - 1,
 			fVolume->Has64bitFeature());
 	}
-
+	_SetInodeBitmapChecksum(group, checksum);
 	status = fVolume->WriteBlockGroup(transaction, blockGroup);
 	if (status != B_OK)
 		return status;
@@ -172,7 +182,7 @@ InodeAllocator::_AllocateInGroup(Transaction& transaction, uint32 blockGroup,
 
 status_t
 InodeAllocator::_MarkInBitmap(Transaction& transaction, fsblock_t bitmapBlock,
-	uint32 blockGroup, uint32 numInodes, uint32& pos)
+	uint32 blockGroup, uint32 numInodes, uint32& pos, uint32& checksum)
 {
 	BitmapBlock inodeBitmap(fVolume, numInodes);
 
@@ -199,13 +209,15 @@ InodeAllocator::_MarkInBitmap(Transaction& transaction, fsblock_t bitmapBlock,
 		return B_BAD_DATA;
 	}
 
+	checksum = inodeBitmap.Checksum(fVolume->InodesPerGroup());
+
 	return B_OK;
 }
 
 
 status_t
 InodeAllocator::_UnmarkInBitmap(Transaction& transaction, fsblock_t bitmapBlock,
-	uint32 numInodes, ino_t id)
+	uint32 numInodes, ino_t id, uint32& checksum)
 {
 	BitmapBlock inodeBitmap(fVolume, numInodes);
 
@@ -222,6 +234,8 @@ InodeAllocator::_UnmarkInBitmap(Transaction& transaction, fsblock_t bitmapBlock,
 		return B_BAD_DATA;
 	}
 
+	checksum = inodeBitmap.Checksum(fVolume->InodesPerGroup());
+
 	return B_OK;
 }
 
@@ -244,3 +258,16 @@ InodeAllocator::_InitGroup(Transaction& transaction, ext2_block_group* group,
 	return B_OK;
 }
 
+
+void
+InodeAllocator::_SetInodeBitmapChecksum(ext2_block_group* group, uint32 checksum)
+{
+	if (fVolume->HasMetaGroupChecksumFeature()) {
+		group->inode_bitmap_csum = checksum & 0xffff;
+		if (fVolume->GroupDescriptorSize() >= offsetof(ext2_block_group,
+			_reserved)) {
+			group->inode_bitmap_csum_high = checksum >> 16;
+		}
+	}
+}
+
diff --git a/src/add-ons/kernel/file_systems/ext2/InodeAllocator.h b/src/add-ons/kernel/file_systems/ext2/InodeAllocator.h
index 75ae7adffc..e4a7abac31 100644
--- a/src/add-ons/kernel/file_systems/ext2/InodeAllocator.h
+++ b/src/add-ons/kernel/file_systems/ext2/InodeAllocator.h
@@ -37,13 +37,15 @@ private:
 							ino_t& id, uint32 numInodes);
 			status_t	_MarkInBitmap(Transaction& transaction,
 							fsblock_t bitmapBlock, uint32 blockGroup,
-							uint32 numInodes, uint32& pos);
+							uint32 numInodes, uint32& pos, uint32& checksum);
 			status_t	_UnmarkInBitmap(Transaction& transaction,
-							fsblock_t bitmapBlock, uint32 numInodes, ino_t id);
+							fsblock_t bitmapBlock, uint32 numInodes, ino_t id,
+							uint32& checksum);
 			status_t	_InitGroup(Transaction& transaction,
 							ext2_block_group* group, fsblock_t bitmapBlock,
 							uint32 numInodes);
-
+			void		_SetInodeBitmapChecksum(ext2_block_group* group,
+							uint32 checksum);
 
 			Volume*		fVolume;
 			mutex		fLock;
diff --git a/src/add-ons/kernel/file_systems/ext2/InodeJournal.cpp b/src/add-ons/kernel/file_systems/ext2/InodeJournal.cpp
index d674c11d2f..48e1d05cde 100644
--- a/src/add-ons/kernel/file_systems/ext2/InodeJournal.cpp
+++ b/src/add-ons/kernel/file_systems/ext2/InodeJournal.cpp
@@ -47,7 +47,7 @@ InodeJournal::InodeJournal(Inode* inode)
 		TRACE("InodeJournal::InodeJournal(): Inode's file cache disabled "
 			"successfully\n");
 		HashRevokeManager* revokeManager = new(std::nothrow)
-			HashRevokeManager;
+			HashRevokeManager(volume->Has64bitFeature());
 		TRACE("InodeJournal::InodeJournal(): Allocated a hash revoke "
 			"manager at %p\n", revokeManager);
 
diff --git a/src/add-ons/kernel/file_systems/ext2/Jamfile b/src/add-ons/kernel/file_systems/ext2/Jamfile
index f31cfdb993..21883181de 100644
--- a/src/add-ons/kernel/file_systems/ext2/Jamfile
+++ b/src/add-ons/kernel/file_systems/ext2/Jamfile
@@ -26,4 +26,6 @@ KernelAddon ext2 :
 	CRCTable.cpp
 
 	kernel_interface.cpp
+
+	crc32.c
 ;
diff --git a/src/add-ons/kernel/file_systems/ext2/Journal.cpp b/src/add-ons/kernel/file_systems/ext2/Journal.cpp
index 00f859b4ef..4d24bc7f10 100644
--- a/src/add-ons/kernel/file_systems/ext2/Journal.cpp
+++ b/src/add-ons/kernel/file_systems/ext2/Journal.cpp
@@ -17,6 +17,7 @@
 #include <fs_cache.h>
 
 #include "CachedBlock.h"
+#include "CRCTable.h"
 #include "HashRevokeManager.h"
 
 
@@ -107,7 +108,8 @@ Journal::Journal(Volume* fsVolume, Volume* jVolume)
 	recursive_lock_init(&fLock, "ext2 journal");
 	mutex_init(&fLogEntriesLock, "ext2 journal log entries");
 
-	HashRevokeManager* revokeManager = new(std::nothrow) HashRevokeManager;
+	HashRevokeManager* revokeManager = new(std::nothrow) HashRevokeManager(
+		fsVolume->Has64bitFeature());
 	TRACE("Journal::Journal(): Allocated a hash revoke manager at %p\n",
 		revokeManager);
 
@@ -131,6 +133,7 @@ Journal::Journal()
 	fJournalBlockCache(NULL),
 	fFilesystemVolume(NULL),
 	fFilesystemBlockCache(NULL),
+	fOwner(NULL),
 	fRevokeManager(NULL),
 	fInitStatus(B_OK),
 	fBlockSize(sizeof(JournalSuperBlock)),
@@ -148,7 +151,10 @@ Journal::Journal()
 	fHasSubTransaction(false),
 	fSeparateSubTransactions(false),
 	fUnwrittenTransactions(0),
-	fTransactionID(0)
+	fTransactionID(0),
+	fChecksumEnabled(false),
+	fChecksumV3Enabled(false),
+	fFeature64bits(false)
 {
 	recursive_lock_init(&fLock, "ext2 journal");
 	mutex_init(&fLogEntriesLock, "ext2 journal log entries");
@@ -683,6 +689,9 @@ Journal::_SaveSuperBlock()
 	superblock.SetFirstCommitID(fFirstCommitID);
 	superblock.SetLogStart(fLogStart);
 
+	if (fChecksumEnabled)
+		superblock.SetChecksum(_Checksum(&superblock));
+
 	TRACE("Journal::SaveSuperBlock(): Write to %" B_PRIdOFF "\n",
 		superblockPos);
 	size_t bytesWritten = write_pos(fJournalVolume->Device(), superblockPos,
@@ -700,6 +709,9 @@ Journal::_SaveSuperBlock()
 status_t
 Journal::_LoadSuperBlock()
 {
+	STATIC_ASSERT(sizeof(struct JournalHeader) == 12);
+	STATIC_ASSERT(sizeof(struct JournalSuperBlock) == 1024);
+
 	TRACE("Journal::_LoadSuperBlock()\n");
 	fsblock_t superblockPos;
 
@@ -737,11 +749,23 @@ Journal::_LoadSuperBlock()
 	}
 
 	if (fVersion >= 2) {
+		TRACE("Journal::_LoadSuperBlock(): incompatible features %" B_PRIx32
+			", read-only features %" B_PRIx32 "\n",
+			superblock.IncompatibleFeatures(),
+			superblock.ReadOnlyCompatibleFeatures());
+
 		status = _CheckFeatures(&superblock);
 
-		if (status != B_OK) {
-			ERROR("Journal::_LoadSuperBlock(): Unsupported features\n");
+		if (status != B_OK)
 			return status;
+
+		if (fChecksumEnabled) {
+			if (superblock.Checksum() != _Checksum(&superblock)) {
+				ERROR("Journal::_LoadSuperBlock(): Invalid checksum\n");
+				return B_BAD_DATA;
+			}
+			fChecksumSeed = calculate_crc32c(0xffffffff, (uint8*)superblock.uuid,
+				sizeof(superblock.uuid));
 		}
 	}
 
@@ -775,36 +799,86 @@ Journal::_LoadSuperBlock()
 status_t
 Journal::_CheckFeatures(JournalSuperBlock* superblock)
 {
-	if ((superblock->ReadOnlyCompatibleFeatures()
-			& ~JOURNAL_KNOWN_READ_ONLY_COMPATIBLE_FEATURES) != 0
-		|| (superblock->IncompatibleFeatures()
-			& ~JOURNAL_KNOWN_INCOMPATIBLE_FEATURES) != 0)
+	uint32 readonly = superblock->ReadOnlyCompatibleFeatures();
+	uint32 incompatible = superblock->IncompatibleFeatures();
+	bool hasReadonly = (readonly & ~JOURNAL_KNOWN_READ_ONLY_COMPATIBLE_FEATURES)
+		!= 0;
+	bool hasIncompatible = (incompatible
+		& ~JOURNAL_KNOWN_INCOMPATIBLE_FEATURES) != 0;
+	if (hasReadonly || hasIncompatible ) {
+		ERROR("Journal::_CheckFeatures(): Unsupported features: %" B_PRIx32
+			" %" B_PRIx32 "\n", readonly, incompatible);
 		return B_UNSUPPORTED;
+	}
 
+	bool hasCsumV2 =
+		(superblock->IncompatibleFeatures() & JOURNAL_FEATURE_INCOMPATIBLE_CSUM_V2) != 0;
+	bool hasCsumV3 =
+		(superblock->IncompatibleFeatures() & JOURNAL_FEATURE_INCOMPATIBLE_CSUM_V3) != 0;
+	if (hasCsumV2 && hasCsumV3) {
+		return B_BAD_VALUE;
+	}
+
+	fChecksumEnabled = hasCsumV2 && hasCsumV3;
+	fChecksumV3Enabled = hasCsumV3;
+	fFeature64bits =
+		(superblock->IncompatibleFeatures() & JOURNAL_FEATURE_INCOMPATIBLE_64BIT) != 0;
 	return B_OK;
 }
 
 
+uint32
+Journal::_Checksum(JournalSuperBlock* superblock)
+{
+	uint32 oldChecksum = superblock->checksum;
+	superblock->checksum = 0;
+	uint32 checksum = calculate_crc32c(0xffffffff, (uint8*)superblock,
+		sizeof(JournalSuperBlock));
+	superblock->checksum = oldChecksum;
+	return checksum;
+}
+
+
+bool
+Journal::_Checksum(uint8* block, bool set)
+{
+	JournalBlockTail *tail = (JournalBlockTail*)(block + fBlockSize
+		- sizeof(JournalBlockTail));
+	uint32 oldChecksum = tail->checksum;
+	tail->checksum = 0;
+	uint32 checksum = calculate_crc32c(0xffffffff, block, fBlockSize);
+	if (set) {
+		tail->checksum = checksum;
+	} else {
+		tail->checksum = oldChecksum;
+	}
+	return checksum == oldChecksum;
+}
+
+
 uint32
 Journal::_CountTags(JournalHeader* descriptorBlock)
 {
 	uint32 count = 0;
+	size_t tagSize = _TagSize();
+	size_t size = fBlockSize;
+
+	if (fChecksumEnabled)
+		size -= sizeof(JournalBlockTail);
 
 	JournalBlockTag* tags = (JournalBlockTag*)descriptorBlock->data;
 		// Skip the header
 	JournalBlockTag* lastTag = (JournalBlockTag*)
-		(descriptorBlock + fBlockSize - sizeof(JournalBlockTag));
+		(descriptorBlock + size - tagSize);
 
 	while (tags < lastTag && (tags->Flags() & JOURNAL_FLAG_LAST_TAG) == 0) {
-		if ((tags->Flags() & JOURNAL_FLAG_SAME_UUID) == 0) {
-			// sizeof(UUID) = 16 = 2*sizeof(JournalBlockTag)
-			tags += 2;	// Skip new UUID
-		}
+		if ((tags->Flags() & JOURNAL_FLAG_SAME_UUID) == 0)
+			tags = (JournalBlockTag*)((uint8*)tags + 16); // Skip new UUID
 
 		TRACE("Journal::_CountTags(): Tag block: %" B_PRIu32 "\n",
 			tags->BlockNumber());
 
-		tags++; // Go to next tag
+		tags = (JournalBlockTag*)((uint8*)tags + tagSize); // Go to next tag
 		count++;
 	}
 
@@ -817,6 +891,21 @@ Journal::_CountTags(JournalHeader* descriptorBlock)
 }
 
 
+size_t
+Journal::_TagSize()
+{
+	if (fChecksumV3Enabled)
+		return sizeof(JournalBlockTagV3);
+
+	size_t size = sizeof(JournalBlockTag);
+	if (fChecksumEnabled)
+		size += sizeof(uint16);
+	if (!fFeature64bits)
+		size -= sizeof(uint32);
+	return size;
+}
+
+
 /*virtual*/ status_t
 Journal::Recover()
 {
@@ -862,6 +951,10 @@ Journal::_RecoverPassScan(uint32& lastCommitID)
 		uint32 blockType = header->BlockType();
 
 		if (blockType == JOURNAL_DESCRIPTOR_BLOCK) {
+			if (fChecksumEnabled && !_Checksum((uint8*)header, false)) {
+				ERROR("Journal::_RecoverPassScan(): Invalid checksum\n");
+				return B_BAD_DATA;
+			}
 			uint32 tags = _CountTags(header);
 			nextBlock += tags;
 			TRACE("Journal recover pass scan: Found a descriptor block with "
diff --git a/src/add-ons/kernel/file_systems/ext2/Journal.h b/src/add-ons/kernel/file_systems/ext2/Journal.h
index 4ebbb51a71..9214971f8c 100644
--- a/src/add-ons/kernel/file_systems/ext2/Journal.h
+++ b/src/add-ons/kernel/file_systems/ext2/Journal.h
@@ -23,12 +23,23 @@
 #define JOURNAL_FLAG_DELETED						4
 #define JOURNAL_FLAG_LAST_TAG						8
 
-#define JOURNAL_FEATURE_INCOMPATIBLE_REVOKE			1
+#define JOURNAL_FEATURE_COMPATIBLE_CHECKSUM			0x1
+
+#define JOURNAL_FEATURE_INCOMPATIBLE_REVOKE			0x1
+#define JOURNAL_FEATURE_INCOMPATIBLE_64BIT			0x2
+#define JOURNAL_FEATURE_INCOMPATIBLE_ASYNC_COMMIT	0x4
+#define JOURNAL_FEATURE_INCOMPATIBLE_CSUM_V2		0x8
+#define JOURNAL_FEATURE_INCOMPATIBLE_CSUM_V3		0x10
 
 #define JOURNAL_KNOWN_READ_ONLY_COMPATIBLE_FEATURES	0
 #define JOURNAL_KNOWN_INCOMPATIBLE_FEATURES			\
-	JOURNAL_FEATURE_INCOMPATIBLE_REVOKE
+	(JOURNAL_FEATURE_INCOMPATIBLE_REVOKE | JOURNAL_FEATURE_INCOMPATIBLE_64BIT \
+		| JOURNAL_FEATURE_INCOMPATIBLE_CSUM_V3)
 
+#define JOURNAL_CHECKSUM_TYPE_CRC32					0x1
+#define JOURNAL_CHECKSUM_TYPE_MD5					0x2
+#define JOURNAL_CHECKSUM_TYPE_SHA1					0x3
+#define JOURNAL_CHECKSUM_TYPE_CRC32C				0x4
 
 #include "Volume.h"
 
@@ -68,15 +79,49 @@ struct JournalHeader {
 
 struct JournalBlockTag {
 	uint32			block_number;
-	uint32			flags;
+	uint16			checksum;
+	uint16			flags;
 
-	uint32			BlockNumber()	const	
+	uint32			BlockNumber()	const
 		{ return B_BENDIAN_TO_HOST_INT32(block_number); }
-	uint32			Flags()			const	
-		{ return B_BENDIAN_TO_HOST_INT32(flags); }
+	uint16			Flags()			const
+		{ return B_BENDIAN_TO_HOST_INT16(flags); }
 
 	void			SetBlockNumber(uint32 block)
 		{ block_number = B_HOST_TO_BENDIAN_INT32(block); }
+	void			SetFlags(uint16 new_flags)
+		{ flags = B_HOST_TO_BENDIAN_INT16(new_flags); }
+	void			SetLastTagFlag()
+		{ flags |= B_HOST_TO_BENDIAN_INT16(JOURNAL_FLAG_LAST_TAG); }
+	void			SetEscapedFlag()
+		{ flags |= B_HOST_TO_BENDIAN_INT16(JOURNAL_FLAG_ESCAPED); }
+} _PACKED;
+
+
+struct JournalBlockTagV3 {
+	uint32			block_number;
+	uint32			flags;
+	uint32			block_number_high;
+	uint32			checksum;
+
+	uint64 BlockNumber(bool has64bits) const
+	{
+		uint64 num = B_BENDIAN_TO_HOST_INT32(block_number);
+		if (has64bits)
+			num |= ((uint64)B_BENDIAN_TO_HOST_INT32(block_number_high) << 32);
+		return num;
+	}
+
+	uint32			Flags()			const
+		{ return B_BENDIAN_TO_HOST_INT32(flags); }
+
+	void SetBlockNumber(uint64 block, bool has64bits)
+	{
+		block_number = B_HOST_TO_BENDIAN_INT32(block & 0xffffffff);
+		if (has64bits)
+			block_number_high = B_HOST_TO_BENDIAN_INT32(block >> 32);
+	}
+
 	void			SetFlags(uint32 new_flags)
 		{ flags = B_HOST_TO_BENDIAN_INT32(new_flags); }
 	void			SetLastTagFlag()
@@ -86,6 +131,17 @@ struct JournalBlockTag {
 } _PACKED;
 
 
+struct JournalBlockTail {
+	uint32			checksum;
+
+	uint32			Checksum()	const
+		{ return B_BENDIAN_TO_HOST_INT32(checksum); }
+
+	void			SetChecksum(uint32 new_checksum)
+		{ checksum = B_HOST_TO_BENDIAN_INT32(new_checksum); }
+} _PACKED;
+
+
 struct JournalRevokeHeader {
 	JournalHeader	header;
 	uint32			num_bytes;
@@ -123,7 +179,10 @@ struct JournalSuperBlock {
 	uint32			max_transaction_blocks;
 	uint32			max_transaction_data;
 
-	uint32			padding[44];
+	uint8			checksum_type;
+	uint8			padding2[3];
+	uint32			padding[42];
+	uint32			checksum;
 
 	uint8			user_ids[16*48];
 
@@ -145,11 +204,17 @@ struct JournalSuperBlock {
 		{ return B_BENDIAN_TO_HOST_INT32(max_transaction_blocks); }
 	uint32			MaxTransactionData() const
 		{ return B_BENDIAN_TO_HOST_INT32(max_transaction_data); }
+	uint32			Checksum() const
+		{ return B_BENDIAN_TO_HOST_INT32(checksum); }
 
 	void			SetLogStart(uint32 logStart)
 		{ log_start = B_HOST_TO_BENDIAN_INT32(logStart); }
 	void			SetFirstCommitID(uint32 firstCommitID)
 		{ first_commit_id = B_HOST_TO_BENDIAN_INT32(firstCommitID); }
+	void			SetChecksum(uint32 checksum)
+		{ log_start = B_HOST_TO_BENDIAN_INT32(checksum); }
+
+
 } _PACKED;
 
 class LogEntry;
@@ -231,10 +296,19 @@ protected:
 			int32				fUnwrittenTransactions;
 			int32				fTransactionID;
 
+			bool				fChecksumEnabled;
+			bool				fChecksumV3Enabled;
+			bool				fFeature64bits;
+			uint32				fChecksumSeed;
+
 private:
 			status_t			_CheckFeatures(JournalSuperBlock* superblock);
 
+			uint32				_Checksum(JournalSuperBlock* superblock);
+			bool				_Checksum(uint8 *block, bool set = false);
+
 			uint32				_CountTags(JournalHeader *descriptorBlock);
+			size_t				_TagSize();
 			status_t			_RecoverPassScan(uint32& lastCommitID);
 			status_t			_RecoverPassRevoke(uint32 lastCommitID);
 			status_t			_RecoverPassReplay(uint32 lastCommitID);
diff --git a/src/add-ons/kernel/file_systems/ext2/RevokeManager.cpp b/src/add-ons/kernel/file_systems/ext2/RevokeManager.cpp
index e8ed581dc7..23f75ec255 100644
--- a/src/add-ons/kernel/file_systems/ext2/RevokeManager.cpp
+++ b/src/add-ons/kernel/file_systems/ext2/RevokeManager.cpp
@@ -18,9 +18,10 @@
 #endif
 
 
-RevokeManager::RevokeManager()
+RevokeManager::RevokeManager(bool has64bits)
 	:
-	fRevokeCount(0)
+	fRevokeCount(0),
+	fHas64bits(has64bits)
 {
 }
 
diff --git a/src/add-ons/kernel/file_systems/ext2/RevokeManager.h b/src/add-ons/kernel/file_systems/ext2/RevokeManager.h
index 796f7fe947..59b8f0a200 100644
--- a/src/add-ons/kernel/file_systems/ext2/RevokeManager.h
+++ b/src/add-ons/kernel/file_systems/ext2/RevokeManager.h
@@ -15,7 +15,7 @@ struct JournalRevokeHeader;
 
 class RevokeManager {
 public:
-						RevokeManager();
+						RevokeManager(bool has64bits);
 	virtual				~RevokeManager() = 0;
 
 	virtual	status_t	Insert(uint32 block, uint32 commitID) = 0;
@@ -29,6 +29,7 @@ public:
 
 protected:
 			uint32		fRevokeCount;
+			bool		fHas64bits;
 };
 
 #endif	// REVOKEMANAGER_H
diff --git a/src/add-ons/kernel/file_systems/ext2/Volume.cpp b/src/add-ons/kernel/file_systems/ext2/Volume.cpp
index e14a24fecf..91bddff28d 100644
--- a/src/add-ons/kernel/file_systems/ext2/Volume.cpp
+++ b/src/add-ons/kernel/file_systems/ext2/Volume.cpp
@@ -301,11 +301,6 @@ Volume::Mount(const char* deviceName, uint32 flags)
 	if (opener.IsReadOnly())
 		fFlags |= VOLUME_READ_ONLY;
 
-	TRACE("features %" B_PRIx32 ", incompatible features %" B_PRIx32
-		", read-only features %" B_PRIx32 "\n",
-		fSuperBlock.CompatibleFeatures(), fSuperBlock.IncompatibleFeatures(),
-		fSuperBlock.ReadOnlyFeatures());
-
 	// read the superblock
 	status_t status = Identify(fDevice, &fSuperBlock);
 	if (status != B_OK) {
@@ -313,38 +308,69 @@ Volume::Mount(const char* deviceName, uint32 flags)
 		return status;
 	}
 
+	TRACE("features %" B_PRIx32 ", incompatible features %" B_PRIx32
+		", read-only features %" B_PRIx32 "\n",
+		fSuperBlock.CompatibleFeatures(), fSuperBlock.IncompatibleFeatures(),
+		fSuperBlock.ReadOnlyFeatures());
+
 	// check read-only features if mounting read-write
 	if (!IsReadOnly() && _UnsupportedReadOnlyFeatures(fSuperBlock) != 0)
 		return B_UNSUPPORTED;
 
+	if (HasMetaGroupChecksumFeature() && HasChecksumFeature())
+		return B_ERROR;
+
+	if (!_VerifySuperBlock())
+		return B_ERROR;
+
 	// initialize short hands to the superblock (to save byte swapping)
 	fBlockShift = fSuperBlock.BlockShift();
 	if (fBlockShift < 10 || fBlockShift > 16)
 		return B_ERROR;
+	if (fBlockShift > 12) {
+		FATAL("blocksize not supported!\n");
+		return B_UNSUPPORTED;
+	}
 	fBlockSize = 1UL << fBlockShift;
 	fFirstDataBlock = fSuperBlock.FirstDataBlock();
 
 	fFreeBlocks = fSuperBlock.FreeBlocks(Has64bitFeature());
 	fFreeInodes = fSuperBlock.FreeInodes();
 
+	if (fFirstDataBlock > fSuperBlock.NumBlocks(Has64bitFeature()))
+		return B_ERROR;
+
 	off_t numBlocks = fSuperBlock.NumBlocks(Has64bitFeature()) - fFirstDataBlock;
 	uint32 blocksPerGroup = fSuperBlock.BlocksPerGroup();
 	fNumGroups = numBlocks / blocksPerGroup;
 	if (numBlocks % blocksPerGroup != 0)
 		fNumGroups++;
 
+	if (blocksPerGroup == 0 || fSuperBlock.FragmentsPerGroup() == 0) {
+		FATAL("zero blocksPerGroup or fragmentsPerGroup!\n");
+		return B_UNSUPPORTED;
+	}
+	if (blocksPerGroup != fSuperBlock.FragmentsPerGroup()) {
+		FATAL("blocksPerGroup is not equal to fragmentsPerGroup!\n");
+		return B_UNSUPPORTED;
+	}
+
 	if (Has64bitFeature()) {
+		TRACE("64bits\n");
 		fGroupDescriptorSize = fSuperBlock.GroupDescriptorSize();
 		if (fGroupDescriptorSize < sizeof(ext2_block_group))
 			return B_ERROR;
+		if (fGroupDescriptorSize != sizeof(ext2_block_group))
+			return B_UNSUPPORTED;
 	} else
 		fGroupDescriptorSize = EXT2_BLOCK_GROUP_NORMAL_SIZE;
 	fGroupsPerBlock = fBlockSize / fGroupDescriptorSize;
 	fNumInodes = fSuperBlock.NumInodes();
 
 	TRACE("block size %" B_PRIu32 ", num groups %" B_PRIu32 ", groups per "
-		"block %" B_PRIu32 ", first %" B_PRIu32 "\n", fBlockSize, fNumGroups,
-		fGroupsPerBlock, fFirstDataBlock);
+		"block %" B_PRIu32 ", first %" B_PRIu32 ", group_descriptor_size %"
+		B_PRIu32 "\n", fBlockSize, fNumGroups,
+		fGroupsPerBlock, fFirstDataBlock, fGroupDescriptorSize);
 
 	uint32 blockCount = (fNumGroups + fGroupsPerBlock - 1) / fGroupsPerBlock;
 
@@ -355,6 +381,8 @@ Volume::Mount(const char* deviceName, uint32 flags)
 	memset(fGroupBlocks, 0, blockCount * sizeof(uint8*));
 	fInodesPerBlock = fBlockSize / InodeSize();
 
+	_SuperBlockChecksumSeed();
+
 	// check if the device size is large enough to hold the file system
 	off_t diskSize;
 	status = opener.GetSize(&diskSize);
@@ -480,6 +508,8 @@ Volume::Unmount()
 
 	status_t status = fJournal->Uninit();
 
+	// this will wait on the block notifier/writer thread
+	FlushDevice();
 	delete fJournal;
 	delete fJournalInode;
 
@@ -524,7 +554,8 @@ Volume::_UnsupportedIncompatibleFeatures(ext2_super_block& superBlock)
 		| EXT2_INCOMPATIBLE_FEATURE_RECOVER
 		| EXT2_INCOMPATIBLE_FEATURE_JOURNAL
 		| EXT2_INCOMPATIBLE_FEATURE_EXTENTS
-		| EXT2_INCOMPATIBLE_FEATURE_FLEX_GROUP;
+		| EXT2_INCOMPATIBLE_FEATURE_FLEX_GROUP
+		| EXT2_INCOMPATIBLE_FEATURE_64BIT;
 		/*| EXT2_INCOMPATIBLE_FEATURE_META_GROUP*/;
 	uint32 unsupported = superBlock.IncompatibleFeatures()
 		& ~supportedIncompatible;
@@ -546,7 +577,8 @@ Volume::_UnsupportedReadOnlyFeatures(ext2_super_block& superBlock)
 		| EXT2_READ_ONLY_FEATURE_HUGE_FILE
 		| EXT2_READ_ONLY_FEATURE_EXTRA_ISIZE
 		| EXT2_READ_ONLY_FEATURE_DIR_NLINK
-		| EXT2_READ_ONLY_FEATURE_GDT_CSUM;
+		| EXT2_READ_ONLY_FEATURE_GDT_CSUM
+		| EXT4_READ_ONLY_FEATURE_METADATA_CSUM;
 	// TODO actually implement EXT2_READ_ONLY_FEATURE_SPARSE_SUPER when
 	// implementing superblock backup copies
 
@@ -577,19 +609,32 @@ Volume::_GroupDescriptorBlock(uint32 blockIndex)
 uint16
 Volume::_GroupCheckSum(ext2_block_group *group, int32 index)
 {
-	uint16 checksum = 0;
-	if (HasChecksumFeature()) {
-		int32 number = B_HOST_TO_LENDIAN_INT32(index);
-		checksum = calculate_crc(0xffff, fSuperBlock.uuid,
+	int32 number = B_HOST_TO_LENDIAN_INT32(index);
+	size_t offset = offsetof(ext2_block_group, checksum);
+	size_t offsetExt4 = offsetof(ext2_block_group, block_bitmap_high);
+	if (HasMetaGroupChecksumFeature()) {
+		uint16 dummy = 0;
+		uint32 checksum = calculate_crc32c(fChecksumSeed, (uint8*)&number,
+			sizeof(number));
+		checksum = calculate_crc32c(checksum, (uint8*)group, offset);
+		checksum = calculate_crc32c(checksum, (uint8*)&dummy, sizeof(dummy));
+		if (fGroupDescriptorSize > offset + sizeof(dummy)) {
+			checksum = calculate_crc32c(checksum, (uint8*)group + offsetExt4,
+				fGroupDescriptorSize - offsetExt4);
+		}
+		return checksum & 0xffff;
+	} else if (HasChecksumFeature()) {
+		uint16 checksum = calculate_crc(0xffff, fSuperBlock.uuid,
 			sizeof(fSuperBlock.uuid));
 		checksum = calculate_crc(checksum, (uint8*)&number, sizeof(number));
-		checksum = calculate_crc(checksum, (uint8*)group, 30);
-		if (Has64bitFeature()) {
-			checksum = calculate_crc(checksum, (uint8*)group + 34,
-				fGroupDescriptorSize - 34);
+		checksum = calculate_crc(checksum, (uint8*)group, offset);
+		if (Has64bitFeature() && fGroupDescriptorSize > offsetExt4) {
+			checksum = calculate_crc(checksum, (uint8*)group + offsetExt4,
+				fGroupDescriptorSize - offsetExt4);
 		}
+		return checksum;
 	}
-	return checksum;
+	return 0;
 }
 
 
@@ -890,6 +935,11 @@ Volume::WriteSuperBlock(Transaction& transaction)
 	fSuperBlock.SetFreeInodes(fFreeInodes);
 	// TODO: Rest of fields that can be modified
 
+	if (HasMetaGroupChecksumFeature()) {
+		fSuperBlock.checksum = calculate_crc32c(0xffffffff, (uint8*)&fSuperBlock,
+			offsetof(struct ext2_super_block, checksum));
+	}
+
 	TRACE("Volume::WriteSuperBlock(): free blocks: %" B_PRIu64 ", free inodes:"
 		" %" B_PRIu32 "\n", fSuperBlock.FreeBlocks(Has64bitFeature()),
 		fSuperBlock.FreeInodes());
@@ -914,6 +964,31 @@ Volume::WriteSuperBlock(Transaction& transaction)
 }
 
 
+void
+Volume::_SuperBlockChecksumSeed()
+{
+	if (HasChecksumSeedFeature()) {
+		fChecksumSeed = fSuperBlock.checksum_seed;
+	} else if (HasMetaGroupChecksumFeature()) {
+		fChecksumSeed = calculate_crc32c(0xffffffff, (uint8*)fSuperBlock.uuid,
+			sizeof(fSuperBlock.uuid));
+	} else
+		fChecksumSeed = 0;
+}
+
+
+bool
+Volume::_VerifySuperBlock()
+{
+	if (!HasMetaGroupChecksumFeature())
+		return true;
+
+	uint32 checksum = calculate_crc32c(0xffffffff, (uint8*)&fSuperBlock,
+		offsetof(struct ext2_super_block, checksum));
+	return checksum == fSuperBlock.checksum;
+}
+
+
 status_t
 Volume::FlushDevice()
 {
@@ -945,8 +1020,10 @@ Volume::Identify(int fd, ext2_super_block* superBlock)
 		return B_BAD_VALUE;
 	}
 
-	return _UnsupportedIncompatibleFeatures(*superBlock) == 0
-		? B_OK : B_UNSUPPORTED;
+	if (_UnsupportedIncompatibleFeatures(*superBlock) != 0)
+		return B_UNSUPPORTED;
+
+	return B_OK;
 }
 
 
diff --git a/src/add-ons/kernel/file_systems/ext2/Volume.h b/src/add-ons/kernel/file_systems/ext2/Volume.h
index 4e7637a9ab..37618dbe88 100644
--- a/src/add-ons/kernel/file_systems/ext2/Volume.h
+++ b/src/add-ons/kernel/file_systems/ext2/Volume.h
@@ -81,7 +81,7 @@ public:
 								{ return (fSuperBlock.CompatibleFeatures()
 									& EXT2_FEATURE_DIRECTORY_INDEX) != 0; }
 			bool				Has64bitFeature() const
-								{ return (fSuperBlock.CompatibleFeatures()
+								{ return (fSuperBlock.IncompatibleFeatures()
 									& EXT2_INCOMPATIBLE_FEATURE_64BIT) != 0; }
 			bool				HasExtentsFeature() const
 								{ return (fSuperBlock.IncompatibleFeatures()
@@ -94,6 +94,14 @@ public:
 								{ return (fSuperBlock.IncompatibleFeatures()
 									& EXT2_INCOMPATIBLE_FEATURE_META_GROUP)
 									!= 0; }
+			bool				HasMetaGroupChecksumFeature() const
+								{ return (fSuperBlock.ReadOnlyFeatures()
+									& EXT4_READ_ONLY_FEATURE_METADATA_CSUM)
+									!= 0; }
+			bool				HasChecksumSeedFeature() const
+								{ return (fSuperBlock.IncompatibleFeatures()
+									& EXT2_INCOMPATIBLE_FEATURE_CSUM_SEED)
+									!= 0; }
 			uint8				DefaultHashVersion() const
 								{ return fSuperBlock.default_hash_version; }
 			bool				HugeFiles() const
@@ -125,6 +133,11 @@ public:
 			// cache access
 			void*				BlockCache() { return fBlockCache; }
 
+			uint32				ChecksumSeed() const
+									{ return fChecksumSeed; }
+			uint16				GroupDescriptorSize() const
+									{ return fGroupDescriptorSize; }
+
 			status_t			FlushDevice();
 			status_t			Sync();
 
@@ -140,10 +153,10 @@ private:
 	static	uint32				_UnsupportedReadOnlyFeatures(
 									ext2_super_block& superBlock);
 			uint32				_GroupDescriptorBlock(uint32 blockIndex);
-			uint16				_GroupDescriptorSize() 
-									{ return fGroupDescriptorSize; }
 			uint16				_GroupCheckSum(ext2_block_group *group,
 									int32 index);
+			void				_SuperBlockChecksumSeed();
+			bool				_VerifySuperBlock();
 
 private:
 			mutex				fLock;
@@ -173,6 +186,8 @@ private:
 
 			void*				fBlockCache;
 			Inode*				fRootNode;
+
+			uint32				fChecksumSeed;
 };
 
 
diff --git a/src/add-ons/kernel/file_systems/ext2/crc32.c b/src/add-ons/kernel/file_systems/ext2/crc32.c
new file mode 100644
index 0000000000..944c154892
--- /dev/null
+++ b/src/add-ons/kernel/file_systems/ext2/crc32.c
@@ -0,0 +1,763 @@
+/*-
+ *  COPYRIGHT (C) 1986 Gary S. Brown.  You may use this program, or
+ *  code or tables extracted from it, as desired without restriction.
+ */
+
+/*
+ *  First, the polynomial itself and its table of feedback terms.  The
+ *  polynomial is
+ *  X^32+X^26+X^23+X^22+X^16+X^12+X^11+X^10+X^8+X^7+X^5+X^4+X^2+X^1+X^0
+ *
+ *  Note that we take it "backwards" and put the highest-order term in
+ *  the lowest-order bit.  The X^32 term is "implied"; the LSB is the
+ *  X^31 term, etc.  The X^0 term (usually shown as "+1") results in
+ *  the MSB being 1
+ *
+ *  Note that the usual hardware shift register implementation, which
+ *  is what we're using (we're merely optimizing it by doing eight-bit
+ *  chunks at a time) shifts bits into the lowest-order term.  In our
+ *  implementation, that means shifting towards the right.  Why do we
+ *  do it this way?  Because the calculated CRC must be transmitted in
+ *  order from highest-order term to lowest-order term.  UARTs transmit
+ *  characters in order from LSB to MSB.  By storing the CRC this way
+ *  we hand it to the UART in the order low-byte to high-byte; the UART
+ *  sends each low-bit to hight-bit; and the result is transmission bit
+ *  by bit from highest- to lowest-order term without requiring any bit
+ *  shuffling on our part.  Reception works similarly
+ *
+ *  The feedback terms table consists of 256, 32-bit entries.  Notes
+ *
+ *      The table can be generated at runtime if desired; code to do so
+ *      is shown later.  It might not be obvious, but the feedback
+ *      terms simply represent the results of eight shift/xor opera
+ *      tions for all combinations of data and CRC register values
+ *
+ *      The values must be right-shifted by eight bits by the "updcrc
+ *      logic; the shift must be unsigned (bring in zeroes).  On some
+ *      hardware you could probably optimize the shift in assembler by
+ *      using byte-swap instructions
+ *      polynomial $edb88320
+ *
+ *
+ * CRC32 code derived from work by Gary S. Brown.
+ */
+
+#include <sys/cdefs.h>
+#include <sys/param.h>
+#ifdef __HAIKU__
+#define	rounddown(x, y)	(((x)/(y))*(y))
+#include <endian.h>
+#include <size_t.h>
+#include <stdint.h>
+uint32_t calculate_crc32c(uint32_t crc32c, const unsigned char *buffer,
+	unsigned int length);
+#endif
+
+const uint32_t crc32_tab[] = {
+	0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
+	0xe963a535, 0x9e6495a3,	0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
+	0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
+	0xf3b97148, 0x84be41de,	0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
+	0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,	0x14015c4f, 0x63066cd9,
+	0xfa0f3d63, 0x8d080df5,	0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
+	0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,	0x35b5a8fa, 0x42b2986c,
+	0xdbbbc9d6, 0xacbcf940,	0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
+	0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
+	0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+	0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,	0x76dc4190, 0x01db7106,
+	0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
+	0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
+	0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
+	0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
+	0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
+	0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
+	0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
+	0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
+	0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+	0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
+	0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
+	0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
+	0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
+	0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
+	0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
+	0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
+	0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
+	0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
+	0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+	0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
+	0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
+	0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
+	0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
+	0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
+	0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
+	0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
+	0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
+	0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
+	0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+	0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
+	0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
+	0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
+};
+
+/*
+ * A function that calculates the CRC-32 based on the table above is
+ * given below for documentation purposes. An equivalent implementation
+ * of this function that's actually used in the kernel can be found
+ * in sys/libkern.h, where it can be inlined.
+ *
+ *	uint32_t
+ *	crc32(const void *buf, size_t size)
+ *	{
+ *		const uint8_t *p = buf;
+ *		uint32_t crc;
+ *
+ *		crc = ~0U;
+ *		while (size--)
+ *			crc = crc32_tab[(crc ^ *p++) & 0xFF] ^ (crc >> 8);
+ *		return crc ^ ~0U;
+ *	}
+ */
+
+/* CRC32C routines, these use a different polynomial */
+/*****************************************************************/
+/*                                                               */
+/* CRC LOOKUP TABLE                                              */
+/* ================                                              */
+/* The following CRC lookup table was generated automagically    */
+/* by the Rocksoft^tm Model CRC Algorithm Table Generation       */
+/* Program V1.0 using the following model parameters:            */
+/*                                                               */
+/*    Width   : 4 bytes.                                         */
+/*    Poly    : 0x1EDC6F41L                                      */
+/*    Reverse : TRUE.                                            */
+/*                                                               */
+/* For more information on the Rocksoft^tm Model CRC Algorithm,  */
+/* see the document titled "A Painless Guide to CRC Error        */
+/* Detection Algorithms" by Ross Williams                        */
+/* (ross@guest.adelaide.edu.au.). This document is likely to be  */
+/* in the FTP archive "ftp.adelaide.edu.au/pub/rocksoft".        */
+/*                                                               */
+/*****************************************************************/
+
+static const uint32_t crc32Table[256] = {
+	0x00000000L, 0xF26B8303L, 0xE13B70F7L, 0x1350F3F4L,
+	0xC79A971FL, 0x35F1141CL, 0x26A1E7E8L, 0xD4CA64EBL,
+	0x8AD958CFL, 0x78B2DBCCL, 0x6BE22838L, 0x9989AB3BL,
+	0x4D43CFD0L, 0xBF284CD3L, 0xAC78BF27L, 0x5E133C24L,
+	0x105EC76FL, 0xE235446CL, 0xF165B798L, 0x030E349BL,
+	0xD7C45070L, 0x25AFD373L, 0x36FF2087L, 0xC494A384L,
+	0x9A879FA0L, 0x68EC1CA3L, 0x7BBCEF57L, 0x89D76C54L,
+	0x5D1D08BFL, 0xAF768BBCL, 0xBC267848L, 0x4E4DFB4BL,
+	0x20BD8EDEL, 0xD2D60DDDL, 0xC186FE29L, 0x33ED7D2AL,
+	0xE72719C1L, 0x154C9AC2L, 0x061C6936L, 0xF477EA35L,
+	0xAA64D611L, 0x580F5512L, 0x4B5FA6E6L, 0xB93425E5L,
+	0x6DFE410EL, 0x9F95C20DL, 0x8CC531F9L, 0x7EAEB2FAL,
+	0x30E349B1L, 0xC288CAB2L, 0xD1D83946L, 0x23B3BA45L,
+	0xF779DEAEL, 0x05125DADL, 0x1642AE59L, 0xE4292D5AL,
+	0xBA3A117EL, 0x4851927DL, 0x5B016189L, 0xA96AE28AL,
+	0x7DA08661L, 0x8FCB0562L, 0x9C9BF696L, 0x6EF07595L,
+	0x417B1DBCL, 0xB3109EBFL, 0xA0406D4BL, 0x522BEE48L,
+	0x86E18AA3L, 0x748A09A0L, 0x67DAFA54L, 0x95B17957L,
+	0xCBA24573L, 0x39C9C670L, 0x2A993584L, 0xD8F2B687L,
+	0x0C38D26CL, 0xFE53516FL, 0xED03A29BL, 0x1F682198L,
+	0x5125DAD3L, 0xA34E59D0L, 0xB01EAA24L, 0x42752927L,
+	0x96BF4DCCL, 0x64D4CECFL, 0x77843D3BL, 0x85EFBE38L,
+	0xDBFC821CL, 0x2997011FL, 0x3AC7F2EBL, 0xC8AC71E8L,
+	0x1C661503L, 0xEE0D9600L, 0xFD5D65F4L, 0x0F36E6F7L,
+	0x61C69362L, 0x93AD1061L, 0x80FDE395L, 0x72966096L,
+	0xA65C047DL, 0x5437877EL, 0x4767748AL, 0xB50CF789L,
+	0xEB1FCBADL, 0x197448AEL, 0x0A24BB5AL, 0xF84F3859L,
+	0x2C855CB2L, 0xDEEEDFB1L, 0xCDBE2C45L, 0x3FD5AF46L,
+	0x7198540DL, 0x83F3D70EL, 0x90A324FAL, 0x62C8A7F9L,
+	0xB602C312L, 0x44694011L, 0x5739B3E5L, 0xA55230E6L,
+	0xFB410CC2L, 0x092A8FC1L, 0x1A7A7C35L, 0xE811FF36L,
+	0x3CDB9BDDL, 0xCEB018DEL, 0xDDE0EB2AL, 0x2F8B6829L,
+	0x82F63B78L, 0x709DB87BL, 0x63CD4B8FL, 0x91A6C88CL,
+	0x456CAC67L, 0xB7072F64L, 0xA457DC90L, 0x563C5F93L,
+	0x082F63B7L, 0xFA44E0B4L, 0xE9141340L, 0x1B7F9043L,
+	0xCFB5F4A8L, 0x3DDE77ABL, 0x2E8E845FL, 0xDCE5075CL,
+	0x92A8FC17L, 0x60C37F14L, 0x73938CE0L, 0x81F80FE3L,
+	0x55326B08L, 0xA759E80BL, 0xB4091BFFL, 0x466298FCL,
+	0x1871A4D8L, 0xEA1A27DBL, 0xF94AD42FL, 0x0B21572CL,
+	0xDFEB33C7L, 0x2D80B0C4L, 0x3ED04330L, 0xCCBBC033L,
+	0xA24BB5A6L, 0x502036A5L, 0x4370C551L, 0xB11B4652L,
+	0x65D122B9L, 0x97BAA1BAL, 0x84EA524EL, 0x7681D14DL,
+	0x2892ED69L, 0xDAF96E6AL, 0xC9A99D9EL, 0x3BC21E9DL,
+	0xEF087A76L, 0x1D63F975L, 0x0E330A81L, 0xFC588982L,
+	0xB21572C9L, 0x407EF1CAL, 0x532E023EL, 0xA145813DL,
+	0x758FE5D6L, 0x87E466D5L, 0x94B49521L, 0x66DF1622L,
+	0x38CC2A06L, 0xCAA7A905L, 0xD9F75AF1L, 0x2B9CD9F2L,
+	0xFF56BD19L, 0x0D3D3E1AL, 0x1E6DCDEEL, 0xEC064EEDL,
+	0xC38D26C4L, 0x31E6A5C7L, 0x22B65633L, 0xD0DDD530L,
+	0x0417B1DBL, 0xF67C32D8L, 0xE52CC12CL, 0x1747422FL,
+	0x49547E0BL, 0xBB3FFD08L, 0xA86F0EFCL, 0x5A048DFFL,
+	0x8ECEE914L, 0x7CA56A17L, 0x6FF599E3L, 0x9D9E1AE0L,
+	0xD3D3E1ABL, 0x21B862A8L, 0x32E8915CL, 0xC083125FL,
+	0x144976B4L, 0xE622F5B7L, 0xF5720643L, 0x07198540L,
+	0x590AB964L, 0xAB613A67L, 0xB831C993L, 0x4A5A4A90L,
+	0x9E902E7BL, 0x6CFBAD78L, 0x7FAB5E8CL, 0x8DC0DD8FL,
+	0xE330A81AL, 0x115B2B19L, 0x020BD8EDL, 0xF0605BEEL,
+	0x24AA3F05L, 0xD6C1BC06L, 0xC5914FF2L, 0x37FACCF1L,
+	0x69E9F0D5L, 0x9B8273D6L, 0x88D28022L, 0x7AB90321L,
+	0xAE7367CAL, 0x5C18E4C9L, 0x4F48173DL, 0xBD23943EL,
+	0xF36E6F75L, 0x0105EC76L, 0x12551F82L, 0xE03E9C81L,
+	0x34F4F86AL, 0xC69F7B69L, 0xD5CF889DL, 0x27A40B9EL,
+	0x79B737BAL, 0x8BDCB4B9L, 0x988C474DL, 0x6AE7C44EL,
+	0xBE2DA0A5L, 0x4C4623A6L, 0x5F16D052L, 0xAD7D5351L
+};
+
+static uint32_t
+singletable_crc32c(uint32_t crc, const void *buf, size_t size)
+{
+	const uint8_t *p = buf;
+
+
+	while (size--)
+		crc = crc32Table[(crc ^ *p++) & 0xff] ^ (crc >> 8);
+
+	return crc;
+}
+
+
+/*
+ * Copyright (c) 2004-2006 Intel Corporation - All Rights Reserved
+ *
+ *
+ * This software program is licensed subject to the BSD License, available at
+ * http://www.opensource.org/licenses/bsd-license.html.
+ *
+ * Abstract:
+ *
+ * Tables for software CRC generation
+ */
+
+/*
+ * The following CRC lookup table was generated automagically using the
+ * following model parameters:
+ *
+ * Generator Polynomial = ................. 0x1EDC6F41
+ * Generator Polynomial Length = .......... 32 bits
+ * Reflected Bits = ....................... TRUE
+ * Table Generation Offset = .............. 32 bits
+ * Number of Slices = ..................... 8 slices
+ * Slice Lengths = ........................ 8 8 8 8 8 8 8 8
+ * Directory Name = ....................... .\
+ * File Name = ............................ 8x256_tables.c
+ */
+
+static const uint32_t sctp_crc_tableil8_o32[256] =
+{
+	0x00000000, 0xF26B8303, 0xE13B70F7, 0x1350F3F4, 0xC79A971F, 0x35F1141C, 0x26A1E7E8, 0xD4CA64EB,
+	0x8AD958CF, 0x78B2DBCC, 0x6BE22838, 0x9989AB3B, 0x4D43CFD0, 0xBF284CD3, 0xAC78BF27, 0x5E133C24,
+	0x105EC76F, 0xE235446C, 0xF165B798, 0x030E349B, 0xD7C45070, 0x25AFD373, 0x36FF2087, 0xC494A384,
+	0x9A879FA0, 0x68EC1CA3, 0x7BBCEF57, 0x89D76C54, 0x5D1D08BF, 0xAF768BBC, 0xBC267848, 0x4E4DFB4B,
+	0x20BD8EDE, 0xD2D60DDD, 0xC186FE29, 0x33ED7D2A, 0xE72719C1, 0x154C9AC2, 0x061C6936, 0xF477EA35,
+	0xAA64D611, 0x580F5512, 0x4B5FA6E6, 0xB93425E5, 0x6DFE410E, 0x9F95C20D, 0x8CC531F9, 0x7EAEB2FA,
+	0x30E349B1, 0xC288CAB2, 0xD1D83946, 0x23B3BA45, 0xF779DEAE, 0x05125DAD, 0x1642AE59, 0xE4292D5A,
+	0xBA3A117E, 0x4851927D, 0x5B016189, 0xA96AE28A, 0x7DA08661, 0x8FCB0562, 0x9C9BF696, 0x6EF07595,
+	0x417B1DBC, 0xB3109EBF, 0xA0406D4B, 0x522BEE48, 0x86E18AA3, 0x748A09A0, 0x67DAFA54, 0x95B17957,
+	0xCBA24573, 0x39C9C670, 0x2A993584, 0xD8F2B687, 0x0C38D26C, 0xFE53516F, 0xED03A29B, 0x1F682198,
+	0x5125DAD3, 0xA34E59D0, 0xB01EAA24, 0x42752927, 0x96BF4DCC, 0x64D4CECF, 0x77843D3B, 0x85EFBE38,
+	0xDBFC821C, 0x2997011F, 0x3AC7F2EB, 0xC8AC71E8, 0x1C661503, 0xEE0D9600, 0xFD5D65F4, 0x0F36E6F7,
+	0x61C69362, 0x93AD1061, 0x80FDE395, 0x72966096, 0xA65C047D, 0x5437877E, 0x4767748A, 0xB50CF789,
+	0xEB1FCBAD, 0x197448AE, 0x0A24BB5A, 0xF84F3859, 0x2C855CB2, 0xDEEEDFB1, 0xCDBE2C45, 0x3FD5AF46,
+	0x7198540D, 0x83F3D70E, 0x90A324FA, 0x62C8A7F9, 0xB602C312, 0x44694011, 0x5739B3E5, 0xA55230E6,
+	0xFB410CC2, 0x092A8FC1, 0x1A7A7C35, 0xE811FF36, 0x3CDB9BDD, 0xCEB018DE, 0xDDE0EB2A, 0x2F8B6829,
+	0x82F63B78, 0x709DB87B, 0x63CD4B8F, 0x91A6C88C, 0x456CAC67, 0xB7072F64, 0xA457DC90, 0x563C5F93,
+	0x082F63B7, 0xFA44E0B4, 0xE9141340, 0x1B7F9043, 0xCFB5F4A8, 0x3DDE77AB, 0x2E8E845F, 0xDCE5075C,
+	0x92A8FC17, 0x60C37F14, 0x73938CE0, 0x81F80FE3, 0x55326B08, 0xA759E80B, 0xB4091BFF, 0x466298FC,
+	0x1871A4D8, 0xEA1A27DB, 0xF94AD42F, 0x0B21572C, 0xDFEB33C7, 0x2D80B0C4, 0x3ED04330, 0xCCBBC033,
+	0xA24BB5A6, 0x502036A5, 0x4370C551, 0xB11B4652, 0x65D122B9, 0x97BAA1BA, 0x84EA524E, 0x7681D14D,
+	0x2892ED69, 0xDAF96E6A, 0xC9A99D9E, 0x3BC21E9D, 0xEF087A76, 0x1D63F975, 0x0E330A81, 0xFC588982,
+	0xB21572C9, 0x407EF1CA, 0x532E023E, 0xA145813D, 0x758FE5D6, 0x87E466D5, 0x94B49521, 0x66DF1622,
+	0x38CC2A06, 0xCAA7A905, 0xD9F75AF1, 0x2B9CD9F2, 0xFF56BD19, 0x0D3D3E1A, 0x1E6DCDEE, 0xEC064EED,
+	0xC38D26C4, 0x31E6A5C7, 0x22B65633, 0xD0DDD530, 0x0417B1DB, 0xF67C32D8, 0xE52CC12C, 0x1747422F,
+	0x49547E0B, 0xBB3FFD08, 0xA86F0EFC, 0x5A048DFF, 0x8ECEE914, 0x7CA56A17, 0x6FF599E3, 0x9D9E1AE0,
+	0xD3D3E1AB, 0x21B862A8, 0x32E8915C, 0xC083125F, 0x144976B4, 0xE622F5B7, 0xF5720643, 0x07198540,
+	0x590AB964, 0xAB613A67, 0xB831C993, 0x4A5A4A90, 0x9E902E7B, 0x6CFBAD78, 0x7FAB5E8C, 0x8DC0DD8F,
+	0xE330A81A, 0x115B2B19, 0x020BD8ED, 0xF0605BEE, 0x24AA3F05, 0xD6C1BC06, 0xC5914FF2, 0x37FACCF1,
+	0x69E9F0D5, 0x9B8273D6, 0x88D28022, 0x7AB90321, 0xAE7367CA, 0x5C18E4C9, 0x4F48173D, 0xBD23943E,
+	0xF36E6F75, 0x0105EC76, 0x12551F82, 0xE03E9C81, 0x34F4F86A, 0xC69F7B69, 0xD5CF889D, 0x27A40B9E,
+	0x79B737BA, 0x8BDCB4B9, 0x988C474D, 0x6AE7C44E, 0xBE2DA0A5, 0x4C4623A6, 0x5F16D052, 0xAD7D5351
+};
+
+/*
+ * end of the CRC lookup table crc_tableil8_o32
+ */
+
+
+
+/*
+ * The following CRC lookup table was generated automagically using the
+ * following model parameters:
+ *
+ * Generator Polynomial = ................. 0x1EDC6F41
+ * Generator Polynomial Length = .......... 32 bits
+ * Reflected Bits = ....................... TRUE
+ * Table Generation Offset = .............. 32 bits
+ * Number of Slices = ..................... 8 slices
+ * Slice Lengths = ........................ 8 8 8 8 8 8 8 8
+ * Directory Name = ....................... .\
+ * File Name = ............................ 8x256_tables.c
+ */
+
+static const uint32_t sctp_crc_tableil8_o40[256] =
+{
+	0x00000000, 0x13A29877, 0x274530EE, 0x34E7A899, 0x4E8A61DC, 0x5D28F9AB, 0x69CF5132, 0x7A6DC945,
+	0x9D14C3B8, 0x8EB65BCF, 0xBA51F356, 0xA9F36B21, 0xD39EA264, 0xC03C3A13, 0xF4DB928A, 0xE7790AFD,
+	0x3FC5F181, 0x2C6769F6, 0x1880C16F, 0x0B225918, 0x714F905D, 0x62ED082A, 0x560AA0B3, 0x45A838C4,
+	0xA2D13239, 0xB173AA4E, 0x859402D7, 0x96369AA0, 0xEC5B53E5, 0xFFF9CB92, 0xCB1E630B, 0xD8BCFB7C,
+	0x7F8BE302, 0x6C297B75, 0x58CED3EC, 0x4B6C4B9B, 0x310182DE, 0x22A31AA9, 0x1644B230, 0x05E62A47,
+	0xE29F20BA, 0xF13DB8CD, 0xC5DA1054, 0xD6788823, 0xAC154166, 0xBFB7D911, 0x8B507188, 0x98F2E9FF,
+	0x404E1283, 0x53EC8AF4, 0x670B226D, 0x74A9BA1A, 0x0EC4735F, 0x1D66EB28, 0x298143B1, 0x3A23DBC6,
+	0xDD5AD13B, 0xCEF8494C, 0xFA1FE1D5, 0xE9BD79A2, 0x93D0B0E7, 0x80722890, 0xB4958009, 0xA737187E,
+	0xFF17C604, 0xECB55E73, 0xD852F6EA, 0xCBF06E9D, 0xB19DA7D8, 0xA23F3FAF, 0x96D89736, 0x857A0F41,
+	0x620305BC, 0x71A19DCB, 0x45463552, 0x56E4AD25, 0x2C896460, 0x3F2BFC17, 0x0BCC548E, 0x186ECCF9,
+	0xC0D23785, 0xD370AFF2, 0xE797076B, 0xF4359F1C, 0x8E585659, 0x9DFACE2E, 0xA91D66B7, 0xBABFFEC0,
+	0x5DC6F43D, 0x4E646C4A, 0x7A83C4D3, 0x69215CA4, 0x134C95E1, 0x00EE0D96, 0x3409A50F, 0x27AB3D78,
+	0x809C2506, 0x933EBD71, 0xA7D915E8, 0xB47B8D9F, 0xCE1644DA, 0xDDB4DCAD, 0xE9537434, 0xFAF1EC43,
+	0x1D88E6BE, 0x0E2A7EC9, 0x3ACDD650, 0x296F4E27, 0x53028762, 0x40A01F15, 0x7447B78C, 0x67E52FFB,
+	0xBF59D487, 0xACFB4CF0, 0x981CE469, 0x8BBE7C1E, 0xF1D3B55B, 0xE2712D2C, 0xD69685B5, 0xC5341DC2,
+	0x224D173F, 0x31EF8F48, 0x050827D1, 0x16AABFA6, 0x6CC776E3, 0x7F65EE94, 0x4B82460D, 0x5820DE7A,
+	0xFBC3FAF9, 0xE861628E, 0xDC86CA17, 0xCF245260, 0xB5499B25, 0xA6EB0352, 0x920CABCB, 0x81AE33BC,
+	0x66D73941, 0x7575A136, 0x419209AF, 0x523091D8, 0x285D589D, 0x3BFFC0EA, 0x0F186873, 0x1CBAF004,
+	0xC4060B78, 0xD7A4930F, 0xE3433B96, 0xF0E1A3E1, 0x8A8C6AA4, 0x992EF2D3, 0xADC95A4A, 0xBE6BC23D,
+	0x5912C8C0, 0x4AB050B7, 0x7E57F82E, 0x6DF56059, 0x1798A91C, 0x043A316B, 0x30DD99F2, 0x237F0185,
+	0x844819FB, 0x97EA818C, 0xA30D2915, 0xB0AFB162, 0xCAC27827, 0xD960E050, 0xED8748C9, 0xFE25D0BE,
+	0x195CDA43, 0x0AFE4234, 0x3E19EAAD, 0x2DBB72DA, 0x57D6BB9F, 0x447423E8, 0x70938B71, 0x63311306,
+	0xBB8DE87A, 0xA82F700D, 0x9CC8D894, 0x8F6A40E3, 0xF50789A6, 0xE6A511D1, 0xD242B948, 0xC1E0213F,
+	0x26992BC2, 0x353BB3B5, 0x01DC1B2C, 0x127E835B, 0x68134A1E, 0x7BB1D269, 0x4F567AF0, 0x5CF4E287,
+	0x04D43CFD, 0x1776A48A, 0x23910C13, 0x30339464, 0x4A5E5D21, 0x59FCC556, 0x6D1B6DCF, 0x7EB9F5B8,
+	0x99C0FF45, 0x8A626732, 0xBE85CFAB, 0xAD2757DC, 0xD74A9E99, 0xC4E806EE, 0xF00FAE77, 0xE3AD3600,
+	0x3B11CD7C, 0x28B3550B, 0x1C54FD92, 0x0FF665E5, 0x759BACA0, 0x663934D7, 0x52DE9C4E, 0x417C0439,
+	0xA6050EC4, 0xB5A796B3, 0x81403E2A, 0x92E2A65D, 0xE88F6F18, 0xFB2DF76F, 0xCFCA5FF6, 0xDC68C781,
+	0x7B5FDFFF, 0x68FD4788, 0x5C1AEF11, 0x4FB87766, 0x35D5BE23, 0x26772654, 0x12908ECD, 0x013216BA,
+	0xE64B1C47, 0xF5E98430, 0xC10E2CA9, 0xD2ACB4DE, 0xA8C17D9B, 0xBB63E5EC, 0x8F844D75, 0x9C26D502,
+	0x449A2E7E, 0x5738B609, 0x63DF1E90, 0x707D86E7, 0x0A104FA2, 0x19B2D7D5, 0x2D557F4C, 0x3EF7E73B,
+	0xD98EEDC6, 0xCA2C75B1, 0xFECBDD28, 0xED69455F, 0x97048C1A, 0x84A6146D, 0xB041BCF4, 0xA3E32483
+};
+
+/*
+ * end of the CRC lookup table crc_tableil8_o40
+ */
+
+
+
+/*
+ * The following CRC lookup table was generated automagically using the
+ * following model parameters:
+ *
+ * Generator Polynomial = ................. 0x1EDC6F41
+ * Generator Polynomial Length = .......... 32 bits
+ * Reflected Bits = ....................... TRUE
+ * Table Generation Offset = .............. 32 bits
+ * Number of Slices = ..................... 8 slices
+ * Slice Lengths = ........................ 8 8 8 8 8 8 8 8
+ * Directory Name = ....................... .\
+ * File Name = ............................ 8x256_tables.c
+ */
+
+static const uint32_t sctp_crc_tableil8_o48[256] =
+{
+	0x00000000, 0xA541927E, 0x4F6F520D, 0xEA2EC073, 0x9EDEA41A, 0x3B9F3664, 0xD1B1F617, 0x74F06469,
+	0x38513EC5, 0x9D10ACBB, 0x773E6CC8, 0xD27FFEB6, 0xA68F9ADF, 0x03CE08A1, 0xE9E0C8D2, 0x4CA15AAC,
+	0x70A27D8A, 0xD5E3EFF4, 0x3FCD2F87, 0x9A8CBDF9, 0xEE7CD990, 0x4B3D4BEE, 0xA1138B9D, 0x045219E3,
+	0x48F3434F, 0xEDB2D131, 0x079C1142, 0xA2DD833C, 0xD62DE755, 0x736C752B, 0x9942B558, 0x3C032726,
+	0xE144FB14, 0x4405696A, 0xAE2BA919, 0x0B6A3B67, 0x7F9A5F0E, 0xDADBCD70, 0x30F50D03, 0x95B49F7D,
+	0xD915C5D1, 0x7C5457AF, 0x967A97DC, 0x333B05A2, 0x47CB61CB, 0xE28AF3B5, 0x08A433C6, 0xADE5A1B8,
+	0x91E6869E, 0x34A714E0, 0xDE89D493, 0x7BC846ED, 0x0F382284, 0xAA79B0FA, 0x40577089, 0xE516E2F7,
+	0xA9B7B85B, 0x0CF62A25, 0xE6D8EA56, 0x43997828, 0x37691C41, 0x92288E3F, 0x78064E4C, 0xDD47DC32,
+	0xC76580D9, 0x622412A7, 0x880AD2D4, 0x2D4B40AA, 0x59BB24C3, 0xFCFAB6BD, 0x16D476CE, 0xB395E4B0,
+	0xFF34BE1C, 0x5A752C62, 0xB05BEC11, 0x151A7E6F, 0x61EA1A06, 0xC4AB8878, 0x2E85480B, 0x8BC4DA75,
+	0xB7C7FD53, 0x12866F2D, 0xF8A8AF5E, 0x5DE93D20, 0x29195949, 0x8C58CB37, 0x66760B44, 0xC337993A,
+	0x8F96C396, 0x2AD751E8, 0xC0F9919B, 0x65B803E5, 0x1148678C, 0xB409F5F2, 0x5E273581, 0xFB66A7FF,
+	0x26217BCD, 0x8360E9B3, 0x694E29C0, 0xCC0FBBBE, 0xB8FFDFD7, 0x1DBE4DA9, 0xF7908DDA, 0x52D11FA4,
+	0x1E704508, 0xBB31D776, 0x511F1705, 0xF45E857B, 0x80AEE112, 0x25EF736C, 0xCFC1B31F, 0x6A802161,
+	0x56830647, 0xF3C29439, 0x19EC544A, 0xBCADC634, 0xC85DA25D, 0x6D1C3023, 0x8732F050, 0x2273622E,
+	0x6ED23882, 0xCB93AAFC, 0x21BD6A8F, 0x84FCF8F1, 0xF00C9C98, 0x554D0EE6, 0xBF63CE95, 0x1A225CEB,
+	0x8B277743, 0x2E66E53D, 0xC448254E, 0x6109B730, 0x15F9D359, 0xB0B84127, 0x5A968154, 0xFFD7132A,
+	0xB3764986, 0x1637DBF8, 0xFC191B8B, 0x595889F5, 0x2DA8ED9C, 0x88E97FE2, 0x62C7BF91, 0xC7862DEF,
+	0xFB850AC9, 0x5EC498B7, 0xB4EA58C4, 0x11ABCABA, 0x655BAED3, 0xC01A3CAD, 0x2A34FCDE, 0x8F756EA0,
+	0xC3D4340C, 0x6695A672, 0x8CBB6601, 0x29FAF47F, 0x5D0A9016, 0xF84B0268, 0x1265C21B, 0xB7245065,
+	0x6A638C57, 0xCF221E29, 0x250CDE5A, 0x804D4C24, 0xF4BD284D, 0x51FCBA33, 0xBBD27A40, 0x1E93E83E,
+	0x5232B292, 0xF77320EC, 0x1D5DE09F, 0xB81C72E1, 0xCCEC1688, 0x69AD84F6, 0x83834485, 0x26C2D6FB,
+	0x1AC1F1DD, 0xBF8063A3, 0x55AEA3D0, 0xF0EF31AE, 0x841F55C7, 0x215EC7B9, 0xCB7007CA, 0x6E3195B4,
+	0x2290CF18, 0x87D15D66, 0x6DFF9D15, 0xC8BE0F6B, 0xBC4E6B02, 0x190FF97C, 0xF321390F, 0x5660AB71,
+	0x4C42F79A, 0xE90365E4, 0x032DA597, 0xA66C37E9, 0xD29C5380, 0x77DDC1FE, 0x9DF3018D, 0x38B293F3,
+	0x7413C95F, 0xD1525B21, 0x3B7C9B52, 0x9E3D092C, 0xEACD6D45, 0x4F8CFF3B, 0xA5A23F48, 0x00E3AD36,
+	0x3CE08A10, 0x99A1186E, 0x738FD81D, 0xD6CE4A63, 0xA23E2E0A, 0x077FBC74, 0xED517C07, 0x4810EE79,
+	0x04B1B4D5, 0xA1F026AB, 0x4BDEE6D8, 0xEE9F74A6, 0x9A6F10CF, 0x3F2E82B1, 0xD50042C2, 0x7041D0BC,
+	0xAD060C8E, 0x08479EF0, 0xE2695E83, 0x4728CCFD, 0x33D8A894, 0x96993AEA, 0x7CB7FA99, 0xD9F668E7,
+	0x9557324B, 0x3016A035, 0xDA386046, 0x7F79F238, 0x0B899651, 0xAEC8042F, 0x44E6C45C, 0xE1A75622,
+	0xDDA47104, 0x78E5E37A, 0x92CB2309, 0x378AB177, 0x437AD51E, 0xE63B4760, 0x0C158713, 0xA954156D,
+	0xE5F54FC1, 0x40B4DDBF, 0xAA9A1DCC, 0x0FDB8FB2, 0x7B2BEBDB, 0xDE6A79A5, 0x3444B9D6, 0x91052BA8
+};
+
+/*
+ * end of the CRC lookup table crc_tableil8_o48
+ */
+
+
+
+/*
+ * The following CRC lookup table was generated automagically using the
+ * following model parameters:
+ *
+ * Generator Polynomial = ................. 0x1EDC6F41
+ * Generator Polynomial Length = .......... 32 bits
+ * Reflected Bits = ....................... TRUE
+ * Table Generation Offset = .............. 32 bits
+ * Number of Slices = ..................... 8 slices
+ * Slice Lengths = ........................ 8 8 8 8 8 8 8 8
+ * Directory Name = ....................... .\
+ * File Name = ............................ 8x256_tables.c
+ */
+
+static const uint32_t sctp_crc_tableil8_o56[256] =
+{
+	0x00000000, 0xDD45AAB8, 0xBF672381, 0x62228939, 0x7B2231F3, 0xA6679B4B, 0xC4451272, 0x1900B8CA,
+	0xF64463E6, 0x2B01C95E, 0x49234067, 0x9466EADF, 0x8D665215, 0x5023F8AD, 0x32017194, 0xEF44DB2C,
+	0xE964B13D, 0x34211B85, 0x560392BC, 0x8B463804, 0x924680CE, 0x4F032A76, 0x2D21A34F, 0xF06409F7,
+	0x1F20D2DB, 0xC2657863, 0xA047F15A, 0x7D025BE2, 0x6402E328, 0xB9474990, 0xDB65C0A9, 0x06206A11,
+	0xD725148B, 0x0A60BE33, 0x6842370A, 0xB5079DB2, 0xAC072578, 0x71428FC0, 0x136006F9, 0xCE25AC41,
+	0x2161776D, 0xFC24DDD5, 0x9E0654EC, 0x4343FE54, 0x5A43469E, 0x8706EC26, 0xE524651F, 0x3861CFA7,
+	0x3E41A5B6, 0xE3040F0E, 0x81268637, 0x5C632C8F, 0x45639445, 0x98263EFD, 0xFA04B7C4, 0x27411D7C,
+	0xC805C650, 0x15406CE8, 0x7762E5D1, 0xAA274F69, 0xB327F7A3, 0x6E625D1B, 0x0C40D422, 0xD1057E9A,
+	0xABA65FE7, 0x76E3F55F, 0x14C17C66, 0xC984D6DE, 0xD0846E14, 0x0DC1C4AC, 0x6FE34D95, 0xB2A6E72D,
+	0x5DE23C01, 0x80A796B9, 0xE2851F80, 0x3FC0B538, 0x26C00DF2, 0xFB85A74A, 0x99A72E73, 0x44E284CB,
+	0x42C2EEDA, 0x9F874462, 0xFDA5CD5B, 0x20E067E3, 0x39E0DF29, 0xE4A57591, 0x8687FCA8, 0x5BC25610,
+	0xB4868D3C, 0x69C32784, 0x0BE1AEBD, 0xD6A40405, 0xCFA4BCCF, 0x12E11677, 0x70C39F4E, 0xAD8635F6,
+	0x7C834B6C, 0xA1C6E1D4, 0xC3E468ED, 0x1EA1C255, 0x07A17A9F, 0xDAE4D027, 0xB8C6591E, 0x6583F3A6,
+	0x8AC7288A, 0x57828232, 0x35A00B0B, 0xE8E5A1B3, 0xF1E51979, 0x2CA0B3C1, 0x4E823AF8, 0x93C79040,
+	0x95E7FA51, 0x48A250E9, 0x2A80D9D0, 0xF7C57368, 0xEEC5CBA2, 0x3380611A, 0x51A2E823, 0x8CE7429B,
+	0x63A399B7, 0xBEE6330F, 0xDCC4BA36, 0x0181108E, 0x1881A844, 0xC5C402FC, 0xA7E68BC5, 0x7AA3217D,
+	0x52A0C93F, 0x8FE56387, 0xEDC7EABE, 0x30824006, 0x2982F8CC, 0xF4C75274, 0x96E5DB4D, 0x4BA071F5,
+	0xA4E4AAD9, 0x79A10061, 0x1B838958, 0xC6C623E0, 0xDFC69B2A, 0x02833192, 0x60A1B8AB, 0xBDE41213,
+	0xBBC47802, 0x6681D2BA, 0x04A35B83, 0xD9E6F13B, 0xC0E649F1, 0x1DA3E349, 0x7F816A70, 0xA2C4C0C8,
+	0x4D801BE4, 0x90C5B15C, 0xF2E73865, 0x2FA292DD, 0x36A22A17, 0xEBE780AF, 0x89C50996, 0x5480A32E,
+	0x8585DDB4, 0x58C0770C, 0x3AE2FE35, 0xE7A7548D, 0xFEA7EC47, 0x23E246FF, 0x41C0CFC6, 0x9C85657E,
+	0x73C1BE52, 0xAE8414EA, 0xCCA69DD3, 0x11E3376B, 0x08E38FA1, 0xD5A62519, 0xB784AC20, 0x6AC10698,
+	0x6CE16C89, 0xB1A4C631, 0xD3864F08, 0x0EC3E5B0, 0x17C35D7A, 0xCA86F7C2, 0xA8A47EFB, 0x75E1D443,
+	0x9AA50F6F, 0x47E0A5D7, 0x25C22CEE, 0xF8878656, 0xE1873E9C, 0x3CC29424, 0x5EE01D1D, 0x83A5B7A5,
+	0xF90696D8, 0x24433C60, 0x4661B559, 0x9B241FE1, 0x8224A72B, 0x5F610D93, 0x3D4384AA, 0xE0062E12,
+	0x0F42F53E, 0xD2075F86, 0xB025D6BF, 0x6D607C07, 0x7460C4CD, 0xA9256E75, 0xCB07E74C, 0x16424DF4,
+	0x106227E5, 0xCD278D5D, 0xAF050464, 0x7240AEDC, 0x6B401616, 0xB605BCAE, 0xD4273597, 0x09629F2F,
+	0xE6264403, 0x3B63EEBB, 0x59416782, 0x8404CD3A, 0x9D0475F0, 0x4041DF48, 0x22635671, 0xFF26FCC9,
+	0x2E238253, 0xF36628EB, 0x9144A1D2, 0x4C010B6A, 0x5501B3A0, 0x88441918, 0xEA669021, 0x37233A99,
+	0xD867E1B5, 0x05224B0D, 0x6700C234, 0xBA45688C, 0xA345D046, 0x7E007AFE, 0x1C22F3C7, 0xC167597F,
+	0xC747336E, 0x1A0299D6, 0x782010EF, 0xA565BA57, 0xBC65029D, 0x6120A825, 0x0302211C, 0xDE478BA4,
+	0x31035088, 0xEC46FA30, 0x8E647309, 0x5321D9B1, 0x4A21617B, 0x9764CBC3, 0xF54642FA, 0x2803E842
+};
+
+/*
+ * end of the CRC lookup table crc_tableil8_o56
+ */
+
+
+
+/*
+ * The following CRC lookup table was generated automagically using the
+ * following model parameters:
+ *
+ * Generator Polynomial = ................. 0x1EDC6F41
+ * Generator Polynomial Length = .......... 32 bits
+ * Reflected Bits = ....................... TRUE
+ * Table Generation Offset = .............. 32 bits
+ * Number of Slices = ..................... 8 slices
+ * Slice Lengths = ........................ 8 8 8 8 8 8 8 8
+ * Directory Name = ....................... .\
+ * File Name = ............................ 8x256_tables.c
+ */
+
+static const uint32_t sctp_crc_tableil8_o64[256] =
+{
+	0x00000000, 0x38116FAC, 0x7022DF58, 0x4833B0F4, 0xE045BEB0, 0xD854D11C, 0x906761E8, 0xA8760E44,
+	0xC5670B91, 0xFD76643D, 0xB545D4C9, 0x8D54BB65, 0x2522B521, 0x1D33DA8D, 0x55006A79, 0x6D1105D5,
+	0x8F2261D3, 0xB7330E7F, 0xFF00BE8B, 0xC711D127, 0x6F67DF63, 0x5776B0CF, 0x1F45003B, 0x27546F97,
+	0x4A456A42, 0x725405EE, 0x3A67B51A, 0x0276DAB6, 0xAA00D4F2, 0x9211BB5E, 0xDA220BAA, 0xE2336406,
+	0x1BA8B557, 0x23B9DAFB, 0x6B8A6A0F, 0x539B05A3, 0xFBED0BE7, 0xC3FC644B, 0x8BCFD4BF, 0xB3DEBB13,
+	0xDECFBEC6, 0xE6DED16A, 0xAEED619E, 0x96FC0E32, 0x3E8A0076, 0x069B6FDA, 0x4EA8DF2E, 0x76B9B082,
+	0x948AD484, 0xAC9BBB28, 0xE4A80BDC, 0xDCB96470, 0x74CF6A34, 0x4CDE0598, 0x04EDB56C, 0x3CFCDAC0,
+	0x51EDDF15, 0x69FCB0B9, 0x21CF004D, 0x19DE6FE1, 0xB1A861A5, 0x89B90E09, 0xC18ABEFD, 0xF99BD151,
+	0x37516AAE, 0x0F400502, 0x4773B5F6, 0x7F62DA5A, 0xD714D41E, 0xEF05BBB2, 0xA7360B46, 0x9F2764EA,
+	0xF236613F, 0xCA270E93, 0x8214BE67, 0xBA05D1CB, 0x1273DF8F, 0x2A62B023, 0x625100D7, 0x5A406F7B,
+	0xB8730B7D, 0x806264D1, 0xC851D425, 0xF040BB89, 0x5836B5CD, 0x6027DA61, 0x28146A95, 0x10050539,
+	0x7D1400EC, 0x45056F40, 0x0D36DFB4, 0x3527B018, 0x9D51BE5C, 0xA540D1F0, 0xED736104, 0xD5620EA8,
+	0x2CF9DFF9, 0x14E8B055, 0x5CDB00A1, 0x64CA6F0D, 0xCCBC6149, 0xF4AD0EE5, 0xBC9EBE11, 0x848FD1BD,
+	0xE99ED468, 0xD18FBBC4, 0x99BC0B30, 0xA1AD649C, 0x09DB6AD8, 0x31CA0574, 0x79F9B580, 0x41E8DA2C,
+	0xA3DBBE2A, 0x9BCAD186, 0xD3F96172, 0xEBE80EDE, 0x439E009A, 0x7B8F6F36, 0x33BCDFC2, 0x0BADB06E,
+	0x66BCB5BB, 0x5EADDA17, 0x169E6AE3, 0x2E8F054F, 0x86F90B0B, 0xBEE864A7, 0xF6DBD453, 0xCECABBFF,
+	0x6EA2D55C, 0x56B3BAF0, 0x1E800A04, 0x269165A8, 0x8EE76BEC, 0xB6F60440, 0xFEC5B4B4, 0xC6D4DB18,
+	0xABC5DECD, 0x93D4B161, 0xDBE70195, 0xE3F66E39, 0x4B80607D, 0x73910FD1, 0x3BA2BF25, 0x03B3D089,
+	0xE180B48F, 0xD991DB23, 0x91A26BD7, 0xA9B3047B, 0x01C50A3F, 0x39D46593, 0x71E7D567, 0x49F6BACB,
+	0x24E7BF1E, 0x1CF6D0B2, 0x54C56046, 0x6CD40FEA, 0xC4A201AE, 0xFCB36E02, 0xB480DEF6, 0x8C91B15A,
+	0x750A600B, 0x4D1B0FA7, 0x0528BF53, 0x3D39D0FF, 0x954FDEBB, 0xAD5EB117, 0xE56D01E3, 0xDD7C6E4F,
+	0xB06D6B9A, 0x887C0436, 0xC04FB4C2, 0xF85EDB6E, 0x5028D52A, 0x6839BA86, 0x200A0A72, 0x181B65DE,
+	0xFA2801D8, 0xC2396E74, 0x8A0ADE80, 0xB21BB12C, 0x1A6DBF68, 0x227CD0C4, 0x6A4F6030, 0x525E0F9C,
+	0x3F4F0A49, 0x075E65E5, 0x4F6DD511, 0x777CBABD, 0xDF0AB4F9, 0xE71BDB55, 0xAF286BA1, 0x9739040D,
+	0x59F3BFF2, 0x61E2D05E, 0x29D160AA, 0x11C00F06, 0xB9B60142, 0x81A76EEE, 0xC994DE1A, 0xF185B1B6,
+	0x9C94B463, 0xA485DBCF, 0xECB66B3B, 0xD4A70497, 0x7CD10AD3, 0x44C0657F, 0x0CF3D58B, 0x34E2BA27,
+	0xD6D1DE21, 0xEEC0B18D, 0xA6F30179, 0x9EE26ED5, 0x36946091, 0x0E850F3D, 0x46B6BFC9, 0x7EA7D065,
+	0x13B6D5B0, 0x2BA7BA1C, 0x63940AE8, 0x5B856544, 0xF3F36B00, 0xCBE204AC, 0x83D1B458, 0xBBC0DBF4,
+	0x425B0AA5, 0x7A4A6509, 0x3279D5FD, 0x0A68BA51, 0xA21EB415, 0x9A0FDBB9, 0xD23C6B4D, 0xEA2D04E1,
+	0x873C0134, 0xBF2D6E98, 0xF71EDE6C, 0xCF0FB1C0, 0x6779BF84, 0x5F68D028, 0x175B60DC, 0x2F4A0F70,
+	0xCD796B76, 0xF56804DA, 0xBD5BB42E, 0x854ADB82, 0x2D3CD5C6, 0x152DBA6A, 0x5D1E0A9E, 0x650F6532,
+	0x081E60E7, 0x300F0F4B, 0x783CBFBF, 0x402DD013, 0xE85BDE57, 0xD04AB1FB, 0x9879010F, 0xA0686EA3
+};
+
+/*
+ * end of the CRC lookup table crc_tableil8_o64
+ */
+
+
+
+/*
+ * The following CRC lookup table was generated automagically using the
+ * following model parameters:
+ *
+ * Generator Polynomial = ................. 0x1EDC6F41
+ * Generator Polynomial Length = .......... 32 bits
+ * Reflected Bits = ....................... TRUE
+ * Table Generation Offset = .............. 32 bits
+ * Number of Slices = ..................... 8 slices
+ * Slice Lengths = ........................ 8 8 8 8 8 8 8 8
+ * Directory Name = ....................... .\
+ * File Name = ............................ 8x256_tables.c
+ */
+
+static const uint32_t sctp_crc_tableil8_o72[256] =
+{
+	0x00000000, 0xEF306B19, 0xDB8CA0C3, 0x34BCCBDA, 0xB2F53777, 0x5DC55C6E, 0x697997B4, 0x8649FCAD,
+	0x6006181F, 0x8F367306, 0xBB8AB8DC, 0x54BAD3C5, 0xD2F32F68, 0x3DC34471, 0x097F8FAB, 0xE64FE4B2,
+	0xC00C303E, 0x2F3C5B27, 0x1B8090FD, 0xF4B0FBE4, 0x72F90749, 0x9DC96C50, 0xA975A78A, 0x4645CC93,
+	0xA00A2821, 0x4F3A4338, 0x7B8688E2, 0x94B6E3FB, 0x12FF1F56, 0xFDCF744F, 0xC973BF95, 0x2643D48C,
+	0x85F4168D, 0x6AC47D94, 0x5E78B64E, 0xB148DD57, 0x370121FA, 0xD8314AE3, 0xEC8D8139, 0x03BDEA20,
+	0xE5F20E92, 0x0AC2658B, 0x3E7EAE51, 0xD14EC548, 0x570739E5, 0xB83752FC, 0x8C8B9926, 0x63BBF23F,
+	0x45F826B3, 0xAAC84DAA, 0x9E748670, 0x7144ED69, 0xF70D11C4, 0x183D7ADD, 0x2C81B107, 0xC3B1DA1E,
+	0x25FE3EAC, 0xCACE55B5, 0xFE729E6F, 0x1142F576, 0x970B09DB, 0x783B62C2, 0x4C87A918, 0xA3B7C201,
+	0x0E045BEB, 0xE13430F2, 0xD588FB28, 0x3AB89031, 0xBCF16C9C, 0x53C10785, 0x677DCC5F, 0x884DA746,
+	0x6E0243F4, 0x813228ED, 0xB58EE337, 0x5ABE882E, 0xDCF77483, 0x33C71F9A, 0x077BD440, 0xE84BBF59,
+	0xCE086BD5, 0x213800CC, 0x1584CB16, 0xFAB4A00F, 0x7CFD5CA2, 0x93CD37BB, 0xA771FC61, 0x48419778,
+	0xAE0E73CA, 0x413E18D3, 0x7582D309, 0x9AB2B810, 0x1CFB44BD, 0xF3CB2FA4, 0xC777E47E, 0x28478F67,
+	0x8BF04D66, 0x64C0267F, 0x507CEDA5, 0xBF4C86BC, 0x39057A11, 0xD6351108, 0xE289DAD2, 0x0DB9B1CB,
+	0xEBF65579, 0x04C63E60, 0x307AF5BA, 0xDF4A9EA3, 0x5903620E, 0xB6330917, 0x828FC2CD, 0x6DBFA9D4,
+	0x4BFC7D58, 0xA4CC1641, 0x9070DD9B, 0x7F40B682, 0xF9094A2F, 0x16392136, 0x2285EAEC, 0xCDB581F5,
+	0x2BFA6547, 0xC4CA0E5E, 0xF076C584, 0x1F46AE9D, 0x990F5230, 0x763F3929, 0x4283F2F3, 0xADB399EA,
+	0x1C08B7D6, 0xF338DCCF, 0xC7841715, 0x28B47C0C, 0xAEFD80A1, 0x41CDEBB8, 0x75712062, 0x9A414B7B,
+	0x7C0EAFC9, 0x933EC4D0, 0xA7820F0A, 0x48B26413, 0xCEFB98BE, 0x21CBF3A7, 0x1577387D, 0xFA475364,
+	0xDC0487E8, 0x3334ECF1, 0x0788272B, 0xE8B84C32, 0x6EF1B09F, 0x81C1DB86, 0xB57D105C, 0x5A4D7B45,
+	0xBC029FF7, 0x5332F4EE, 0x678E3F34, 0x88BE542D, 0x0EF7A880, 0xE1C7C399, 0xD57B0843, 0x3A4B635A,
+	0x99FCA15B, 0x76CCCA42, 0x42700198, 0xAD406A81, 0x2B09962C, 0xC439FD35, 0xF08536EF, 0x1FB55DF6,
+	0xF9FAB944, 0x16CAD25D, 0x22761987, 0xCD46729E, 0x4B0F8E33, 0xA43FE52A, 0x90832EF0, 0x7FB345E9,
+	0x59F09165, 0xB6C0FA7C, 0x827C31A6, 0x6D4C5ABF, 0xEB05A612, 0x0435CD0B, 0x308906D1, 0xDFB96DC8,
+	0x39F6897A, 0xD6C6E263, 0xE27A29B9, 0x0D4A42A0, 0x8B03BE0D, 0x6433D514, 0x508F1ECE, 0xBFBF75D7,
+	0x120CEC3D, 0xFD3C8724, 0xC9804CFE, 0x26B027E7, 0xA0F9DB4A, 0x4FC9B053, 0x7B757B89, 0x94451090,
+	0x720AF422, 0x9D3A9F3B, 0xA98654E1, 0x46B63FF8, 0xC0FFC355, 0x2FCFA84C, 0x1B736396, 0xF443088F,
+	0xD200DC03, 0x3D30B71A, 0x098C7CC0, 0xE6BC17D9, 0x60F5EB74, 0x8FC5806D, 0xBB794BB7, 0x544920AE,
+	0xB206C41C, 0x5D36AF05, 0x698A64DF, 0x86BA0FC6, 0x00F3F36B, 0xEFC39872, 0xDB7F53A8, 0x344F38B1,
+	0x97F8FAB0, 0x78C891A9, 0x4C745A73, 0xA344316A, 0x250DCDC7, 0xCA3DA6DE, 0xFE816D04, 0x11B1061D,
+	0xF7FEE2AF, 0x18CE89B6, 0x2C72426C, 0xC3422975, 0x450BD5D8, 0xAA3BBEC1, 0x9E87751B, 0x71B71E02,
+	0x57F4CA8E, 0xB8C4A197, 0x8C786A4D, 0x63480154, 0xE501FDF9, 0x0A3196E0, 0x3E8D5D3A, 0xD1BD3623,
+	0x37F2D291, 0xD8C2B988, 0xEC7E7252, 0x034E194B, 0x8507E5E6, 0x6A378EFF, 0x5E8B4525, 0xB1BB2E3C
+};
+
+/*
+ * end of the CRC lookup table crc_tableil8_o72
+ */
+
+
+
+/*
+ * The following CRC lookup table was generated automagically using the
+ * following model parameters:
+ *
+ * Generator Polynomial = ................. 0x1EDC6F41
+ * Generator Polynomial Length = .......... 32 bits
+ * Reflected Bits = ....................... TRUE
+ * Table Generation Offset = .............. 32 bits
+ * Number of Slices = ..................... 8 slices
+ * Slice Lengths = ........................ 8 8 8 8 8 8 8 8
+ * Directory Name = ....................... .\
+ * File Name = ............................ 8x256_tables.c
+ */
+
+static const uint32_t sctp_crc_tableil8_o80[256] =
+{
+	0x00000000, 0x68032CC8, 0xD0065990, 0xB8057558, 0xA5E0C5D1, 0xCDE3E919, 0x75E69C41, 0x1DE5B089,
+	0x4E2DFD53, 0x262ED19B, 0x9E2BA4C3, 0xF628880B, 0xEBCD3882, 0x83CE144A, 0x3BCB6112, 0x53C84DDA,
+	0x9C5BFAA6, 0xF458D66E, 0x4C5DA336, 0x245E8FFE, 0x39BB3F77, 0x51B813BF, 0xE9BD66E7, 0x81BE4A2F,
+	0xD27607F5, 0xBA752B3D, 0x02705E65, 0x6A7372AD, 0x7796C224, 0x1F95EEEC, 0xA7909BB4, 0xCF93B77C,
+	0x3D5B83BD, 0x5558AF75, 0xED5DDA2D, 0x855EF6E5, 0x98BB466C, 0xF0B86AA4, 0x48BD1FFC, 0x20BE3334,
+	0x73767EEE, 0x1B755226, 0xA370277E, 0xCB730BB6, 0xD696BB3F, 0xBE9597F7, 0x0690E2AF, 0x6E93CE67,
+	0xA100791B, 0xC90355D3, 0x7106208B, 0x19050C43, 0x04E0BCCA, 0x6CE39002, 0xD4E6E55A, 0xBCE5C992,
+	0xEF2D8448, 0x872EA880, 0x3F2BDDD8, 0x5728F110, 0x4ACD4199, 0x22CE6D51, 0x9ACB1809, 0xF2C834C1,
+	0x7AB7077A, 0x12B42BB2, 0xAAB15EEA, 0xC2B27222, 0xDF57C2AB, 0xB754EE63, 0x0F519B3B, 0x6752B7F3,
+	0x349AFA29, 0x5C99D6E1, 0xE49CA3B9, 0x8C9F8F71, 0x917A3FF8, 0xF9791330, 0x417C6668, 0x297F4AA0,
+	0xE6ECFDDC, 0x8EEFD114, 0x36EAA44C, 0x5EE98884, 0x430C380D, 0x2B0F14C5, 0x930A619D, 0xFB094D55,
+	0xA8C1008F, 0xC0C22C47, 0x78C7591F, 0x10C475D7, 0x0D21C55E, 0x6522E996, 0xDD279CCE, 0xB524B006,
+	0x47EC84C7, 0x2FEFA80F, 0x97EADD57, 0xFFE9F19F, 0xE20C4116, 0x8A0F6DDE, 0x320A1886, 0x5A09344E,
+	0x09C17994, 0x61C2555C, 0xD9C72004, 0xB1C40CCC, 0xAC21BC45, 0xC422908D, 0x7C27E5D5, 0x1424C91D,
+	0xDBB77E61, 0xB3B452A9, 0x0BB127F1, 0x63B20B39, 0x7E57BBB0, 0x16549778, 0xAE51E220, 0xC652CEE8,
+	0x959A8332, 0xFD99AFFA, 0x459CDAA2, 0x2D9FF66A, 0x307A46E3, 0x58796A2B, 0xE07C1F73, 0x887F33BB,
+	0xF56E0EF4, 0x9D6D223C, 0x25685764, 0x4D6B7BAC, 0x508ECB25, 0x388DE7ED, 0x808892B5, 0xE88BBE7D,
+	0xBB43F3A7, 0xD340DF6F, 0x6B45AA37, 0x034686FF, 0x1EA33676, 0x76A01ABE, 0xCEA56FE6, 0xA6A6432E,
+	0x6935F452, 0x0136D89A, 0xB933ADC2, 0xD130810A, 0xCCD53183, 0xA4D61D4B, 0x1CD36813, 0x74D044DB,
+	0x27180901, 0x4F1B25C9, 0xF71E5091, 0x9F1D7C59, 0x82F8CCD0, 0xEAFBE018, 0x52FE9540, 0x3AFDB988,
+	0xC8358D49, 0xA036A181, 0x1833D4D9, 0x7030F811, 0x6DD54898, 0x05D66450, 0xBDD31108, 0xD5D03DC0,
+	0x8618701A, 0xEE1B5CD2, 0x561E298A, 0x3E1D0542, 0x23F8B5CB, 0x4BFB9903, 0xF3FEEC5B, 0x9BFDC093,
+	0x546E77EF, 0x3C6D5B27, 0x84682E7F, 0xEC6B02B7, 0xF18EB23E, 0x998D9EF6, 0x2188EBAE, 0x498BC766,
+	0x1A438ABC, 0x7240A674, 0xCA45D32C, 0xA246FFE4, 0xBFA34F6D, 0xD7A063A5, 0x6FA516FD, 0x07A63A35,
+	0x8FD9098E, 0xE7DA2546, 0x5FDF501E, 0x37DC7CD6, 0x2A39CC5F, 0x423AE097, 0xFA3F95CF, 0x923CB907,
+	0xC1F4F4DD, 0xA9F7D815, 0x11F2AD4D, 0x79F18185, 0x6414310C, 0x0C171DC4, 0xB412689C, 0xDC114454,
+	0x1382F328, 0x7B81DFE0, 0xC384AAB8, 0xAB878670, 0xB66236F9, 0xDE611A31, 0x66646F69, 0x0E6743A1,
+	0x5DAF0E7B, 0x35AC22B3, 0x8DA957EB, 0xE5AA7B23, 0xF84FCBAA, 0x904CE762, 0x2849923A, 0x404ABEF2,
+	0xB2828A33, 0xDA81A6FB, 0x6284D3A3, 0x0A87FF6B, 0x17624FE2, 0x7F61632A, 0xC7641672, 0xAF673ABA,
+	0xFCAF7760, 0x94AC5BA8, 0x2CA92EF0, 0x44AA0238, 0x594FB2B1, 0x314C9E79, 0x8949EB21, 0xE14AC7E9,
+	0x2ED97095, 0x46DA5C5D, 0xFEDF2905, 0x96DC05CD, 0x8B39B544, 0xE33A998C, 0x5B3FECD4, 0x333CC01C,
+	0x60F48DC6, 0x08F7A10E, 0xB0F2D456, 0xD8F1F89E, 0xC5144817, 0xAD1764DF, 0x15121187, 0x7D113D4F
+};
+
+/*
+ * end of the CRC lookup table crc_tableil8_o80
+ */
+
+
+
+/*
+ * The following CRC lookup table was generated automagically using the
+ * following model parameters:
+ *
+ * Generator Polynomial = ................. 0x1EDC6F41
+ * Generator Polynomial Length = .......... 32 bits
+ * Reflected Bits = ....................... TRUE
+ * Table Generation Offset = .............. 32 bits
+ * Number of Slices = ..................... 8 slices
+ * Slice Lengths = ........................ 8 8 8 8 8 8 8 8
+ * Directory Name = ....................... .\
+ * File Name = ............................ 8x256_tables.c
+ */
+
+static const uint32_t sctp_crc_tableil8_o88[256] =
+{
+	0x00000000, 0x493C7D27, 0x9278FA4E, 0xDB448769, 0x211D826D, 0x6821FF4A, 0xB3657823, 0xFA590504,
+	0x423B04DA, 0x0B0779FD, 0xD043FE94, 0x997F83B3, 0x632686B7, 0x2A1AFB90, 0xF15E7CF9, 0xB86201DE,
+	0x847609B4, 0xCD4A7493, 0x160EF3FA, 0x5F328EDD, 0xA56B8BD9, 0xEC57F6FE, 0x37137197, 0x7E2F0CB0,
+	0xC64D0D6E, 0x8F717049, 0x5435F720, 0x1D098A07, 0xE7508F03, 0xAE6CF224, 0x7528754D, 0x3C14086A,
+	0x0D006599, 0x443C18BE, 0x9F789FD7, 0xD644E2F0, 0x2C1DE7F4, 0x65219AD3, 0xBE651DBA, 0xF759609D,
+	0x4F3B6143, 0x06071C64, 0xDD439B0D, 0x947FE62A, 0x6E26E32E, 0x271A9E09, 0xFC5E1960, 0xB5626447,
+	0x89766C2D, 0xC04A110A, 0x1B0E9663, 0x5232EB44, 0xA86BEE40, 0xE1579367, 0x3A13140E, 0x732F6929,
+	0xCB4D68F7, 0x827115D0, 0x593592B9, 0x1009EF9E, 0xEA50EA9A, 0xA36C97BD, 0x782810D4, 0x31146DF3,
+	0x1A00CB32, 0x533CB615, 0x8878317C, 0xC1444C5B, 0x3B1D495F, 0x72213478, 0xA965B311, 0xE059CE36,
+	0x583BCFE8, 0x1107B2CF, 0xCA4335A6, 0x837F4881, 0x79264D85, 0x301A30A2, 0xEB5EB7CB, 0xA262CAEC,
+	0x9E76C286, 0xD74ABFA1, 0x0C0E38C8, 0x453245EF, 0xBF6B40EB, 0xF6573DCC, 0x2D13BAA5, 0x642FC782,
+	0xDC4DC65C, 0x9571BB7B, 0x4E353C12, 0x07094135, 0xFD504431, 0xB46C3916, 0x6F28BE7F, 0x2614C358,
+	0x1700AEAB, 0x5E3CD38C, 0x857854E5, 0xCC4429C2, 0x361D2CC6, 0x7F2151E1, 0xA465D688, 0xED59ABAF,
+	0x553BAA71, 0x1C07D756, 0xC743503F, 0x8E7F2D18, 0x7426281C, 0x3D1A553B, 0xE65ED252, 0xAF62AF75,
+	0x9376A71F, 0xDA4ADA38, 0x010E5D51, 0x48322076, 0xB26B2572, 0xFB575855, 0x2013DF3C, 0x692FA21B,
+	0xD14DA3C5, 0x9871DEE2, 0x4335598B, 0x0A0924AC, 0xF05021A8, 0xB96C5C8F, 0x6228DBE6, 0x2B14A6C1,
+	0x34019664, 0x7D3DEB43, 0xA6796C2A, 0xEF45110D, 0x151C1409, 0x5C20692E, 0x8764EE47, 0xCE589360,
+	0x763A92BE, 0x3F06EF99, 0xE44268F0, 0xAD7E15D7, 0x572710D3, 0x1E1B6DF4, 0xC55FEA9D, 0x8C6397BA,
+	0xB0779FD0, 0xF94BE2F7, 0x220F659E, 0x6B3318B9, 0x916A1DBD, 0xD856609A, 0x0312E7F3, 0x4A2E9AD4,
+	0xF24C9B0A, 0xBB70E62D, 0x60346144, 0x29081C63, 0xD3511967, 0x9A6D6440, 0x4129E329, 0x08159E0E,
+	0x3901F3FD, 0x703D8EDA, 0xAB7909B3, 0xE2457494, 0x181C7190, 0x51200CB7, 0x8A648BDE, 0xC358F6F9,
+	0x7B3AF727, 0x32068A00, 0xE9420D69, 0xA07E704E, 0x5A27754A, 0x131B086D, 0xC85F8F04, 0x8163F223,
+	0xBD77FA49, 0xF44B876E, 0x2F0F0007, 0x66337D20, 0x9C6A7824, 0xD5560503, 0x0E12826A, 0x472EFF4D,
+	0xFF4CFE93, 0xB67083B4, 0x6D3404DD, 0x240879FA, 0xDE517CFE, 0x976D01D9, 0x4C2986B0, 0x0515FB97,
+	0x2E015D56, 0x673D2071, 0xBC79A718, 0xF545DA3F, 0x0F1CDF3B, 0x4620A21C, 0x9D642575, 0xD4585852,
+	0x6C3A598C, 0x250624AB, 0xFE42A3C2, 0xB77EDEE5, 0x4D27DBE1, 0x041BA6C6, 0xDF5F21AF, 0x96635C88,
+	0xAA7754E2, 0xE34B29C5, 0x380FAEAC, 0x7133D38B, 0x8B6AD68F, 0xC256ABA8, 0x19122CC1, 0x502E51E6,
+	0xE84C5038, 0xA1702D1F, 0x7A34AA76, 0x3308D751, 0xC951D255, 0x806DAF72, 0x5B29281B, 0x1215553C,
+	0x230138CF, 0x6A3D45E8, 0xB179C281, 0xF845BFA6, 0x021CBAA2, 0x4B20C785, 0x906440EC, 0xD9583DCB,
+	0x613A3C15, 0x28064132, 0xF342C65B, 0xBA7EBB7C, 0x4027BE78, 0x091BC35F, 0xD25F4436, 0x9B633911,
+	0xA777317B, 0xEE4B4C5C, 0x350FCB35, 0x7C33B612, 0x866AB316, 0xCF56CE31, 0x14124958, 0x5D2E347F,
+	0xE54C35A1, 0xAC704886, 0x7734CFEF, 0x3E08B2C8, 0xC451B7CC, 0x8D6DCAEB, 0x56294D82, 0x1F1530A5
+};
+
+/*
+ * end of the CRC lookup table crc_tableil8_o88
+ */
+
+
+static uint32_t
+crc32c_sb8_64_bit(uint32_t crc,
+    const unsigned char *p_buf,
+    uint32_t length,
+    uint32_t init_bytes)
+{
+	uint32_t li;
+	uint32_t term1, term2;
+	uint32_t running_length;
+	uint32_t end_bytes;
+
+	running_length = rounddown(length - init_bytes, 8);
+	end_bytes = length - init_bytes - running_length;
+
+	for (li = 0; li < init_bytes; li++)
+		crc = sctp_crc_tableil8_o32[(crc ^ *p_buf++) & 0x000000FF] ^
+		    (crc >> 8);
+	for (li = 0; li < running_length / 8; li++) {
+#if BYTE_ORDER == BIG_ENDIAN
+		crc ^= *p_buf++;
+		crc ^= (*p_buf++) << 8;
+		crc ^= (*p_buf++) << 16;
+		crc ^= (*p_buf++) << 24;
+#else
+		crc ^= *(const uint32_t *) p_buf;
+		p_buf += 4;
+#endif
+		term1 = sctp_crc_tableil8_o88[crc & 0x000000FF] ^
+		    sctp_crc_tableil8_o80[(crc >> 8) & 0x000000FF];
+		term2 = crc >> 16;
+		crc = term1 ^
+		    sctp_crc_tableil8_o72[term2 & 0x000000FF] ^
+		    sctp_crc_tableil8_o64[(term2 >> 8) & 0x000000FF];
+
+#if BYTE_ORDER == BIG_ENDIAN
+		crc ^= sctp_crc_tableil8_o56[*p_buf++];
+		crc ^= sctp_crc_tableil8_o48[*p_buf++];
+		crc ^= sctp_crc_tableil8_o40[*p_buf++];
+		crc ^= sctp_crc_tableil8_o32[*p_buf++];
+#else
+		term1 = sctp_crc_tableil8_o56[(*(const uint32_t *) p_buf) & 0x000000FF] ^
+		    sctp_crc_tableil8_o48[((*(const uint32_t *) p_buf) >> 8) & 0x000000FF];
+
+		term2 = (*(const uint32_t *) p_buf) >> 16;
+		crc = crc ^
+		    term1 ^
+		    sctp_crc_tableil8_o40[term2 & 0x000000FF] ^
+		    sctp_crc_tableil8_o32[(term2 >> 8) & 0x000000FF];
+		p_buf += 4;
+#endif
+	}
+	for (li = 0; li < end_bytes; li++)
+		crc = sctp_crc_tableil8_o32[(crc ^ *p_buf++) & 0x000000FF] ^
+		    (crc >> 8);
+	return crc;
+}
+
+static uint32_t
+multitable_crc32c(uint32_t crc32c,
+    const unsigned char *buffer,
+    unsigned int length)
+{
+	uint32_t to_even_word;
+
+	if (length == 0) {
+		return (crc32c);
+	}
+	to_even_word = (4 - (((uintptr_t) buffer) & 0x3));
+	return (crc32c_sb8_64_bit(crc32c, buffer, length, to_even_word));
+}
+
+uint32_t
+calculate_crc32c(uint32_t crc32c,
+    const unsigned char *buffer,
+    unsigned int length)
+{
+	if (length < 4) {
+		return (singletable_crc32c(crc32c, buffer, length));
+	} else {
+		return (multitable_crc32c(crc32c, buffer, length));
+	}
+}
+
diff --git a/src/add-ons/kernel/file_systems/ext2/ext2.h b/src/add-ons/kernel/file_systems/ext2/ext2.h
index 8b4da0c5c2..41b03c5fea 100644
--- a/src/add-ons/kernel/file_systems/ext2/ext2.h
+++ b/src/add-ons/kernel/file_systems/ext2/ext2.h
@@ -85,9 +85,13 @@ struct ext2_super_block {
 	uint64	mmp_block;
 	uint32	raid_stripe_width;
 	uint8	groups_per_flex_shift;
-	uint8	_reserved3;
+	uint8	checksum_type;
 	uint16	_reserved4;
-	uint32	_reserved5[162];
+	uint64	kb_written;
+	uint32	_reserved5[60];
+	uint32	checksum_seed;
+	uint32	_reserved6[98];
+	uint32	checksum;
 
 	uint16 Magic() const { return B_LENDIAN_TO_HOST_INT16(magic); }
 	uint16 State() const { return B_LENDIAN_TO_HOST_INT16(state); }
@@ -109,11 +113,20 @@ struct ext2_super_block {
 			blocks |= ((uint64)B_LENDIAN_TO_HOST_INT32(free_blocks_high) << 32);
 		return blocks;
 	}
+	uint64 ReservedBlocks(bool has64bits) const
+	{
+		uint64 blocks = B_LENDIAN_TO_HOST_INT32(reserved_blocks);
+		if (has64bits)
+			blocks |= ((uint64)B_LENDIAN_TO_HOST_INT32(reserved_blocks_high) << 32);
+		return blocks;
+	}
 	uint16 InodeSize() const { return B_LENDIAN_TO_HOST_INT16(inode_size); }
 	uint32 FirstDataBlock() const
 		{ return B_LENDIAN_TO_HOST_INT32(first_data_block); }
 	uint32 BlocksPerGroup() const
 		{ return B_LENDIAN_TO_HOST_INT32(blocks_per_group); }
+	uint32 FragmentsPerGroup() const
+		{ return B_LENDIAN_TO_HOST_INT32(fragments_per_group); }
 	uint32 InodesPerGroup() const
 		{ return B_LENDIAN_TO_HOST_INT32(inodes_per_group); }
 	uint32 FirstMetaBlockGroup() const
@@ -152,6 +165,7 @@ struct ext2_super_block {
 		// implemented in Volume.cpp
 } _PACKED;
 
+
 #define EXT2_OLD_REVISION		0
 #define EXT2_DYNAMIC_REVISION	1
 
@@ -168,6 +182,7 @@ struct ext2_super_block {
 #define EXT2_FEATURE_EXT_ATTR					0x0008
 #define EXT2_FEATURE_RESIZE_INODE				0x0010
 #define EXT2_FEATURE_DIRECTORY_INDEX			0x0020
+#define EXT2_FEATURE_SPARSESUPER2				0x0200
 
 // read-only compatible features
 #define EXT2_READ_ONLY_FEATURE_SPARSE_SUPER		0x0001
@@ -177,6 +192,11 @@ struct ext2_super_block {
 #define EXT2_READ_ONLY_FEATURE_GDT_CSUM			0x0010
 #define EXT2_READ_ONLY_FEATURE_DIR_NLINK		0x0020
 #define EXT2_READ_ONLY_FEATURE_EXTRA_ISIZE		0x0040
+#define EXT2_READ_ONLY_FEATURE_QUOTA			0x0100
+#define EXT2_READ_ONLY_FEATURE_BIGALLOC			0x0200
+#define EXT4_READ_ONLY_FEATURE_METADATA_CSUM	0x0400
+#define EXT4_READ_ONLY_FEATURE_READONLY			0x1000
+#define EXT4_READ_ONLY_FEATURE_PROJECT			0x2000
 
 // incompatible features
 #define EXT2_INCOMPATIBLE_FEATURE_COMPRESSION	0x0001
@@ -188,13 +208,18 @@ struct ext2_super_block {
 #define EXT2_INCOMPATIBLE_FEATURE_64BIT			0x0080
 #define EXT2_INCOMPATIBLE_FEATURE_MMP			0x0100
 #define EXT2_INCOMPATIBLE_FEATURE_FLEX_GROUP	0x0200
+#define EXT2_INCOMPATIBLE_FEATURE_EA_INODE		0x0400
+#define EXT2_INCOMPATIBLE_FEATURE_DIR_DATA		0x1000
+#define EXT2_INCOMPATIBLE_FEATURE_CSUM_SEED		0x2000
+#define EXT2_INCOMPATIBLE_FEATURE_LARGEDIR		0x4000
+#define EXT2_INCOMPATIBLE_FEATURE_INLINE_DATA	0x8000
+#define EXT2_INCOMPATIBLE_FEATURE_ENCRYPT		0x10000
 
 // states
 #define EXT2_STATE_VALID						0x01
 #define	EXT2_STATE_INVALID						0x02
 
 #define EXT2_BLOCK_GROUP_NORMAL_SIZE			32
-#define EXT2_BLOCK_GROUP_64BIT_SIZE				64
 
 // block group flags
 #define EXT2_BLOCK_GROUP_INODE_UNINIT	0x1
@@ -209,7 +234,9 @@ struct ext2_block_group {
 	uint16	free_inodes;
 	uint16	used_directories;
 	uint16	flags;
-	uint32	_reserved[2];
+	uint32	exclude_bitmap;
+	uint16	block_bitmap_csum;
+	uint16	inode_bitmap_csum;
 	uint16	unused_inodes;
 	uint16	checksum;
 
@@ -221,7 +248,10 @@ struct ext2_block_group {
 	uint16	free_inodes_high;
 	uint16	used_directories_high;
 	uint16	unused_inodes_high;
-	uint32	_reserved2[3];
+	uint32	exclude_bitmap_high;
+	uint16	block_bitmap_csum_high;
+	uint16	inode_bitmap_csum_high;
+	uint32	_reserved;
 
 	fsblock_t BlockBitmap(bool has64bits) const
 	{
@@ -354,6 +384,10 @@ struct ext2_extent_header {
 		{ generation = B_HOST_TO_LENDIAN_INT32(_generation); }
 } _PACKED;
 
+struct ext2_extent_tail {
+	uint32 checksum;
+} _PACKED;
+
 struct ext2_extent_index {
 	uint32 logical_block;
 	uint32 physical_block;
@@ -434,14 +468,15 @@ struct ext2_inode {
 		};
 		uint16 num_blocks_high;
 	};
-	uint16	_padding;
+	uint16	file_access_control_high;
 	uint16	uid_high;
 	uint16	gid_high;
-	uint32	_reserved2;
+	uint16	checksum;
+	uint16	reserved;
 
 	// extra attributes
 	uint16	extra_inode_size;
-	uint16	_padding2;
+	uint16	checksum_high;
 	uint32	change_time_extra;
 	uint32	modification_time_extra;
 	uint32	access_time_extra;
@@ -668,6 +703,11 @@ struct ext2_inode {
 
 #define EXT2_NAME_LENGTH	255
 
+#define EXT2_DIR_PAD		4
+#define EXT2_DIR_ROUND		(EXT2_DIR_PAD - 1)
+#define EXT2_DIR_REC_LEN(namelen)	(((namelen) + 8 + EXT2_DIR_ROUND) \
+										& ~EXT2_DIR_ROUND)
+
 struct ext2_dir_entry {
 	uint32	inode_id;
 	uint16	length;
@@ -709,6 +749,19 @@ struct ext2_dir_entry {
 	}
 } _PACKED;
 
+struct ext2_dir_entry_tail {
+	uint32	zero1;
+	uint16	twelve;
+	uint8	zero2;
+	uint8	hexade;
+	uint32	checksum;
+} _PACKED;
+
+struct ext2_htree_tail {
+	uint32	reserved;
+	uint32	checksum;
+} _PACKED;
+
 // file types
 #define EXT2_TYPE_UNKNOWN		0
 #define EXT2_TYPE_FILE			1
@@ -730,7 +783,8 @@ struct ext2_xattr_header {
 	uint32	refcount;
 	uint32	blocks;		// must be 1 for ext2
 	uint32	hash;
-	uint32	reserved[4];	// zero
+	uint32	checksum;
+	uint32	reserved[3];	// zero
 
 	bool IsValid() const
 	{
diff --git a/src/add-ons/kernel/file_systems/ext2/kernel_interface.cpp b/src/add-ons/kernel/file_systems/ext2/kernel_interface.cpp
index f44e6d4d30..6eecf9bcce 100644
--- a/src/add-ons/kernel/file_systems/ext2/kernel_interface.cpp
+++ b/src/add-ons/kernel/file_systems/ext2/kernel_interface.cpp
@@ -72,6 +72,9 @@ iterative_io_finished_hook(void* cookie, io_request* request, status_t status,
 static float
 ext2_identify_partition(int fd, partition_data *partition, void **_cookie)
 {
+	STATIC_ASSERT(sizeof(struct ext2_super_block) == 1024);
+	STATIC_ASSERT(sizeof(struct ext2_block_group) == 64);
+
 	ext2_super_block superBlock;
 	status_t status = Volume::Identify(fd, &superBlock);
 	if (status != B_OK)
@@ -819,17 +822,7 @@ ext2_create_symlink(fs_volume* _volume, fs_vnode* _directory, const char* name,
 	if (length < EXT2_SHORT_SYMLINK_LENGTH) {
 		strcpy(link->Node().symlink, path);
 		link->Node().SetSize((uint32)length);
-
-		TRACE("ext2_create_symlink(): Publishing vnode\n");
-		publish_vnode(volume->FSVolume(), id, link, &gExt2VnodeOps,
-			link->Mode(), 0);
-		put_vnode(volume->FSVolume(), id);
 	} else {
-		TRACE("ext2_create_symlink(): Publishing vnode\n");
-		publish_vnode(volume->FSVolume(), id, link, &gExt2VnodeOps,
-			link->Mode(), 0);
-		put_vnode(volume->FSVolume(), id);
-
 		if (!link->HasFileCache()) {
 			status = link->CreateFileCache();
 			if (status != B_OK)
@@ -845,16 +838,20 @@ ext2_create_symlink(fs_volume* _volume, fs_vnode* _directory, const char* name,
 	if (status == B_OK)
 		status = link->WriteBack(transaction);
 
-	entry_cache_add(volume->ID(), directory->ID(), name, id);
+	TRACE("ext2_create_symlink(): Publishing vnode\n");
+	publish_vnode(volume->FSVolume(), id, link, &gExt2VnodeOps,
+		link->Mode(), 0);
+	put_vnode(volume->FSVolume(), id);
 
-	status = transaction.Done();
-	if (status != B_OK) {
-		entry_cache_remove(volume->ID(), directory->ID(), name);
-		return status;
+	if (status == B_OK) {
+		entry_cache_add(volume->ID(), directory->ID(), name, id);
+
+		status = transaction.Done();
+		if (status == B_OK)
+			notify_entry_created(volume->ID(), directory->ID(), name, id);
+		else
+			entry_cache_remove(volume->ID(), directory->ID(), name);
 	}
-
-	notify_entry_created(volume->ID(), directory->ID(), name, id);
-
 	TRACE("ext2_create_symlink(): Done\n");
 
 	return status;
@@ -902,22 +899,23 @@ ext2_unlink(fs_volume* _volume, fs_vnode* _directory, const char* name)
 	if (status != B_OK)
 		return status;
 
-	Vnode vnode(volume, id);
-	Inode* inode;
-	status = vnode.Get(&inode);
-	if (status != B_OK)
-		return status;
+	{
+		Vnode vnode(volume, id);
+		Inode* inode;
+		status = vnode.Get(&inode);
+		if (status != B_OK)
+			return status;
 
-	inode->WriteLockInTransaction(transaction);
+		inode->WriteLockInTransaction(transaction);
 
-	status = inode->Unlink(transaction);
-	if (status != B_OK)
-		return status;
-
-	status = directoryIterator->RemoveEntry(transaction);
-	if (status != B_OK)
-		return status;
+		status = inode->Unlink(transaction);
+		if (status != B_OK)
+			return status;
 
+		status = directoryIterator->RemoveEntry(transaction);
+		if (status != B_OK)
+			return status;
+	}
 	entry_cache_remove(volume->ID(), directory->ID(), name);
 
 	status = transaction.Done();
@@ -969,6 +967,8 @@ ext2_rename(fs_volume* _volume, fs_vnode* _oldDir, const char* oldName,
 	if (status != B_OK)
 		return status;
 
+	TRACE("ext2_rename(): found entry to rename\n");
+
 	if (oldDirectory != newDirectory) {
 		TRACE("ext2_rename(): Different parent directories\n");
 		CachedBlock cached(volume);
@@ -1005,6 +1005,8 @@ ext2_rename(fs_volume* _volume, fs_vnode* _oldDir, const char* oldName,
 	if (status != B_OK)
 		return status;
 
+	TRACE("ext2_rename(): found new directory\n");
+
 	ObjectDeleter<DirectoryIterator> newIteratorDeleter(newIterator);
 
 	Vnode vnode(volume, oldID);
@@ -1028,6 +1030,7 @@ ext2_rename(fs_volume* _volume, fs_vnode* _oldDir, const char* oldName,
 	ino_t existentID;
 	status = newIterator->FindEntry(newName, &existentID);
 	if (status == B_OK) {
+		TRACE("ext2_rename(): found existing new entry\n");
 		if (existentID == oldID) {
 			// Remove entry in oldID
 			// return inode->Unlink();
@@ -1059,9 +1062,21 @@ ext2_rename(fs_volume* _volume, fs_vnode* _oldDir, const char* oldName,
 			oldID, fileType);
 		if (status != B_OK)
 			return status;
+
 	} else
 		return status;
 
+	if (oldDirectory == newDirectory) {
+		status = oldHTree.Lookup(oldName, &oldIterator);
+		if (status != B_OK)
+			return status;
+
+		oldIteratorDeleter.SetTo(oldIterator);
+		status = oldIterator->FindEntry(oldName, &oldID);
+		if (status != B_OK)
+			return status;
+	}
+
 	// Remove entry from source folder
 	status = oldIterator->RemoveEntry(transaction);
 	if (status != B_OK)
@@ -1074,7 +1089,7 @@ ext2_rename(fs_volume* _volume, fs_vnode* _oldDir, const char* oldName,
 
 		status = inodeIterator.FindEntry("..");
 		if (status == B_ENTRY_NOT_FOUND) {
-			TRACE("Corrupt file system. Missing \"..\" in directory %"
+			ERROR("Corrupt file system. Missing \"..\" in directory %"
 				B_PRIdINO "\n", inode->ID());
 			return B_BAD_DATA;
 		} else if (status != B_OK)
@@ -1082,6 +1097,15 @@ ext2_rename(fs_volume* _volume, fs_vnode* _oldDir, const char* oldName,
 
 		inodeIterator.ChangeEntry(transaction, newDirectory->ID(),
 			(uint8)EXT2_TYPE_DIRECTORY);
+		// Decrement hardlink count on the source folder
+		status = oldDirectory->Unlink(transaction);
+		if (status != B_OK)
+			ERROR("Error while decrementing hardlink count on the source folder\n");
+		// Increment hardlink count on the destination folder
+		newDirectory->IncrementNumLinks(transaction);
+		status = newDirectory->WriteBack(transaction);
+		if (status != B_OK)
+			ERROR("Error while writing back the destination folder inode\n");
 	}
 
 	status = inode->WriteBack(transaction);