[haiku-commits] haiku: hrev53401 - src/add-ons/kernel/file_systems/ext2

  • From: waddlesplash <waddlesplash@xxxxxxxxx>
  • To: haiku-commits@xxxxxxxxxxxxx
  • Date: Sat, 24 Aug 2019 13:19:00 -0400 (EDT)

hrev53401 adds 1 changeset to branch 'master'
old head: ec6b0f4650185047bf7af591315bc6af15a5453b
new head: ce4e12ca3e341178e3df50ef67cf7c1d724e9559
overview: 
https://git.haiku-os.org/haiku/log/?qt=range&q=ce4e12ca3e34+%5Eec6b0f465018

----------------------------------------------------------------------------

ce4e12ca3e34: 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@xxxxxxxxx>

                                   [ Jérôme Duval <jerome.duval@xxxxxxxxx> ]

----------------------------------------------------------------------------

Revision:    hrev53401
Commit:      ce4e12ca3e341178e3df50ef67cf7c1d724e9559
URL:         https://git.haiku-os.org/haiku/commit/?id=ce4e12ca3e34
Author:      Jérôme Duval <jerome.duval@xxxxxxxxx>
Date:        Wed Oct 10 20:08:43 2018 UTC
Committer:   waddlesplash <waddlesplash@xxxxxxxxx>
Commit-Date: Sat Aug 24 17:18:44 2019 UTC

----------------------------------------------------------------------------

29 files changed, 1761 insertions(+), 177 deletions(-)
.../kernel/file_systems/ext2/BitmapBlock.cpp     |  13 +
.../kernel/file_systems/ext2/BitmapBlock.h       |   2 +
.../kernel/file_systems/ext2/BlockAllocator.cpp  |  75 +-
src/add-ons/kernel/file_systems/ext2/CRCTable.h  |   8 +
.../kernel/file_systems/ext2/DataStream.cpp      |   4 +-
.../file_systems/ext2/DirectoryIterator.cpp      | 198 ++++-
.../kernel/file_systems/ext2/DirectoryIterator.h |  14 +
.../kernel/file_systems/ext2/ExtentStream.cpp    |  11 +-
.../kernel/file_systems/ext2/ExtentStream.h      |   6 +-
src/add-ons/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 +-
.../kernel/file_systems/ext2/HashRevokeManager.h |   2 +-
src/add-ons/kernel/file_systems/ext2/Inode.cpp   | 186 ++++-
src/add-ons/kernel/file_systems/ext2/Inode.h     |  13 +
.../kernel/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 +
src/add-ons/kernel/file_systems/ext2/Journal.cpp | 121 ++-
src/add-ons/kernel/file_systems/ext2/Journal.h   |  88 ++-
.../kernel/file_systems/ext2/RevokeManager.cpp   |   5 +-
.../kernel/file_systems/ext2/RevokeManager.h     |   3 +-
src/add-ons/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 ++-

----------------------------------------------------------------------------

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@xxxxxxxxxxxxxxxxxxxxx.). 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
+ */
+

[ *** diff truncated: 759 lines dropped *** ]




Other related posts:

  • » [haiku-commits] haiku: hrev53401 - src/add-ons/kernel/file_systems/ext2 - waddlesplash