From cb9c6e9007c72b4e27a76a101d1b023bab954ad6 Mon Sep 17 00:00:00 2001 From: 0xf00sec <159052166+0xf00sec@users.noreply.github.com> Date: Thu, 4 Sep 2025 21:04:57 +0300 Subject: AkeantiFS2 --- dev/kernel/FSKit/Ext2IFS.h | 111 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 111 insertions(+) create mode 100644 dev/kernel/FSKit/Ext2IFS.h (limited to 'dev/kernel/FSKit/Ext2IFS.h') diff --git a/dev/kernel/FSKit/Ext2IFS.h b/dev/kernel/FSKit/Ext2IFS.h new file mode 100644 index 00000000..b8d988de --- /dev/null +++ b/dev/kernel/FSKit/Ext2IFS.h @@ -0,0 +1,111 @@ +#pragma once + +#include +#include +#include +#include +#include +#include + +namespace Ext2 { + +/// @brief Context for an EXT2 filesystem on a given drive +struct Ext2Context { + Kernel::DriveTrait* drive{nullptr}; + EXT2_SUPER_BLOCK* superblock{nullptr}; + + /// @brief context with a drive + explicit Ext2Context(Kernel::DriveTrait* drv) : drive(drv) {} + + /// @brief Clean up + ~Ext2Context() { + if (superblock) { + Kernel::mm_free_ptr(superblock); + superblock = nullptr; + } + } + + inline Kernel::UInt32 block_size() const { + if (!superblock) return kExt2FSBlockSizeBase; + return kExt2FSBlockSizeBase << superblock->fLogBlockSize; + } +}; + +inline bool read_block(Kernel::DriveTrait* drv, Kernel::UInt32 lba, void* buffer, Kernel::UInt32 size) { + if (!drv || !buffer) return false; + + Kernel::DriveTrait::DrivePacket pkt{}; + pkt.fPacketContent = buffer; + pkt.fPacketSize = size; + pkt.fPacketLba = lba; + drv->fInput(pkt); + return pkt.fPacketGood; +} + +inline bool write_block(Kernel::DriveTrait* drv, Kernel::UInt32 lba, const void* buffer, Kernel::UInt32 size) { + if (!drv || !buffer) return false; + + Kernel::DriveTrait::DrivePacket pkt{}; + pkt.fPacketContent = const_cast(buffer); + pkt.fPacketSize = size; + pkt.fPacketLba = lba; + drv->fOutput(pkt); + return pkt.fPacketGood; +} + +// Load superblock +inline Kernel::ErrorOr load_superblock(Ext2Context* ctx) { + if (!ctx || !ctx->drive) return Kernel::ErrorOr(kErrorInvalidData); + + auto buf = Kernel::mm_alloc_ptr(sizeof(EXT2_SUPER_BLOCK), true, false); + if (!buf) return Kernel::ErrorOr(kErrorOutOfMemory); + + Kernel::UInt32 blockLba = kExt2FSSuperblockOffset / ctx->drive->fSectorSz; + if (!read_block(ctx->drive, blockLba, buf, sizeof(EXT2_SUPER_BLOCK))) { + Kernel::mm_free_ptr(buf); + return Kernel::ErrorOr(kErrorReadFailed); + } + + auto sb = reinterpret_cast(buf); + if (sb->fMagic != kExt2FSMagic) { + Kernel::mm_free_ptr(buf); + return Kernel::ErrorOr(kErrorBadData); + } + + ctx->superblock = sb; + return sb; +} + +// Load inode +inline Kernel::ErrorOr load_inode(Ext2Context* ctx, Kernel::UInt32 inodeNumber) { + if (!ctx || !ctx->superblock) return Kernel::ErrorOr(kErrorInvalidData); + + auto nodePtr = Kernel::mm_alloc_ptr(sizeof(Ext2Node), true, false); + if (!nodePtr) return Kernel::ErrorOr(kErrorOutOfMemory); + + auto ext2Node = reinterpret_cast(nodePtr); + ext2Node->inodeNumber = inodeNumber; + + // Compute block group and index within group + Kernel::UInt32 inodesPerGroup = ctx->superblock->fInodesPerGroup; + Kernel::UInt32 group = (inodeNumber - 1) / inodesPerGroup; + Kernel::UInt32 index = (inodeNumber - 1) % inodesPerGroup; + + // dummy: just offset first inode + Kernel::UInt32 inodeTableBlock = ctx->superblock->fFirstInode + group; + + if (!read_block(ctx->drive, inodeTableBlock, &ext2Node->inode, sizeof(EXT2_INODE))) { + Kernel::mm_free_ptr(nodePtr); + return Kernel::ErrorOr(kErrorReadFailed); + } + + ext2Node->cursor = 0; + return ext2Node; +} + +inline Kernel::UInt32 inode_offset(const Ext2Context* ctx, Kernel::UInt32 inodeNumber) { + if (!ctx || !ctx->superblock) return 0; + return ((inodeNumber - 1) % ctx->superblock->fInodesPerGroup) * ctx->superblock->fInodeSize; +} + +} // namespace Ext2 -- cgit v1.2.3 From bacae38de32945ce57e6125902779145cbce4475 Mon Sep 17 00:00:00 2001 From: 0xf00sec <159052166+0xf00sec@users.noreply.github.com> Date: Sat, 6 Sep 2025 19:02:40 +0300 Subject: Update --- dev/kernel/FSKit/Ext2IFS.h | 64 +++++++++++++++++++++++++++++++--------------- 1 file changed, 43 insertions(+), 21 deletions(-) (limited to 'dev/kernel/FSKit/Ext2IFS.h') diff --git a/dev/kernel/FSKit/Ext2IFS.h b/dev/kernel/FSKit/Ext2IFS.h index b8d988de..87095bc6 100644 --- a/dev/kernel/FSKit/Ext2IFS.h +++ b/dev/kernel/FSKit/Ext2IFS.h @@ -5,33 +5,55 @@ #include #include #include -#include +#include +#include namespace Ext2 { /// @brief Context for an EXT2 filesystem on a given drive -struct Ext2Context { +struct Context { Kernel::DriveTrait* drive{nullptr}; EXT2_SUPER_BLOCK* superblock{nullptr}; /// @brief context with a drive - explicit Ext2Context(Kernel::DriveTrait* drv) : drive(drv) {} + explicit Context(Kernel::DriveTrait* drv) : drive(drv) {} /// @brief Clean up - ~Ext2Context() { + ~Context() { if (superblock) { Kernel::mm_free_ptr(superblock); superblock = nullptr; } } - inline Kernel::UInt32 block_size() const { + Context(const Context&) = delete; + Context& operator=(const Context&) = delete; + + Context(Context&& other) noexcept : drive(other.drive), superblock(other.superblock) { + other.drive = nullptr; + other.superblock = nullptr; + } + + Context& operator=(Context&& other) noexcept { + if (this != &other) { + if (superblock) { + Kernel::mm_free_ptr(superblock); + } + drive = other.drive; + superblock = other.superblock; + other.drive = nullptr; + other.superblock = nullptr; + } + return *this; + } + + inline Kernel::UInt32 BlockSize() const { if (!superblock) return kExt2FSBlockSizeBase; return kExt2FSBlockSizeBase << superblock->fLogBlockSize; } }; -inline bool read_block(Kernel::DriveTrait* drv, Kernel::UInt32 lba, void* buffer, Kernel::UInt32 size) { +inline bool ext2_read_block(Kernel::DriveTrait* drv, Kernel::UInt32 lba, void* buffer, Kernel::UInt32 size) { if (!drv || !buffer) return false; Kernel::DriveTrait::DrivePacket pkt{}; @@ -42,7 +64,7 @@ inline bool read_block(Kernel::DriveTrait* drv, Kernel::UInt32 lba, void* buffer return pkt.fPacketGood; } -inline bool write_block(Kernel::DriveTrait* drv, Kernel::UInt32 lba, const void* buffer, Kernel::UInt32 size) { +inline bool ext2_write_block(Kernel::DriveTrait* drv, Kernel::UInt32 lba, const void* buffer, Kernel::UInt32 size) { if (!drv || !buffer) return false; Kernel::DriveTrait::DrivePacket pkt{}; @@ -54,34 +76,34 @@ inline bool write_block(Kernel::DriveTrait* drv, Kernel::UInt32 lba, const void* } // Load superblock -inline Kernel::ErrorOr load_superblock(Ext2Context* ctx) { - if (!ctx || !ctx->drive) return Kernel::ErrorOr(kErrorInvalidData); +inline Kernel::ErrorOr ext2_load_superblock(Context* ctx) { + if (!ctx || !ctx->drive) return Kernel::ErrorOr(Kernel::kErrorInvalidData); auto buf = Kernel::mm_alloc_ptr(sizeof(EXT2_SUPER_BLOCK), true, false); - if (!buf) return Kernel::ErrorOr(kErrorOutOfMemory); + if (!buf) return Kernel::ErrorOr(Kernel::kErrorHeapOutOfMemory); Kernel::UInt32 blockLba = kExt2FSSuperblockOffset / ctx->drive->fSectorSz; - if (!read_block(ctx->drive, blockLba, buf, sizeof(EXT2_SUPER_BLOCK))) { + if (!ext2_read_block(ctx->drive, blockLba, buf, sizeof(EXT2_SUPER_BLOCK))) { Kernel::mm_free_ptr(buf); - return Kernel::ErrorOr(kErrorReadFailed); + return Kernel::ErrorOr(Kernel::kErrorDisk); } auto sb = reinterpret_cast(buf); if (sb->fMagic != kExt2FSMagic) { Kernel::mm_free_ptr(buf); - return Kernel::ErrorOr(kErrorBadData); + return Kernel::ErrorOr(Kernel::kErrorInvalidData); } ctx->superblock = sb; - return sb; + return Kernel::ErrorOr(sb); } // Load inode -inline Kernel::ErrorOr load_inode(Ext2Context* ctx, Kernel::UInt32 inodeNumber) { - if (!ctx || !ctx->superblock) return Kernel::ErrorOr(kErrorInvalidData); +inline Kernel::ErrorOr ext2_load_inode(Context* ctx, Kernel::UInt32 inodeNumber) { + if (!ctx || !ctx->superblock) return Kernel::ErrorOr(Kernel::kErrorInvalidData); auto nodePtr = Kernel::mm_alloc_ptr(sizeof(Ext2Node), true, false); - if (!nodePtr) return Kernel::ErrorOr(kErrorOutOfMemory); + if (!nodePtr) return Kernel::ErrorOr(Kernel::kErrorHeapOutOfMemory); auto ext2Node = reinterpret_cast(nodePtr); ext2Node->inodeNumber = inodeNumber; @@ -94,16 +116,16 @@ inline Kernel::ErrorOr load_inode(Ext2Context* ctx, Kernel::UInt32 in // dummy: just offset first inode Kernel::UInt32 inodeTableBlock = ctx->superblock->fFirstInode + group; - if (!read_block(ctx->drive, inodeTableBlock, &ext2Node->inode, sizeof(EXT2_INODE))) { + if (!ext2_read_block(ctx->drive, inodeTableBlock, &ext2Node->inode, sizeof(EXT2_INODE))) { Kernel::mm_free_ptr(nodePtr); - return Kernel::ErrorOr(kErrorReadFailed); + return Kernel::ErrorOr(Kernel::kErrorDisk); } ext2Node->cursor = 0; - return ext2Node; + return Kernel::ErrorOr(ext2Node); } -inline Kernel::UInt32 inode_offset(const Ext2Context* ctx, Kernel::UInt32 inodeNumber) { +inline Kernel::UInt32 inode_offset(const Context* ctx, Kernel::UInt32 inodeNumber) { if (!ctx || !ctx->superblock) return 0; return ((inodeNumber - 1) % ctx->superblock->fInodesPerGroup) * ctx->superblock->fInodeSize; } -- cgit v1.2.3