Method SetInodeBlock

Kernel/src/fs/ext2.cpp:285–349

    }
    
    void Ext2Volume::SetInodeBlock(uint32_t index, ext2_inode_t& ino, uint32_t block){
        uint32_t blocksPerPointer = blocksize / sizeof(uint32_t); // Amount of blocks in a indirect block table
        uint32_t singlyIndirectStart = EXT2_DIRECT_BLOCK_COUNT;
        uint32_t doublyIndirectStart = singlyIndirectStart + blocksPerPointer;
        uint32_t triplyIndirectStart = doublyIndirectStart + blocksPerPointer * blocksPerPointer;

        assert(index < triplyIndirectStart + blocksPerPointer * blocksPerPointer * blocksPerPointer); // Make sure that an invalid index was not passed

        if(index < EXT2_DIRECT_BLOCK_COUNT){
            // Index lies within the direct blocklist
            ino.blocks[index] = block;
        } else if(index < doublyIndirectStart){
            // Index lies within the singly indirect blocklist
            uint32_t buffer[blocksize / sizeof(uint32_t)];

            if(ino.blocks[EXT2_SINGLY_INDIRECT_INDEX] == 0){
                ino.blocks[EXT2_SINGLY_INDIRECT_INDEX] = AllocateBlock();
            }

            if(int e = ReadBlockCached(ino.blocks[EXT2_SINGLY_INDIRECT_INDEX], buffer)){
                (void)e;
                error = DiskReadError;
                return;
            }

            buffer[index - singlyIndirectStart] = block;
            
            if(int e = WriteBlockCached(ino.blocks[EXT2_SINGLY_INDIRECT_INDEX], buffer)){
                (void)e;
                error = DiskWriteError;
                return;
            }
            return;
        } else if(index < triplyIndirectStart){
            // Index lies within the doubly indirect blocklist
            uint32_t blockPointers[blocksize / sizeof(uint32_t)];
            uint32_t buffer[blocksize / sizeof(uint32_t)];

            if(int e = ReadBlockCached(ino.blocks[EXT2_DOUBLY_INDIRECT_INDEX], blockPointers)){ // Read indirect block pointer list
                (void)e;
                error = DiskReadError;
                return;
            }

            uint32_t blockPointer = blockPointers[(index - doublyIndirectStart) / blocksPerPointer];

            if(int e = ReadBlockCached(blockPointer, buffer)){ // Read blocklist
                (void)e;
                error = DiskReadError;
                return;
            }

            buffer[(index - doublyIndirectStart) % blocksPerPointer] = block; // Update the index
            
            if(int e = WriteBlockCached(blockPointer, buffer)){ // Write our updated blocklist
                (void)e;
                error = DiskWriteError;
                return;