Method Write

Kernel/src/fs/ext2.cpp:1143–1227

    }

    ssize_t Ext2Volume::Write(Ext2Node* node, size_t offset, size_t size, uint8_t *buffer){
        if(readOnly) {
            error = FilesystemAccessError;
            return -EROFS;
        }

        uint32_t blockIndex = LocationToBlock(offset); // Index of first block to write
        uint32_t fileBlockCount = node->e2inode.blockCount / (blocksize / 512); // Size of file in blocks
        uint32_t blockLimit = LocationToBlock(offset + size); // Amount of blocks to write
        uint8_t blockBuffer[blocksize]; // block buffer
        bool sync = false; // Need to sync the inode?

        if(blockLimit >= fileBlockCount){
            if(debugLevelExt2 >= DebugLevelVerbose){
                Log::Info("[Ext2] Allocating blocks for inode %d", node->inode);
            }
            for(unsigned i = fileBlockCount; i <= blockLimit; i++){
                uint32_t block = AllocateBlock();
                SetInodeBlock(i, node->e2inode, block);
            }
            node->e2inode.blockCount = (blockLimit + 1) * (blocksize / 512);

            WriteSuperblock();
            sync = true;
        }

        if(offset + size > node->size){
            node->size = offset + size;
            node->e2inode.size = node->size;

            sync = true;
        }

        if(sync){
            SyncNode(node);
        }

        if(debugLevelExt2 >= DebugLevelVerbose){
            Log::Info("[Ext2] Writing: Block index: %d, Blockcount: %d, Offset: %d, Size: %d", blockIndex, blockLimit - blockIndex + 1, offset, size);
        }

        size_t ret = size;

        for(; blockIndex <= blockLimit && size > 0; blockIndex++){
            uint32_t block = GetInodeBlock(blockIndex, node->e2inode);
            
            if(offset % blocksize){
                ReadBlockCached(block, blockBuffer);

                size_t writeSize = blocksize - (offset % blocksize);
                size_t writeOffset = (offset % blocksize);
                
                if(writeSize > size) writeSize = size;

                memcpy(blockBuffer + writeOffset, buffer, writeSize);
                WriteBlockCached(block, blockBuffer);

                size -= writeSize;