From 3ace886a9e9f044cd48de51f0a15aceb02bfa9b2 Mon Sep 17 00:00:00 2001 From: "marcel.braun" Date: Tue, 17 Mar 2026 19:36:20 +0100 Subject: Clean up project folder structure --- kernel/src/filesystem/ext2/ext2_filesystem.cpp | 33 ++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 kernel/src/filesystem/ext2/ext2_filesystem.cpp (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/ext2_filesystem.cpp b/kernel/src/filesystem/ext2/ext2_filesystem.cpp new file mode 100644 index 0000000..408b292 --- /dev/null +++ b/kernel/src/filesystem/ext2/ext2_filesystem.cpp @@ -0,0 +1,33 @@ +#include "kernel/filesystem/ext2/ext2_filesystem.hpp" + +#include "kernel/devices/device.hpp" +#include "kernel/filesystem/inode.hpp" +#include "kernel/filesystem/inode_metadata.hpp" + +#include + +#include + +namespace filesystem::ext2 +{ + auto ext2_filesystem::mount(kstd::shared_ptr const & device) -> int + { + if (!device) + { + return -1; // TODO BA-FS26 panic or errorcode? + } + + m_device = device; + // TODO BA-FS26 load proper root inode from ext2 metadata + m_root_inode = inode{inode_kind::directory}; + + // TODO BA-FS26 implement + return 0; + } + + auto ext2_filesystem::lookup(inode const & /*parent*/, std::string_view /*name*/) -> inode * + { + // TODO BA-FS26 implement ext2 directory traversal and inode loading + return nullptr; + } +} // namespace filesystem::ext2 -- cgit v1.2.3 From 98b6633ea8e961f8668259dbd4970330494408d5 Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Thu, 19 Mar 2026 21:32:38 +0100 Subject: prepare files for new inode structure --- kernel/src/filesystem/ext2/ext2_inode.cpp | 6 ++++++ 1 file changed, 6 insertions(+) create mode 100644 kernel/src/filesystem/ext2/ext2_inode.cpp (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/ext2_inode.cpp b/kernel/src/filesystem/ext2/ext2_inode.cpp new file mode 100644 index 0000000..ec68ee9 --- /dev/null +++ b/kernel/src/filesystem/ext2/ext2_inode.cpp @@ -0,0 +1,6 @@ +#include "kernel/filesystem/ext2/ext2_inode.hpp" + +namespace filesystem::ext2 +{ + // TODO BA-FS26: Implement ext2 inode +} \ No newline at end of file -- cgit v1.2.3 From 8d3471f1d160d301f9d990455bd8c63450df1cf3 Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Thu, 19 Mar 2026 21:59:31 +0100 Subject: remove inode metadata --- kernel/src/filesystem/ext2/ext2_filesystem.cpp | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/ext2_filesystem.cpp b/kernel/src/filesystem/ext2/ext2_filesystem.cpp index 408b292..87845d5 100644 --- a/kernel/src/filesystem/ext2/ext2_filesystem.cpp +++ b/kernel/src/filesystem/ext2/ext2_filesystem.cpp @@ -2,7 +2,6 @@ #include "kernel/devices/device.hpp" #include "kernel/filesystem/inode.hpp" -#include "kernel/filesystem/inode_metadata.hpp" #include @@ -19,7 +18,7 @@ namespace filesystem::ext2 m_device = device; // TODO BA-FS26 load proper root inode from ext2 metadata - m_root_inode = inode{inode_kind::directory}; + // m_root_inode = inode{inode_kind::directory}; // TODO BA-FS26 implement return 0; -- cgit v1.2.3 From 09e3d0cb2272e7eabd79a320c17c58124515d427 Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Thu, 19 Mar 2026 22:58:31 +0100 Subject: first try to simplify the architecture (remove redundant inode_file and open() methods), add ext2_file placeholder struct --- kernel/src/filesystem/ext2/ext2_file.cpp | 20 ++++++++++++++++++++ kernel/src/filesystem/ext2/ext2_inode.cpp | 17 +++++++++++++++-- 2 files changed, 35 insertions(+), 2 deletions(-) create mode 100644 kernel/src/filesystem/ext2/ext2_file.cpp (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/ext2_file.cpp b/kernel/src/filesystem/ext2/ext2_file.cpp new file mode 100644 index 0000000..7217c77 --- /dev/null +++ b/kernel/src/filesystem/ext2/ext2_file.cpp @@ -0,0 +1,20 @@ +#include "kernel/filesystem/ext2/ext2_file.hpp" + +#include "kapi/system.hpp" + +#include + +namespace filesystem::ext2 +{ + auto ext2_file::read(void * /*buffer*/, size_t /*offset*/, size_t /*size*/) const -> size_t + { + kapi::system::panic("[FILESYSTEM] ext2_file::read is not implemented yet."); + return 0; + } + + auto ext2_file::write(void const * /*buffer*/, size_t /*offset*/, size_t /*size*/) -> size_t + { + kapi::system::panic("[FILESYSTEM] ext2_file::write is not implemented yet."); + return 0; + } +} // namespace filesystem::ext2 diff --git a/kernel/src/filesystem/ext2/ext2_inode.cpp b/kernel/src/filesystem/ext2/ext2_inode.cpp index ec68ee9..1522387 100644 --- a/kernel/src/filesystem/ext2/ext2_inode.cpp +++ b/kernel/src/filesystem/ext2/ext2_inode.cpp @@ -1,6 +1,19 @@ #include "kernel/filesystem/ext2/ext2_inode.hpp" +#include "kernel/filesystem/ext2/ext2_file.hpp" +#include "kernel/filesystem/file.hpp" +#include "kernel/filesystem/inode.hpp" + +#include + namespace filesystem::ext2 { - // TODO BA-FS26: Implement ext2 inode -} \ No newline at end of file + ext2_inode::ext2_inode() + : inode(inode_kind::regular) + {} + + auto ext2_inode::open_file() const -> kstd::shared_ptr + { + return kstd::make_shared(); + } +} // namespace filesystem::ext2 \ No newline at end of file -- cgit v1.2.3 From f669454966c9fa8cbdbbefb1d9cfdd61026849f9 Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Fri, 20 Mar 2026 21:47:58 +0100 Subject: improve architecture again -> use same architecture for devices and ext2_files --- kernel/src/filesystem/ext2/ext2_inode.cpp | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/ext2_inode.cpp b/kernel/src/filesystem/ext2/ext2_inode.cpp index 1522387..8131f43 100644 --- a/kernel/src/filesystem/ext2/ext2_inode.cpp +++ b/kernel/src/filesystem/ext2/ext2_inode.cpp @@ -1,19 +1,21 @@ #include "kernel/filesystem/ext2/ext2_inode.hpp" -#include "kernel/filesystem/ext2/ext2_file.hpp" +#include "kernel/filesystem/disk_file.hpp" #include "kernel/filesystem/file.hpp" #include "kernel/filesystem/inode.hpp" +#include "kernel/filesystem/inode_file.hpp" #include namespace filesystem::ext2 { - ext2_inode::ext2_inode() + ext2_inode::ext2_inode(kstd::shared_ptr const & disk_file) : inode(inode_kind::regular) + , m_disk_file(disk_file) {} auto ext2_inode::open_file() const -> kstd::shared_ptr { - return kstd::make_shared(); + return kstd::make_shared(m_disk_file); } } // namespace filesystem::ext2 \ No newline at end of file -- cgit v1.2.3 From ba63fbfc2bb43a6f0f05b6b49fd51fd6c89a0861 Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Sat, 21 Mar 2026 00:28:17 +0100 Subject: refactor file and inode architecture again --- kernel/src/filesystem/ext2/ext2_inode.cpp | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/ext2_inode.cpp b/kernel/src/filesystem/ext2/ext2_inode.cpp index 8131f43..0a1994b 100644 --- a/kernel/src/filesystem/ext2/ext2_inode.cpp +++ b/kernel/src/filesystem/ext2/ext2_inode.cpp @@ -1,6 +1,7 @@ #include "kernel/filesystem/ext2/ext2_inode.hpp" -#include "kernel/filesystem/disk_file.hpp" +#include "kapi/system.hpp" + #include "kernel/filesystem/file.hpp" #include "kernel/filesystem/inode.hpp" #include "kernel/filesystem/inode_file.hpp" @@ -9,13 +10,17 @@ namespace filesystem::ext2 { - ext2_inode::ext2_inode(kstd::shared_ptr const & disk_file) + ext2_inode::ext2_inode() : inode(inode_kind::regular) - , m_disk_file(disk_file) {} - auto ext2_inode::open_file() const -> kstd::shared_ptr + auto ext2_inode::open_file(kstd::shared_ptr const & self) const -> kstd::shared_ptr { - return kstd::make_shared(m_disk_file); + if (!self) + { + kapi::system::panic("[FILESYSTEM] ext2_inode::open_file called with null inode."); + } + + return kstd::make_shared(self); } } // namespace filesystem::ext2 \ No newline at end of file -- cgit v1.2.3 From ffb2accb09a013d8da16acd824c846bc1acfd8e4 Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Sat, 21 Mar 2026 10:52:46 +0100 Subject: use enable_shared_from_this instead of self invocation method --- kernel/src/filesystem/ext2/ext2_inode.cpp | 11 ++--------- 1 file changed, 2 insertions(+), 9 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/ext2_inode.cpp b/kernel/src/filesystem/ext2/ext2_inode.cpp index 0a1994b..0760cb1 100644 --- a/kernel/src/filesystem/ext2/ext2_inode.cpp +++ b/kernel/src/filesystem/ext2/ext2_inode.cpp @@ -1,7 +1,5 @@ #include "kernel/filesystem/ext2/ext2_inode.hpp" -#include "kapi/system.hpp" - #include "kernel/filesystem/file.hpp" #include "kernel/filesystem/inode.hpp" #include "kernel/filesystem/inode_file.hpp" @@ -14,13 +12,8 @@ namespace filesystem::ext2 : inode(inode_kind::regular) {} - auto ext2_inode::open_file(kstd::shared_ptr const & self) const -> kstd::shared_ptr + auto ext2_inode::open_file() -> kstd::shared_ptr { - if (!self) - { - kapi::system::panic("[FILESYSTEM] ext2_inode::open_file called with null inode."); - } - - return kstd::make_shared(self); + return kstd::make_shared(shared_from_this()); } } // namespace filesystem::ext2 \ No newline at end of file -- cgit v1.2.3 From 6c172389b562a08a6540574d6fbdf6a5bdce37b8 Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Sat, 21 Mar 2026 16:22:23 +0100 Subject: simplify architecture again --- kernel/src/filesystem/ext2/ext2_inode.cpp | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/ext2_inode.cpp b/kernel/src/filesystem/ext2/ext2_inode.cpp index 0760cb1..3cc0fb2 100644 --- a/kernel/src/filesystem/ext2/ext2_inode.cpp +++ b/kernel/src/filesystem/ext2/ext2_inode.cpp @@ -1,10 +1,8 @@ #include "kernel/filesystem/ext2/ext2_inode.hpp" -#include "kernel/filesystem/file.hpp" #include "kernel/filesystem/inode.hpp" -#include "kernel/filesystem/inode_file.hpp" -#include +#include namespace filesystem::ext2 { @@ -12,8 +10,15 @@ namespace filesystem::ext2 : inode(inode_kind::regular) {} - auto ext2_inode::open_file() -> kstd::shared_ptr + auto ext2_inode::read(void * /*buffer*/, size_t /*offset*/, size_t /*size*/) const -> size_t { - return kstd::make_shared(shared_from_this()); + // TODO BA-FS26 implement + return 0; + } + + auto ext2_inode::write(void const * /*buffer*/, size_t /*offset*/, size_t /*size*/) -> size_t + { + // TODO BA-FS26 implement + return 0; } } // namespace filesystem::ext2 \ No newline at end of file -- cgit v1.2.3 From bcb4f8a76dea2443c1597716e27b7c2d268bfc44 Mon Sep 17 00:00:00 2001 From: "marcel.braun" Date: Mon, 23 Mar 2026 09:49:32 +0100 Subject: Refactor filesystem --- kernel/src/filesystem/ext2/ext2_filesystem.cpp | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/ext2_filesystem.cpp b/kernel/src/filesystem/ext2/ext2_filesystem.cpp index 87845d5..ea692ee 100644 --- a/kernel/src/filesystem/ext2/ext2_filesystem.cpp +++ b/kernel/src/filesystem/ext2/ext2_filesystem.cpp @@ -1,6 +1,7 @@ #include "kernel/filesystem/ext2/ext2_filesystem.hpp" #include "kernel/devices/device.hpp" +#include "kernel/filesystem/filesystem.hpp" #include "kernel/filesystem/inode.hpp" #include @@ -11,12 +12,7 @@ namespace filesystem::ext2 { auto ext2_filesystem::mount(kstd::shared_ptr const & device) -> int { - if (!device) - { - return -1; // TODO BA-FS26 panic or errorcode? - } - - m_device = device; + filesystem::mount(device); // TODO BA-FS26 error handling? // TODO BA-FS26 load proper root inode from ext2 metadata // m_root_inode = inode{inode_kind::directory}; -- cgit v1.2.3 From fdcf1c7d2b47d418916e311cea8b87affaf63f90 Mon Sep 17 00:00:00 2001 From: "marcel.braun" Date: Mon, 23 Mar 2026 20:12:29 +0100 Subject: Small refactoring use shared pointer --- kernel/src/filesystem/ext2/ext2_filesystem.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/ext2_filesystem.cpp b/kernel/src/filesystem/ext2/ext2_filesystem.cpp index ea692ee..536e328 100644 --- a/kernel/src/filesystem/ext2/ext2_filesystem.cpp +++ b/kernel/src/filesystem/ext2/ext2_filesystem.cpp @@ -20,7 +20,8 @@ namespace filesystem::ext2 return 0; } - auto ext2_filesystem::lookup(inode const & /*parent*/, std::string_view /*name*/) -> inode * + auto ext2_filesystem::lookup(kstd::shared_ptr const & /*parent*/, std::string_view /*name*/) + -> kstd::shared_ptr { // TODO BA-FS26 implement ext2 directory traversal and inode loading return nullptr; -- cgit v1.2.3 From b3cb1d0f8864bf54362f1da2b7a65ca693778cff Mon Sep 17 00:00:00 2001 From: "marcel.braun" Date: Mon, 23 Mar 2026 22:18:54 +0100 Subject: Add test for resolve_path --- kernel/src/filesystem/ext2/ext2_filesystem.cpp | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/ext2_filesystem.cpp b/kernel/src/filesystem/ext2/ext2_filesystem.cpp index 536e328..3f5774c 100644 --- a/kernel/src/filesystem/ext2/ext2_filesystem.cpp +++ b/kernel/src/filesystem/ext2/ext2_filesystem.cpp @@ -1,6 +1,7 @@ #include "kernel/filesystem/ext2/ext2_filesystem.hpp" #include "kernel/devices/device.hpp" +#include "kernel/filesystem/ext2/ext2_inode.hpp" #include "kernel/filesystem/filesystem.hpp" #include "kernel/filesystem/inode.hpp" @@ -17,6 +18,7 @@ namespace filesystem::ext2 // m_root_inode = inode{inode_kind::directory}; // TODO BA-FS26 implement + m_root_inode = kstd::make_shared(); return 0; } @@ -24,6 +26,7 @@ namespace filesystem::ext2 -> kstd::shared_ptr { // TODO BA-FS26 implement ext2 directory traversal and inode loading - return nullptr; + // return nullptr; + return kstd::make_shared(); } } // namespace filesystem::ext2 -- cgit v1.2.3 From 372148a1379d7f14cbe641272f8f28766925f3aa Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Thu, 26 Mar 2026 21:13:59 +0100 Subject: mock filesystem correctly for tests with /dev --- kernel/src/filesystem/ext2/ext2_filesystem.cpp | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/ext2_filesystem.cpp b/kernel/src/filesystem/ext2/ext2_filesystem.cpp index 3f5774c..373c6a2 100644 --- a/kernel/src/filesystem/ext2/ext2_filesystem.cpp +++ b/kernel/src/filesystem/ext2/ext2_filesystem.cpp @@ -22,11 +22,16 @@ namespace filesystem::ext2 return 0; } - auto ext2_filesystem::lookup(kstd::shared_ptr const & /*parent*/, std::string_view /*name*/) + auto ext2_filesystem::lookup(kstd::shared_ptr const & /*parent*/, std::string_view name) -> kstd::shared_ptr { // TODO BA-FS26 implement ext2 directory traversal and inode loading - // return nullptr; + if (name == "dev") + { + // TODO BA-FS26 just for testing + return nullptr; + } + return kstd::make_shared(); } } // namespace filesystem::ext2 -- cgit v1.2.3 From 8c0488fb8df8742740eb8464a7ad51d71a24e416 Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Sun, 29 Mar 2026 13:29:23 +0200 Subject: remove redundant ext2_file class --- kernel/src/filesystem/ext2/ext2_file.cpp | 20 -------------------- 1 file changed, 20 deletions(-) delete mode 100644 kernel/src/filesystem/ext2/ext2_file.cpp (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/ext2_file.cpp b/kernel/src/filesystem/ext2/ext2_file.cpp deleted file mode 100644 index 7217c77..0000000 --- a/kernel/src/filesystem/ext2/ext2_file.cpp +++ /dev/null @@ -1,20 +0,0 @@ -#include "kernel/filesystem/ext2/ext2_file.hpp" - -#include "kapi/system.hpp" - -#include - -namespace filesystem::ext2 -{ - auto ext2_file::read(void * /*buffer*/, size_t /*offset*/, size_t /*size*/) const -> size_t - { - kapi::system::panic("[FILESYSTEM] ext2_file::read is not implemented yet."); - return 0; - } - - auto ext2_file::write(void const * /*buffer*/, size_t /*offset*/, size_t /*size*/) -> size_t - { - kapi::system::panic("[FILESYSTEM] ext2_file::write is not implemented yet."); - return 0; - } -} // namespace filesystem::ext2 -- cgit v1.2.3 From 9c602f2cf8fd87f55adc31c085e469e72b7cbbfa Mon Sep 17 00:00:00 2001 From: "marcel.braun" Date: Sun, 29 Mar 2026 20:49:03 +0200 Subject: Move block device offset and size-to-blocks calculation to block_device_utils --- kernel/src/filesystem/ext2/ext2_filesystem.cpp | 2 ++ 1 file changed, 2 insertions(+) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/ext2_filesystem.cpp b/kernel/src/filesystem/ext2/ext2_filesystem.cpp index 373c6a2..19f1014 100644 --- a/kernel/src/filesystem/ext2/ext2_filesystem.cpp +++ b/kernel/src/filesystem/ext2/ext2_filesystem.cpp @@ -1,5 +1,6 @@ #include "kernel/filesystem/ext2/ext2_filesystem.hpp" +#include "kernel/devices/block_device_utils.hpp" #include "kernel/devices/device.hpp" #include "kernel/filesystem/ext2/ext2_inode.hpp" #include "kernel/filesystem/filesystem.hpp" @@ -19,6 +20,7 @@ namespace filesystem::ext2 // TODO BA-FS26 implement m_root_inode = kstd::make_shared(); + // devices::block_device_utils::read(device, nullptr, 0, 0); // TODO BA-FS26 just for testing return 0; } -- cgit v1.2.3 From ea578b348f63939bb07bd669ad86d3fe1b6d5f65 Mon Sep 17 00:00:00 2001 From: "marcel.braun" Date: Sun, 29 Mar 2026 21:30:32 +0200 Subject: Save WIP add some definitions and helper functions --- kernel/src/filesystem/ext2/ext2_filesystem.cpp | 33 ++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/ext2_filesystem.cpp b/kernel/src/filesystem/ext2/ext2_filesystem.cpp index 19f1014..e176ade 100644 --- a/kernel/src/filesystem/ext2/ext2_filesystem.cpp +++ b/kernel/src/filesystem/ext2/ext2_filesystem.cpp @@ -3,15 +3,48 @@ #include "kernel/devices/block_device_utils.hpp" #include "kernel/devices/device.hpp" #include "kernel/filesystem/ext2/ext2_inode.hpp" +#include "kernel/filesystem/ext2/ext2_superblock.hpp" #include "kernel/filesystem/filesystem.hpp" #include "kernel/filesystem/inode.hpp" #include +#include +#include #include namespace filesystem::ext2 { + namespace + { + constexpr size_t SUPERBLOCK_OFFSET = 1024; + constexpr uint16_t EXT2_MAGIC = 0xEF53; + + // Mode bits + constexpr uint16_t S_IFMT = 0xF000; + constexpr uint16_t S_IFREG = 0x8000; + constexpr uint16_t S_IFDIR = 0x4000; + + auto S_ISREG(uint16_t mode) -> bool + { + return (mode & S_IFMT) == S_IFREG; + } + auto S_ISDIR(uint16_t mode) -> bool + { + return (mode & S_IFMT) == S_IFDIR; + } + + auto get_block_size(ext2_superblock const & superblock) -> size_t + { + return 1024U << superblock.log_block_size; + } + + auto get_inode_size(ext2_superblock const & superblock) -> size_t + { + return superblock.rev_level == 0 ? 128 : superblock.inode_size; + } + } // namespace + auto ext2_filesystem::mount(kstd::shared_ptr const & device) -> int { filesystem::mount(device); // TODO BA-FS26 error handling? -- cgit v1.2.3 From 7ad07a735759dc93b668ec92896f57c0c0df0025 Mon Sep 17 00:00:00 2001 From: "marcel.braun" Date: Mon, 30 Mar 2026 19:26:48 +0200 Subject: Fix linter warnings --- kernel/src/filesystem/ext2/ext2_filesystem.cpp | 44 +++++++++++++------------- 1 file changed, 22 insertions(+), 22 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/ext2_filesystem.cpp b/kernel/src/filesystem/ext2/ext2_filesystem.cpp index e176ade..ea6fe0d 100644 --- a/kernel/src/filesystem/ext2/ext2_filesystem.cpp +++ b/kernel/src/filesystem/ext2/ext2_filesystem.cpp @@ -17,32 +17,32 @@ namespace filesystem::ext2 { namespace { - constexpr size_t SUPERBLOCK_OFFSET = 1024; - constexpr uint16_t EXT2_MAGIC = 0xEF53; + // constexpr size_t SUPERBLOCK_OFFSET = 1024; + // constexpr uint16_t EXT2_MAGIC = 0xEF53; - // Mode bits - constexpr uint16_t S_IFMT = 0xF000; - constexpr uint16_t S_IFREG = 0x8000; - constexpr uint16_t S_IFDIR = 0x4000; + // // Mode bits + // constexpr uint16_t S_IFMT = 0xF000; + // constexpr uint16_t S_IFREG = 0x8000; + // constexpr uint16_t S_IFDIR = 0x4000; - auto S_ISREG(uint16_t mode) -> bool - { - return (mode & S_IFMT) == S_IFREG; - } - auto S_ISDIR(uint16_t mode) -> bool - { - return (mode & S_IFMT) == S_IFDIR; - } + // auto S_ISREG(uint16_t mode) -> bool + // { + // return (mode & S_IFMT) == S_IFREG; + // } + // auto S_ISDIR(uint16_t mode) -> bool + // { + // return (mode & S_IFMT) == S_IFDIR; + // } - auto get_block_size(ext2_superblock const & superblock) -> size_t - { - return 1024U << superblock.log_block_size; - } + // auto get_block_size(ext2_superblock const & superblock) -> size_t + // { + // return 1024U << superblock.log_block_size; + // } - auto get_inode_size(ext2_superblock const & superblock) -> size_t - { - return superblock.rev_level == 0 ? 128 : superblock.inode_size; - } + // auto get_inode_size(ext2_superblock const & superblock) -> size_t + // { + // return superblock.rev_level == 0 ? 128 : superblock.inode_size; + // } } // namespace auto ext2_filesystem::mount(kstd::shared_ptr const & device) -> int -- cgit v1.2.3 From 5603c7ec2b07dbc772fe2c20a9e9e176c5465c57 Mon Sep 17 00:00:00 2001 From: "marcel.braun" Date: Mon, 30 Mar 2026 21:22:22 +0200 Subject: Move everything in kernel into kernel namespace --- kernel/src/filesystem/ext2/ext2_filesystem.cpp | 4 ++-- kernel/src/filesystem/ext2/ext2_inode.cpp | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/ext2_filesystem.cpp b/kernel/src/filesystem/ext2/ext2_filesystem.cpp index ea6fe0d..036b80e 100644 --- a/kernel/src/filesystem/ext2/ext2_filesystem.cpp +++ b/kernel/src/filesystem/ext2/ext2_filesystem.cpp @@ -13,7 +13,7 @@ #include #include -namespace filesystem::ext2 +namespace kernel::filesystem::ext2 { namespace { @@ -69,4 +69,4 @@ namespace filesystem::ext2 return kstd::make_shared(); } -} // namespace filesystem::ext2 +} // namespace kernel::filesystem::ext2 diff --git a/kernel/src/filesystem/ext2/ext2_inode.cpp b/kernel/src/filesystem/ext2/ext2_inode.cpp index 3cc0fb2..142502e 100644 --- a/kernel/src/filesystem/ext2/ext2_inode.cpp +++ b/kernel/src/filesystem/ext2/ext2_inode.cpp @@ -4,7 +4,7 @@ #include -namespace filesystem::ext2 +namespace kernel::filesystem::ext2 { ext2_inode::ext2_inode() : inode(inode_kind::regular) @@ -21,4 +21,4 @@ namespace filesystem::ext2 // TODO BA-FS26 implement return 0; } -} // namespace filesystem::ext2 \ No newline at end of file +} // namespace kernel::filesystem::ext2 \ No newline at end of file -- cgit v1.2.3 From 55e37a219fc953d1675bc2edb8573c6d47df7647 Mon Sep 17 00:00:00 2001 From: "marcel.braun" Date: Mon, 30 Mar 2026 21:23:02 +0200 Subject: Rename ext2 filesystem files --- kernel/src/filesystem/ext2/ext2_filesystem.cpp | 72 -------------------------- kernel/src/filesystem/ext2/ext2_inode.cpp | 24 --------- kernel/src/filesystem/ext2/filesystem.cpp | 72 ++++++++++++++++++++++++++ kernel/src/filesystem/ext2/inode.cpp | 24 +++++++++ 4 files changed, 96 insertions(+), 96 deletions(-) delete mode 100644 kernel/src/filesystem/ext2/ext2_filesystem.cpp delete mode 100644 kernel/src/filesystem/ext2/ext2_inode.cpp create mode 100644 kernel/src/filesystem/ext2/filesystem.cpp create mode 100644 kernel/src/filesystem/ext2/inode.cpp (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/ext2_filesystem.cpp b/kernel/src/filesystem/ext2/ext2_filesystem.cpp deleted file mode 100644 index 036b80e..0000000 --- a/kernel/src/filesystem/ext2/ext2_filesystem.cpp +++ /dev/null @@ -1,72 +0,0 @@ -#include "kernel/filesystem/ext2/ext2_filesystem.hpp" - -#include "kernel/devices/block_device_utils.hpp" -#include "kernel/devices/device.hpp" -#include "kernel/filesystem/ext2/ext2_inode.hpp" -#include "kernel/filesystem/ext2/ext2_superblock.hpp" -#include "kernel/filesystem/filesystem.hpp" -#include "kernel/filesystem/inode.hpp" - -#include - -#include -#include -#include - -namespace kernel::filesystem::ext2 -{ - namespace - { - // constexpr size_t SUPERBLOCK_OFFSET = 1024; - // constexpr uint16_t EXT2_MAGIC = 0xEF53; - - // // Mode bits - // constexpr uint16_t S_IFMT = 0xF000; - // constexpr uint16_t S_IFREG = 0x8000; - // constexpr uint16_t S_IFDIR = 0x4000; - - // auto S_ISREG(uint16_t mode) -> bool - // { - // return (mode & S_IFMT) == S_IFREG; - // } - // auto S_ISDIR(uint16_t mode) -> bool - // { - // return (mode & S_IFMT) == S_IFDIR; - // } - - // auto get_block_size(ext2_superblock const & superblock) -> size_t - // { - // return 1024U << superblock.log_block_size; - // } - - // auto get_inode_size(ext2_superblock const & superblock) -> size_t - // { - // return superblock.rev_level == 0 ? 128 : superblock.inode_size; - // } - } // namespace - - auto ext2_filesystem::mount(kstd::shared_ptr const & device) -> int - { - filesystem::mount(device); // TODO BA-FS26 error handling? - // TODO BA-FS26 load proper root inode from ext2 metadata - // m_root_inode = inode{inode_kind::directory}; - - // TODO BA-FS26 implement - m_root_inode = kstd::make_shared(); - // devices::block_device_utils::read(device, nullptr, 0, 0); // TODO BA-FS26 just for testing - return 0; - } - - auto ext2_filesystem::lookup(kstd::shared_ptr const & /*parent*/, std::string_view name) - -> kstd::shared_ptr - { - // TODO BA-FS26 implement ext2 directory traversal and inode loading - if (name == "dev") - { - // TODO BA-FS26 just for testing - return nullptr; - } - - return kstd::make_shared(); - } -} // namespace kernel::filesystem::ext2 diff --git a/kernel/src/filesystem/ext2/ext2_inode.cpp b/kernel/src/filesystem/ext2/ext2_inode.cpp deleted file mode 100644 index 142502e..0000000 --- a/kernel/src/filesystem/ext2/ext2_inode.cpp +++ /dev/null @@ -1,24 +0,0 @@ -#include "kernel/filesystem/ext2/ext2_inode.hpp" - -#include "kernel/filesystem/inode.hpp" - -#include - -namespace kernel::filesystem::ext2 -{ - ext2_inode::ext2_inode() - : inode(inode_kind::regular) - {} - - auto ext2_inode::read(void * /*buffer*/, size_t /*offset*/, size_t /*size*/) const -> size_t - { - // TODO BA-FS26 implement - return 0; - } - - auto ext2_inode::write(void const * /*buffer*/, size_t /*offset*/, size_t /*size*/) -> size_t - { - // TODO BA-FS26 implement - return 0; - } -} // namespace kernel::filesystem::ext2 \ No newline at end of file diff --git a/kernel/src/filesystem/ext2/filesystem.cpp b/kernel/src/filesystem/ext2/filesystem.cpp new file mode 100644 index 0000000..d951158 --- /dev/null +++ b/kernel/src/filesystem/ext2/filesystem.cpp @@ -0,0 +1,72 @@ +#include "kernel/filesystem/ext2/filesystem.hpp" + +#include "kernel/devices/block_device_utils.hpp" +#include "kernel/devices/device.hpp" +#include "kernel/filesystem/ext2/inode.hpp" +#include "kernel/filesystem/ext2/superblock.hpp" +#include "kernel/filesystem/filesystem.hpp" +#include "kernel/filesystem/inode.hpp" + +#include + +#include +#include +#include + +namespace kernel::filesystem::ext2 +{ + namespace + { + // constexpr size_t SUPERBLOCK_OFFSET = 1024; + // constexpr uint16_t EXT2_MAGIC = 0xEF53; + + // // Mode bits + // constexpr uint16_t S_IFMT = 0xF000; + // constexpr uint16_t S_IFREG = 0x8000; + // constexpr uint16_t S_IFDIR = 0x4000; + + // auto S_ISREG(uint16_t mode) -> bool + // { + // return (mode & S_IFMT) == S_IFREG; + // } + // auto S_ISDIR(uint16_t mode) -> bool + // { + // return (mode & S_IFMT) == S_IFDIR; + // } + + // auto get_block_size(superblock const & superblock) -> size_t + // { + // return 1024U << superblock.log_block_size; + // } + + // auto get_inode_size(superblock const & superblock) -> size_t + // { + // return superblock.rev_level == 0 ? 128 : superblock.inode_size; + // } + } // namespace + + auto filesystem::mount(kstd::shared_ptr const & device) -> int + { + kernel::filesystem::filesystem::mount(device); // TODO BA-FS26 error handling? + // TODO BA-FS26 load proper root inode from ext2 metadata + // m_root_inode = inode{inode_kind::directory}; + + // TODO BA-FS26 implement + m_root_inode = kstd::make_shared(); + // devices::block_device_utils::read(device, nullptr, 0, 0); // TODO BA-FS26 just for testing + return 0; + } + + auto filesystem::lookup(kstd::shared_ptr const & /*parent*/, std::string_view name) + -> kstd::shared_ptr + { + // TODO BA-FS26 implement ext2 directory traversal and inode loading + if (name == "dev") + { + // TODO BA-FS26 just for testing + return nullptr; + } + + return kstd::make_shared(); + } +} // namespace kernel::filesystem::ext2 diff --git a/kernel/src/filesystem/ext2/inode.cpp b/kernel/src/filesystem/ext2/inode.cpp new file mode 100644 index 0000000..b75969a --- /dev/null +++ b/kernel/src/filesystem/ext2/inode.cpp @@ -0,0 +1,24 @@ +#include "kernel/filesystem/ext2/inode.hpp" + +#include "kernel/filesystem/inode.hpp" + +#include + +namespace kernel::filesystem::ext2 +{ + inode::inode() + : kernel::filesystem::inode(inode_kind::regular) + {} + + auto inode::read(void * /*buffer*/, size_t /*offset*/, size_t /*size*/) const -> size_t + { + // TODO BA-FS26 implement + return 0; + } + + auto inode::write(void const * /*buffer*/, size_t /*offset*/, size_t /*size*/) -> size_t + { + // TODO BA-FS26 implement + return 0; + } +} // namespace kernel::filesystem::ext2 \ No newline at end of file -- cgit v1.2.3 From 9e85f9d1f34d08213a918d9c1b0845c179e323af Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Tue, 31 Mar 2026 08:56:17 +0200 Subject: move device into kapi --- kernel/src/filesystem/ext2/filesystem.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/filesystem.cpp b/kernel/src/filesystem/ext2/filesystem.cpp index d951158..eb9edc4 100644 --- a/kernel/src/filesystem/ext2/filesystem.cpp +++ b/kernel/src/filesystem/ext2/filesystem.cpp @@ -1,7 +1,7 @@ #include "kernel/filesystem/ext2/filesystem.hpp" #include "kernel/devices/block_device_utils.hpp" -#include "kernel/devices/device.hpp" +#include "kapi/devices/device.hpp" #include "kernel/filesystem/ext2/inode.hpp" #include "kernel/filesystem/ext2/superblock.hpp" #include "kernel/filesystem/filesystem.hpp" @@ -45,7 +45,7 @@ namespace kernel::filesystem::ext2 // } } // namespace - auto filesystem::mount(kstd::shared_ptr const & device) -> int + auto filesystem::mount(kstd::shared_ptr const & device) -> int { kernel::filesystem::filesystem::mount(device); // TODO BA-FS26 error handling? // TODO BA-FS26 load proper root inode from ext2 metadata -- cgit v1.2.3 From 93bca4c2a7c1852fc89df6965c835a7dbbdd6512 Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Thu, 2 Apr 2026 09:50:14 +0200 Subject: read ext2 superblock and check the magic number --- kernel/src/filesystem/ext2/filesystem.cpp | 66 +++++++++++++++++-------------- 1 file changed, 37 insertions(+), 29 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/filesystem.cpp b/kernel/src/filesystem/ext2/filesystem.cpp index eb9edc4..a3425b5 100644 --- a/kernel/src/filesystem/ext2/filesystem.cpp +++ b/kernel/src/filesystem/ext2/filesystem.cpp @@ -1,10 +1,10 @@ #include "kernel/filesystem/ext2/filesystem.hpp" -#include "kernel/devices/block_device_utils.hpp" #include "kapi/devices/device.hpp" + +#include "kernel/devices/block_device_utils.hpp" #include "kernel/filesystem/ext2/inode.hpp" #include "kernel/filesystem/ext2/superblock.hpp" -#include "kernel/filesystem/filesystem.hpp" #include "kernel/filesystem/inode.hpp" #include @@ -17,37 +17,35 @@ namespace kernel::filesystem::ext2 { namespace { - // constexpr size_t SUPERBLOCK_OFFSET = 1024; - // constexpr uint16_t EXT2_MAGIC = 0xEF53; - - // // Mode bits - // constexpr uint16_t S_IFMT = 0xF000; - // constexpr uint16_t S_IFREG = 0x8000; - // constexpr uint16_t S_IFDIR = 0x4000; - - // auto S_ISREG(uint16_t mode) -> bool - // { - // return (mode & S_IFMT) == S_IFREG; - // } - // auto S_ISDIR(uint16_t mode) -> bool - // { - // return (mode & S_IFMT) == S_IFDIR; - // } - - // auto get_block_size(superblock const & superblock) -> size_t - // { - // return 1024U << superblock.log_block_size; - // } - - // auto get_inode_size(superblock const & superblock) -> size_t - // { - // return superblock.rev_level == 0 ? 128 : superblock.inode_size; - // } + constexpr size_t SUPERBLOCK_OFFSET = 1024; + constexpr uint16_t EXT2_MAGIC = 0xEF53; + + // Mode bits + constexpr uint16_t S_IFMT = 0xF000; + constexpr uint16_t S_IFREG = 0x8000; + constexpr uint16_t S_IFDIR = 0x4000; + + auto S_ISREG(uint16_t mode) -> bool + { + return (mode & S_IFMT) == S_IFREG; + } + auto S_ISDIR(uint16_t mode) -> bool + { + return (mode & S_IFMT) == S_IFDIR; + } } // namespace auto filesystem::mount(kstd::shared_ptr const & device) -> int { - kernel::filesystem::filesystem::mount(device); // TODO BA-FS26 error handling? + m_device = device; + + kernel::devices::block_device_utils::read(m_device, &m_superblock, SUPERBLOCK_OFFSET, sizeof(m_superblock)); + + if (m_superblock.magic != EXT2_MAGIC) + { + return -1; + } + // TODO BA-FS26 load proper root inode from ext2 metadata // m_root_inode = inode{inode_kind::directory}; @@ -69,4 +67,14 @@ namespace kernel::filesystem::ext2 return kstd::make_shared(); } + + auto filesystem::get_block_size() -> size_t + { + return 1024U << m_superblock.log_block_size; + } + + auto filesystem::get_inode_size() -> size_t + { + return m_superblock.rev_level == 0 ? 128 : m_superblock.inode_size; + } } // namespace kernel::filesystem::ext2 -- cgit v1.2.3 From 1dcf253fdf8169a3b2b71bfac68f2f25951af1a8 Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Thu, 2 Apr 2026 10:04:04 +0200 Subject: fix build, refactoring --- kernel/src/filesystem/ext2/filesystem.cpp | 27 ++++++++++++++------------- 1 file changed, 14 insertions(+), 13 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/filesystem.cpp b/kernel/src/filesystem/ext2/filesystem.cpp index a3425b5..0ebb243 100644 --- a/kernel/src/filesystem/ext2/filesystem.cpp +++ b/kernel/src/filesystem/ext2/filesystem.cpp @@ -5,6 +5,7 @@ #include "kernel/devices/block_device_utils.hpp" #include "kernel/filesystem/ext2/inode.hpp" #include "kernel/filesystem/ext2/superblock.hpp" +#include "kernel/filesystem/filesystem.hpp" #include "kernel/filesystem/inode.hpp" #include @@ -21,23 +22,23 @@ namespace kernel::filesystem::ext2 constexpr uint16_t EXT2_MAGIC = 0xEF53; // Mode bits - constexpr uint16_t S_IFMT = 0xF000; - constexpr uint16_t S_IFREG = 0x8000; - constexpr uint16_t S_IFDIR = 0x4000; - - auto S_ISREG(uint16_t mode) -> bool - { - return (mode & S_IFMT) == S_IFREG; - } - auto S_ISDIR(uint16_t mode) -> bool - { - return (mode & S_IFMT) == S_IFDIR; - } + // constexpr uint16_t S_IFMT = 0xF000; + // constexpr uint16_t S_IFREG = 0x8000; + // constexpr uint16_t S_IFDIR = 0x4000; + + // auto S_ISREG(uint16_t mode) -> bool + // { + // return (mode & S_IFMT) == S_IFREG; + // } + // auto S_ISDIR(uint16_t mode) -> bool + // { + // return (mode & S_IFMT) == S_IFDIR; + // } } // namespace auto filesystem::mount(kstd::shared_ptr const & device) -> int { - m_device = device; + kernel::filesystem::filesystem::mount(device); kernel::devices::block_device_utils::read(m_device, &m_superblock, SUPERBLOCK_OFFSET, sizeof(m_superblock)); -- cgit v1.2.3 From 16b854e991bb791694268d09eb696c719cdff42f Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Thu, 2 Apr 2026 11:09:13 +0200 Subject: read block_group_descriptors --- kernel/src/filesystem/ext2/filesystem.cpp | 13 +++++++++++++ 1 file changed, 13 insertions(+) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/filesystem.cpp b/kernel/src/filesystem/ext2/filesystem.cpp index 0ebb243..96c1589 100644 --- a/kernel/src/filesystem/ext2/filesystem.cpp +++ b/kernel/src/filesystem/ext2/filesystem.cpp @@ -3,12 +3,14 @@ #include "kapi/devices/device.hpp" #include "kernel/devices/block_device_utils.hpp" +#include "kernel/filesystem/ext2/block_group_descriptor.hpp" #include "kernel/filesystem/ext2/inode.hpp" #include "kernel/filesystem/ext2/superblock.hpp" #include "kernel/filesystem/filesystem.hpp" #include "kernel/filesystem/inode.hpp" #include +#include #include #include @@ -47,6 +49,17 @@ namespace kernel::filesystem::ext2 return -1; } + auto const block_size = get_block_size(); + auto const blocks_per_group = m_superblock.blocks_per_group; + auto const num_block_groups = (m_superblock.blocks_count + blocks_per_group - 1) / blocks_per_group; + + m_block_group_descriptors = kstd::vector(num_block_groups); + + auto const block_group_descriptor_table_offset = block_size == 1024 ? 2 * block_size : block_size; + kernel::devices::block_device_utils::read(m_device, m_block_group_descriptors.data(), + block_group_descriptor_table_offset, + num_block_groups * sizeof(block_group_descriptor)); + // TODO BA-FS26 load proper root inode from ext2 metadata // m_root_inode = inode{inode_kind::directory}; -- cgit v1.2.3 From baf63039d5430c0b3b1e6235b561c12f60e97f49 Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Thu, 2 Apr 2026 15:03:06 +0200 Subject: implement read_inode --- kernel/src/filesystem/ext2/filesystem.cpp | 35 ++++++++++++++++++++++++------- 1 file changed, 27 insertions(+), 8 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/filesystem.cpp b/kernel/src/filesystem/ext2/filesystem.cpp index 96c1589..d650e97 100644 --- a/kernel/src/filesystem/ext2/filesystem.cpp +++ b/kernel/src/filesystem/ext2/filesystem.cpp @@ -21,7 +21,9 @@ namespace kernel::filesystem::ext2 namespace { constexpr size_t SUPERBLOCK_OFFSET = 1024; - constexpr uint16_t EXT2_MAGIC = 0xEF53; + constexpr uint16_t MAGIC_NUMBER = 0xEF53; + + constexpr uint32_t ROOT_INODE_NUMBER = 2; // Mode bits // constexpr uint16_t S_IFMT = 0xF000; @@ -44,7 +46,7 @@ namespace kernel::filesystem::ext2 kernel::devices::block_device_utils::read(m_device, &m_superblock, SUPERBLOCK_OFFSET, sizeof(m_superblock)); - if (m_superblock.magic != EXT2_MAGIC) + if (m_superblock.magic != MAGIC_NUMBER) { return -1; } @@ -60,12 +62,7 @@ namespace kernel::filesystem::ext2 block_group_descriptor_table_offset, num_block_groups * sizeof(block_group_descriptor)); - // TODO BA-FS26 load proper root inode from ext2 metadata - // m_root_inode = inode{inode_kind::directory}; - - // TODO BA-FS26 implement - m_root_inode = kstd::make_shared(); - // devices::block_device_utils::read(device, nullptr, 0, 0); // TODO BA-FS26 just for testing + m_root_inode = read_inode(ROOT_INODE_NUMBER); return 0; } @@ -82,6 +79,28 @@ namespace kernel::filesystem::ext2 return kstd::make_shared(); } + auto filesystem::read_inode(uint32_t inode_number) -> kstd::shared_ptr + { + auto const block_size = get_block_size(); + auto const inodes_per_group = m_superblock.inodes_per_group; + auto const block_group_index = (inode_number - 1) / inodes_per_group; + auto const inode_index_within_group = (inode_number - 1) % inodes_per_group; + + if (block_group_index >= m_block_group_descriptors.size()) + { + return nullptr; + } + + auto const & block_group_descriptor = m_block_group_descriptors.at(block_group_index); + auto const inode_table_start_block = block_group_descriptor.inode_table; + auto const inode_table_offset = static_cast(inode_table_start_block) * block_size; + auto const inode_offset = inode_table_offset + inode_index_within_group * get_inode_size(); + + auto new_inode = kstd::make_shared(); + kernel::devices::block_device_utils::read(m_device, &new_inode->m_data, inode_offset, sizeof(inode_data)); + return new_inode; + } + auto filesystem::get_block_size() -> size_t { return 1024U << m_superblock.log_block_size; -- cgit v1.2.3 From 794de4a7f8dbea164d857ae9e4525536f338518d Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Thu, 2 Apr 2026 16:06:40 +0200 Subject: temporary implementation of inode kind --- kernel/src/filesystem/ext2/filesystem.cpp | 41 ++++++++++++++++++++++--------- 1 file changed, 29 insertions(+), 12 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/filesystem.cpp b/kernel/src/filesystem/ext2/filesystem.cpp index d650e97..31dc6f2 100644 --- a/kernel/src/filesystem/ext2/filesystem.cpp +++ b/kernel/src/filesystem/ext2/filesystem.cpp @@ -26,18 +26,18 @@ namespace kernel::filesystem::ext2 constexpr uint32_t ROOT_INODE_NUMBER = 2; // Mode bits - // constexpr uint16_t S_IFMT = 0xF000; - // constexpr uint16_t S_IFREG = 0x8000; - // constexpr uint16_t S_IFDIR = 0x4000; - - // auto S_ISREG(uint16_t mode) -> bool - // { - // return (mode & S_IFMT) == S_IFREG; - // } - // auto S_ISDIR(uint16_t mode) -> bool - // { - // return (mode & S_IFMT) == S_IFDIR; - // } + constexpr uint16_t S_IFMT = 0xF000; + constexpr uint16_t S_IFREG = 0x8000; + constexpr uint16_t S_IFDIR = 0x4000; + + auto S_ISREG(uint16_t mode) -> bool + { + return (mode & S_IFMT) == S_IFREG; + } + auto S_ISDIR(uint16_t mode) -> bool + { + return (mode & S_IFMT) == S_IFDIR; + } } // namespace auto filesystem::mount(kstd::shared_ptr const & device) -> int @@ -63,6 +63,7 @@ namespace kernel::filesystem::ext2 num_block_groups * sizeof(block_group_descriptor)); m_root_inode = read_inode(ROOT_INODE_NUMBER); + // TODO BA-FS26 check if root inode is valid and is a directory ?? return 0; } @@ -98,6 +99,22 @@ namespace kernel::filesystem::ext2 auto new_inode = kstd::make_shared(); kernel::devices::block_device_utils::read(m_device, &new_inode->m_data, inode_offset, sizeof(inode_data)); + + // TODO BA-FS26 improve inode_kind really needed? or just map it to the mode bits? + if (S_ISREG(new_inode->m_data.mode)) + { + new_inode->m_kind = inode::inode_kind::regular; + } + else if (S_ISDIR(new_inode->m_data.mode)) + { + new_inode->m_kind = inode::inode_kind::directory; + } + else + { + // TODO BA-FS26 really correct?? + return nullptr; + } + return new_inode; } -- cgit v1.2.3 From 82c8a4c16e3af3d62d7211e741b051da900de79c Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Fri, 3 Apr 2026 10:16:36 +0200 Subject: first lookup draft --- kernel/src/filesystem/ext2/filesystem.cpp | 48 ++++++++++++++++++++++++++++++- 1 file changed, 47 insertions(+), 1 deletion(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/filesystem.cpp b/kernel/src/filesystem/ext2/filesystem.cpp index 31dc6f2..82fcba9 100644 --- a/kernel/src/filesystem/ext2/filesystem.cpp +++ b/kernel/src/filesystem/ext2/filesystem.cpp @@ -5,11 +5,13 @@ #include "kernel/devices/block_device_utils.hpp" #include "kernel/filesystem/ext2/block_group_descriptor.hpp" #include "kernel/filesystem/ext2/inode.hpp" +#include "kernel/filesystem/ext2/linked_directory_entry.hpp" #include "kernel/filesystem/ext2/superblock.hpp" #include "kernel/filesystem/filesystem.hpp" #include "kernel/filesystem/inode.hpp" #include +#include #include #include @@ -24,6 +26,7 @@ namespace kernel::filesystem::ext2 constexpr uint16_t MAGIC_NUMBER = 0xEF53; constexpr uint32_t ROOT_INODE_NUMBER = 2; + constexpr size_t DIRECT_BLOCK_COUNT = 12; // Mode bits constexpr uint16_t S_IFMT = 0xF000; @@ -67,9 +70,52 @@ namespace kernel::filesystem::ext2 return 0; } - auto filesystem::lookup(kstd::shared_ptr const & /*parent*/, std::string_view name) + auto filesystem::lookup(kstd::shared_ptr const & parent, std::string_view name) -> kstd::shared_ptr { + if (!parent || !parent->is_directory()) + { + return nullptr; + } + + auto * ext2_parent = static_cast(parent.get()); + if (!ext2_parent) + { + return nullptr; + } + + auto const block_size = get_block_size(); + auto const & inode_data = ext2_parent->m_data; + kstd::vector buffer(block_size); + + for (size_t i = 0; i < DIRECT_BLOCK_COUNT && inode_data.block[i] != 0; ++i) + { + kernel::devices::block_device_utils::read(m_device, buffer.data(), inode_data.block[i] * block_size, block_size); + + size_t offset = 0; + while (offset < block_size) + { + auto * entry = reinterpret_cast(buffer.data() + offset); + if (entry->inode == 0) + break; + + // Stop if the directory entry is malformed to avoid overruns/loops. + // if (entry->rec_len < sizeof(linked_directory_entry) || offset + entry->rec_len > block_size) + // { + // break; + // } + + std::string_view entry_name(reinterpret_cast(entry->name.data()), entry->name_len); + if (entry_name == name) + { + return read_inode(entry->inode); + } + + offset += entry->rec_len; + } + } + + return nullptr; // TODO BA-FS26 implement ext2 directory traversal and inode loading if (name == "dev") { -- cgit v1.2.3 From 7e6137b2725d5cf2b16f55678dcfb99091f03fe9 Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Fri, 3 Apr 2026 14:30:20 +0200 Subject: implement map_inode_block_index_to_global_block_number and lookup --- kernel/src/filesystem/ext2/filesystem.cpp | 120 ++++++++++++++++++++++++------ 1 file changed, 96 insertions(+), 24 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/filesystem.cpp b/kernel/src/filesystem/ext2/filesystem.cpp index 82fcba9..a84414f 100644 --- a/kernel/src/filesystem/ext2/filesystem.cpp +++ b/kernel/src/filesystem/ext2/filesystem.cpp @@ -11,6 +11,7 @@ #include "kernel/filesystem/inode.hpp" #include +#include #include #include @@ -26,7 +27,11 @@ namespace kernel::filesystem::ext2 constexpr uint16_t MAGIC_NUMBER = 0xEF53; constexpr uint32_t ROOT_INODE_NUMBER = 2; + constexpr size_t DIRECT_BLOCK_COUNT = 12; + constexpr size_t INDIRECT_BLOCK_INDEX = DIRECT_BLOCK_COUNT; + constexpr size_t DOUBLY_INDIRECT_BLOCK_INDEX = INDIRECT_BLOCK_INDEX + 1; + constexpr size_t TRIPLY_INDIRECT_BLOCK_INDEX = DOUBLY_INDIRECT_BLOCK_INDEX + 1; // Mode bits constexpr uint16_t S_IFMT = 0xF000; @@ -37,6 +42,7 @@ namespace kernel::filesystem::ext2 { return (mode & S_IFMT) == S_IFREG; } + auto S_ISDIR(uint16_t mode) -> bool { return (mode & S_IFMT) == S_IFDIR; @@ -88,42 +94,29 @@ namespace kernel::filesystem::ext2 auto const & inode_data = ext2_parent->m_data; kstd::vector buffer(block_size); - for (size_t i = 0; i < DIRECT_BLOCK_COUNT && inode_data.block[i] != 0; ++i) + for (uint32_t i = 0; i < get_inode_block_count(inode_data); ++i) { - kernel::devices::block_device_utils::read(m_device, buffer.data(), inode_data.block[i] * block_size, block_size); - - size_t offset = 0; - while (offset < block_size) - { - auto * entry = reinterpret_cast(buffer.data() + offset); - if (entry->inode == 0) - break; + auto const global_block_number = map_inode_block_index_to_global_block_number(i, inode_data); + auto const block_offset = global_block_number * block_size; + kernel::devices::block_device_utils::read(m_device, buffer.data(), block_offset, block_size); - // Stop if the directory entry is malformed to avoid overruns/loops. - // if (entry->rec_len < sizeof(linked_directory_entry) || offset + entry->rec_len > block_size) - // { - // break; - // } + auto const * entry = reinterpret_cast(buffer.data()); + auto bytes_read = 0uz; - std::string_view entry_name(reinterpret_cast(entry->name.data()), entry->name_len); + while (bytes_read < block_size && entry->inode != 0) + { + auto const entry_name = std::string_view{entry->name.data(), entry->name_len}; if (entry_name == name) { return read_inode(entry->inode); } - offset += entry->rec_len; + bytes_read += entry->rec_len; + entry = reinterpret_cast(buffer.data() + bytes_read); } } return nullptr; - // TODO BA-FS26 implement ext2 directory traversal and inode loading - if (name == "dev") - { - // TODO BA-FS26 just for testing - return nullptr; - } - - return kstd::make_shared(); } auto filesystem::read_inode(uint32_t inode_number) -> kstd::shared_ptr @@ -164,6 +157,80 @@ namespace kernel::filesystem::ext2 return new_inode; } + auto filesystem::map_inode_block_index_to_global_block_number(uint32_t inode_block_index, inode_data data) -> uint32_t + { + if (inode_block_index < DIRECT_BLOCK_COUNT) + { + return data.block.at(inode_block_index); + } + inode_block_index -= DIRECT_BLOCK_COUNT; + + auto const block_size = get_block_size(); + auto const numbers_per_block = block_size / sizeof(uint32_t); + uint32_t block_number_buffer = 0; + + auto const number_of_singly_indirect_blocks = numbers_per_block; + if (inode_block_index < number_of_singly_indirect_blocks) + { + auto const indirect_block_start_offset = data.block.at(INDIRECT_BLOCK_INDEX) * block_size; + auto const direct_block_number_index = inode_block_index; + auto const direct_block_number_offset = + indirect_block_start_offset + direct_block_number_index * sizeof(uint32_t); + kernel::devices::block_device_utils::read(m_device, &block_number_buffer, direct_block_number_offset, + sizeof(uint32_t)); + return block_number_buffer; + } + inode_block_index -= number_of_singly_indirect_blocks; + + auto const number_of_doubly_indirect_blocks = numbers_per_block * numbers_per_block; + if (inode_block_index < number_of_doubly_indirect_blocks) + { + auto const doubly_indirect_block_start_offset = data.block.at(DOUBLY_INDIRECT_BLOCK_INDEX) * block_size; + auto const indirect_block_number_index = inode_block_index / numbers_per_block; + auto const indirect_block_number_offset = + doubly_indirect_block_start_offset + indirect_block_number_index * sizeof(uint32_t); + kernel::devices::block_device_utils::read(m_device, &block_number_buffer, indirect_block_number_offset, + sizeof(uint32_t)); + + auto const indirect_block_start_offset = block_number_buffer * block_size; + auto const direct_block_number_index = inode_block_index % numbers_per_block; + auto const direct_block_number_offset = + indirect_block_start_offset + direct_block_number_index * sizeof(uint32_t); + kernel::devices::block_device_utils::read(m_device, &block_number_buffer, direct_block_number_offset, + sizeof(uint32_t)); + return block_number_buffer; + } + inode_block_index -= number_of_doubly_indirect_blocks; + + auto const number_of_triply_indirect_blocks = numbers_per_block * numbers_per_block * numbers_per_block; + if (inode_block_index < number_of_triply_indirect_blocks) + { + auto const triply_indirect_block_start_offset = data.block.at(TRIPLY_INDIRECT_BLOCK_INDEX) * block_size; + auto const doubly_indirect_block_number_index = inode_block_index / (numbers_per_block * numbers_per_block); + auto const doubly_indirect_block_number_offset = + triply_indirect_block_start_offset + doubly_indirect_block_number_index * sizeof(uint32_t); + kernel::devices::block_device_utils::read(m_device, &block_number_buffer, doubly_indirect_block_number_offset, + sizeof(uint32_t)); + + auto const doubly_indirect_block_start_offset = block_number_buffer * block_size; + auto const indirect_block_number_index = (inode_block_index / numbers_per_block) % numbers_per_block; + auto const indirect_block_number_offset = + doubly_indirect_block_start_offset + indirect_block_number_index * sizeof(uint32_t); + kernel::devices::block_device_utils::read(m_device, &block_number_buffer, indirect_block_number_offset, + sizeof(uint32_t)); + + auto const indirect_block_start_offset = block_number_buffer * block_size; + auto const direct_block_number_index = inode_block_index % numbers_per_block; + auto const direct_block_number_offset = + indirect_block_start_offset + direct_block_number_index * sizeof(uint32_t); + kernel::devices::block_device_utils::read(m_device, &block_number_buffer, direct_block_number_offset, + sizeof(uint32_t)); + return block_number_buffer; + } + + return 0; // TODO BA-FS26 really correct?? + } + auto filesystem::get_block_size() -> size_t { return 1024U << m_superblock.log_block_size; @@ -173,4 +240,9 @@ namespace kernel::filesystem::ext2 { return m_superblock.rev_level == 0 ? 128 : m_superblock.inode_size; } + + auto filesystem::get_inode_block_count(inode_data const & data) -> uint32_t + { + return data.blocks / (2 << m_superblock.log_block_size); + } } // namespace kernel::filesystem::ext2 -- cgit v1.2.3 From fe8706422605e466427ae2727ddb98ce5cd984f6 Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Fri, 3 Apr 2026 15:38:16 +0200 Subject: refactoring map_inode_block_index_to_global_block_number --- kernel/src/filesystem/ext2/filesystem.cpp | 101 ++++++++++++++---------------- 1 file changed, 48 insertions(+), 53 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/filesystem.cpp b/kernel/src/filesystem/ext2/filesystem.cpp index a84414f..56c0b88 100644 --- a/kernel/src/filesystem/ext2/filesystem.cpp +++ b/kernel/src/filesystem/ext2/filesystem.cpp @@ -29,8 +29,8 @@ namespace kernel::filesystem::ext2 constexpr uint32_t ROOT_INODE_NUMBER = 2; constexpr size_t DIRECT_BLOCK_COUNT = 12; - constexpr size_t INDIRECT_BLOCK_INDEX = DIRECT_BLOCK_COUNT; - constexpr size_t DOUBLY_INDIRECT_BLOCK_INDEX = INDIRECT_BLOCK_INDEX + 1; + constexpr size_t SINGLY_INDIRECT_BLOCK_INDEX = DIRECT_BLOCK_COUNT; + constexpr size_t DOUBLY_INDIRECT_BLOCK_INDEX = SINGLY_INDIRECT_BLOCK_INDEX + 1; constexpr size_t TRIPLY_INDIRECT_BLOCK_INDEX = DOUBLY_INDIRECT_BLOCK_INDEX + 1; // Mode bits @@ -167,70 +167,65 @@ namespace kernel::filesystem::ext2 auto const block_size = get_block_size(); auto const numbers_per_block = block_size / sizeof(uint32_t); - uint32_t block_number_buffer = 0; - auto const number_of_singly_indirect_blocks = numbers_per_block; - if (inode_block_index < number_of_singly_indirect_blocks) + auto const block_numbers_per_singly_indirect_block = numbers_per_block; + auto const block_numbers_per_doubly_indirect_block = numbers_per_block * block_numbers_per_singly_indirect_block; + auto const block_numbers_per_triply_indirect_block = numbers_per_block * block_numbers_per_doubly_indirect_block; + + if (inode_block_index < block_numbers_per_singly_indirect_block) { - auto const indirect_block_start_offset = data.block.at(INDIRECT_BLOCK_INDEX) * block_size; - auto const direct_block_number_index = inode_block_index; - auto const direct_block_number_offset = - indirect_block_start_offset + direct_block_number_index * sizeof(uint32_t); - kernel::devices::block_device_utils::read(m_device, &block_number_buffer, direct_block_number_offset, - sizeof(uint32_t)); - return block_number_buffer; + auto const singly_indirect_block_number = data.block.at(SINGLY_INDIRECT_BLOCK_INDEX); + return read_block_number_at_index(singly_indirect_block_number, inode_block_index); } - inode_block_index -= number_of_singly_indirect_blocks; + inode_block_index -= block_numbers_per_singly_indirect_block; - auto const number_of_doubly_indirect_blocks = numbers_per_block * numbers_per_block; - if (inode_block_index < number_of_doubly_indirect_blocks) + if (inode_block_index < block_numbers_per_doubly_indirect_block) { - auto const doubly_indirect_block_start_offset = data.block.at(DOUBLY_INDIRECT_BLOCK_INDEX) * block_size; - auto const indirect_block_number_index = inode_block_index / numbers_per_block; - auto const indirect_block_number_offset = - doubly_indirect_block_start_offset + indirect_block_number_index * sizeof(uint32_t); - kernel::devices::block_device_utils::read(m_device, &block_number_buffer, indirect_block_number_offset, - sizeof(uint32_t)); - - auto const indirect_block_start_offset = block_number_buffer * block_size; - auto const direct_block_number_index = inode_block_index % numbers_per_block; - auto const direct_block_number_offset = - indirect_block_start_offset + direct_block_number_index * sizeof(uint32_t); - kernel::devices::block_device_utils::read(m_device, &block_number_buffer, direct_block_number_offset, - sizeof(uint32_t)); - return block_number_buffer; + auto const doubly_indirect_block_number = data.block.at(DOUBLY_INDIRECT_BLOCK_INDEX); + auto const singly_indirect_block_index_in_doubly_indirect_block = + inode_block_index / block_numbers_per_singly_indirect_block; + auto const singly_indirect_block_number = read_block_number_at_index( + doubly_indirect_block_number, singly_indirect_block_index_in_doubly_indirect_block); + + auto const block_index_in_singly_indirect_block = inode_block_index % block_numbers_per_singly_indirect_block; + return read_block_number_at_index(singly_indirect_block_number, block_index_in_singly_indirect_block); } - inode_block_index -= number_of_doubly_indirect_blocks; + inode_block_index -= block_numbers_per_doubly_indirect_block; - auto const number_of_triply_indirect_blocks = numbers_per_block * numbers_per_block * numbers_per_block; - if (inode_block_index < number_of_triply_indirect_blocks) + if (inode_block_index < block_numbers_per_triply_indirect_block) { - auto const triply_indirect_block_start_offset = data.block.at(TRIPLY_INDIRECT_BLOCK_INDEX) * block_size; - auto const doubly_indirect_block_number_index = inode_block_index / (numbers_per_block * numbers_per_block); - auto const doubly_indirect_block_number_offset = - triply_indirect_block_start_offset + doubly_indirect_block_number_index * sizeof(uint32_t); - kernel::devices::block_device_utils::read(m_device, &block_number_buffer, doubly_indirect_block_number_offset, - sizeof(uint32_t)); - - auto const doubly_indirect_block_start_offset = block_number_buffer * block_size; - auto const indirect_block_number_index = (inode_block_index / numbers_per_block) % numbers_per_block; - auto const indirect_block_number_offset = - doubly_indirect_block_start_offset + indirect_block_number_index * sizeof(uint32_t); - kernel::devices::block_device_utils::read(m_device, &block_number_buffer, indirect_block_number_offset, - sizeof(uint32_t)); - - auto const indirect_block_start_offset = block_number_buffer * block_size; - auto const direct_block_number_index = inode_block_index % numbers_per_block; - auto const direct_block_number_offset = - indirect_block_start_offset + direct_block_number_index * sizeof(uint32_t); - kernel::devices::block_device_utils::read(m_device, &block_number_buffer, direct_block_number_offset, - sizeof(uint32_t)); - return block_number_buffer; + auto const triply_indirect_block_number = data.block.at(TRIPLY_INDIRECT_BLOCK_INDEX); + auto const doubly_indirect_block_index_in_triply_indirect_block = + inode_block_index / block_numbers_per_doubly_indirect_block; + auto const doubly_indirect_block_number = read_block_number_at_index( + triply_indirect_block_number, doubly_indirect_block_index_in_triply_indirect_block); + + auto const remaining_block_numbers = inode_block_index % block_numbers_per_doubly_indirect_block; + + auto const singly_indirect_block_index_in_doubly_indirect_block = + remaining_block_numbers / block_numbers_per_singly_indirect_block; + auto const singly_indirect_block_number = read_block_number_at_index( + doubly_indirect_block_number, singly_indirect_block_index_in_doubly_indirect_block); + + auto const block_index_in_singly_indirect_block = + remaining_block_numbers % block_numbers_per_singly_indirect_block; + return read_block_number_at_index(singly_indirect_block_number, block_index_in_singly_indirect_block); } return 0; // TODO BA-FS26 really correct?? } + auto filesystem::read_block_number_at_index(uint32_t block_number, uint32_t index) -> uint32_t + { + uint32_t block_number_buffer = 0; + + auto const block_start_offset = block_number * get_block_size(); + auto const number_start_address = block_start_offset + index * sizeof(uint32_t); + kernel::devices::block_device_utils::read(m_device, &block_number_buffer, number_start_address, sizeof(uint32_t)); + + return block_number_buffer; + } + auto filesystem::get_block_size() -> size_t { return 1024U << m_superblock.log_block_size; -- cgit v1.2.3 From 725116d22e850c502e6cb8d42b100da1080dfec0 Mon Sep 17 00:00:00 2001 From: Marcel Braun Date: Mon, 6 Apr 2026 10:35:45 +0200 Subject: Add file system pointer to ext2 inode --- kernel/src/filesystem/ext2/filesystem.cpp | 2 +- kernel/src/filesystem/ext2/inode.cpp | 12 ++++++++++-- 2 files changed, 11 insertions(+), 3 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/filesystem.cpp b/kernel/src/filesystem/ext2/filesystem.cpp index 56c0b88..514bb59 100644 --- a/kernel/src/filesystem/ext2/filesystem.cpp +++ b/kernel/src/filesystem/ext2/filesystem.cpp @@ -136,7 +136,7 @@ namespace kernel::filesystem::ext2 auto const inode_table_offset = static_cast(inode_table_start_block) * block_size; auto const inode_offset = inode_table_offset + inode_index_within_group * get_inode_size(); - auto new_inode = kstd::make_shared(); + auto new_inode = kstd::make_shared(this); kernel::devices::block_device_utils::read(m_device, &new_inode->m_data, inode_offset, sizeof(inode_data)); // TODO BA-FS26 improve inode_kind really needed? or just map it to the mode bits? diff --git a/kernel/src/filesystem/ext2/inode.cpp b/kernel/src/filesystem/ext2/inode.cpp index b75969a..4d36e66 100644 --- a/kernel/src/filesystem/ext2/inode.cpp +++ b/kernel/src/filesystem/ext2/inode.cpp @@ -1,14 +1,22 @@ #include "kernel/filesystem/ext2/inode.hpp" +#include "kapi/system.hpp" + #include "kernel/filesystem/inode.hpp" #include namespace kernel::filesystem::ext2 { - inode::inode() + inode::inode(filesystem * fs) : kernel::filesystem::inode(inode_kind::regular) - {} + , m_filesystem(fs) + { + if (!m_filesystem) + { + kapi::system::panic("[EXT2] ext2::inode constructed with filesystem null pointer"); + } + } auto inode::read(void * /*buffer*/, size_t /*offset*/, size_t /*size*/) const -> size_t { -- cgit v1.2.3 From 4a2d4fb3ab38a64c4b10832f5a6318b7240829cc Mon Sep 17 00:00:00 2001 From: Marcel Braun Date: Mon, 6 Apr 2026 11:40:12 +0200 Subject: Implement read data in ext2 inode --- kernel/src/filesystem/ext2/inode.cpp | 33 ++++++++++++++++++++++++++++++--- 1 file changed, 30 insertions(+), 3 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/inode.cpp b/kernel/src/filesystem/ext2/inode.cpp index 4d36e66..7f4cf69 100644 --- a/kernel/src/filesystem/ext2/inode.cpp +++ b/kernel/src/filesystem/ext2/inode.cpp @@ -2,9 +2,13 @@ #include "kapi/system.hpp" +#include "kernel/devices/block_device_utils.hpp" +#include "kernel/filesystem/ext2/filesystem.hpp" #include "kernel/filesystem/inode.hpp" +#include #include +#include namespace kernel::filesystem::ext2 { @@ -18,10 +22,33 @@ namespace kernel::filesystem::ext2 } } - auto inode::read(void * /*buffer*/, size_t /*offset*/, size_t /*size*/) const -> size_t + auto inode::read(void * buffer, size_t offset, size_t size) const -> size_t { - // TODO BA-FS26 implement - return 0; + auto block_index = offset / m_filesystem->get_block_size(); + auto in_block_offset = offset % m_filesystem->get_block_size(); + + auto bytes_read = 0uz; + + while (bytes_read < size) + { + auto const block_number = m_filesystem->map_inode_block_index_to_global_block_number(block_index, m_data); + if (block_number == 0) // TODO BA-FS26 really correct? + { + break; + } + + auto const block_start_offset = block_number * m_filesystem->get_block_size(); + auto const read_offset = block_start_offset + in_block_offset; + auto const bytes_to_read = std::min(size - bytes_read, m_filesystem->get_block_size() - in_block_offset); + + bytes_read += kernel::devices::block_device_utils::read( + m_filesystem->device(), static_cast(buffer) + bytes_read, read_offset, bytes_to_read); + + block_index++; + in_block_offset = 0; // After the first block, we always start at the beginning of the block + } + + return bytes_read; } auto inode::write(void const * /*buffer*/, size_t /*offset*/, size_t /*size*/) -> size_t -- cgit v1.2.3 From 2240b9a36e4a9f6f8291c9271e6aac8f5536dbd7 Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Tue, 7 Apr 2026 22:13:49 +0200 Subject: refactoring --- kernel/src/filesystem/ext2/filesystem.cpp | 2 -- 1 file changed, 2 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/filesystem.cpp b/kernel/src/filesystem/ext2/filesystem.cpp index 514bb59..d7c989c 100644 --- a/kernel/src/filesystem/ext2/filesystem.cpp +++ b/kernel/src/filesystem/ext2/filesystem.cpp @@ -11,8 +11,6 @@ #include "kernel/filesystem/inode.hpp" #include -#include -#include #include #include -- cgit v1.2.3 From dd330e7a05905713acfa87ec109956bfe78f78c4 Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Wed, 8 Apr 2026 09:31:32 +0200 Subject: add descriptions, some refactoring --- kernel/src/filesystem/ext2/filesystem.cpp | 12 ++++++++++-- kernel/src/filesystem/ext2/inode.cpp | 2 +- 2 files changed, 11 insertions(+), 3 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/filesystem.cpp b/kernel/src/filesystem/ext2/filesystem.cpp index d7c989c..7ee1072 100644 --- a/kernel/src/filesystem/ext2/filesystem.cpp +++ b/kernel/src/filesystem/ext2/filesystem.cpp @@ -36,6 +36,10 @@ namespace kernel::filesystem::ext2 constexpr uint16_t S_IFREG = 0x8000; constexpr uint16_t S_IFDIR = 0x4000; + // Error codes + constexpr int INVALID_MAGIC_NUMBER = -1; + constexpr int INVALID_ROOT_INODE = -2; + auto S_ISREG(uint16_t mode) -> bool { return (mode & S_IFMT) == S_IFREG; @@ -55,7 +59,7 @@ namespace kernel::filesystem::ext2 if (m_superblock.magic != MAGIC_NUMBER) { - return -1; + return INVALID_MAGIC_NUMBER; } auto const block_size = get_block_size(); @@ -70,7 +74,11 @@ namespace kernel::filesystem::ext2 num_block_groups * sizeof(block_group_descriptor)); m_root_inode = read_inode(ROOT_INODE_NUMBER); - // TODO BA-FS26 check if root inode is valid and is a directory ?? + + if (!m_root_inode || !m_root_inode->is_directory()) + { + return INVALID_ROOT_INODE; + } return 0; } diff --git a/kernel/src/filesystem/ext2/inode.cpp b/kernel/src/filesystem/ext2/inode.cpp index 7f4cf69..a29bb3b 100644 --- a/kernel/src/filesystem/ext2/inode.cpp +++ b/kernel/src/filesystem/ext2/inode.cpp @@ -53,7 +53,7 @@ namespace kernel::filesystem::ext2 auto inode::write(void const * /*buffer*/, size_t /*offset*/, size_t /*size*/) -> size_t { - // TODO BA-FS26 implement + kapi::system::panic("[EXT2] inode::write is not implemented yet"); return 0; } } // namespace kernel::filesystem::ext2 \ No newline at end of file -- cgit v1.2.3 From 2793770dc6eba30b73b4a4993618d2cbe184790e Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Wed, 8 Apr 2026 15:21:10 +0200 Subject: implement unmount, improve error codes --- kernel/src/filesystem/ext2/filesystem.cpp | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/filesystem.cpp b/kernel/src/filesystem/ext2/filesystem.cpp index 7ee1072..6d5960e 100644 --- a/kernel/src/filesystem/ext2/filesystem.cpp +++ b/kernel/src/filesystem/ext2/filesystem.cpp @@ -36,10 +36,6 @@ namespace kernel::filesystem::ext2 constexpr uint16_t S_IFREG = 0x8000; constexpr uint16_t S_IFDIR = 0x4000; - // Error codes - constexpr int INVALID_MAGIC_NUMBER = -1; - constexpr int INVALID_ROOT_INODE = -2; - auto S_ISREG(uint16_t mode) -> bool { return (mode & S_IFMT) == S_IFREG; @@ -51,7 +47,7 @@ namespace kernel::filesystem::ext2 } } // namespace - auto filesystem::mount(kstd::shared_ptr const & device) -> int + auto filesystem::mount(kstd::shared_ptr const & device) -> operation_result { kernel::filesystem::filesystem::mount(device); @@ -59,7 +55,7 @@ namespace kernel::filesystem::ext2 if (m_superblock.magic != MAGIC_NUMBER) { - return INVALID_MAGIC_NUMBER; + return operation_result::invalid_magic_number; } auto const block_size = get_block_size(); @@ -77,9 +73,9 @@ namespace kernel::filesystem::ext2 if (!m_root_inode || !m_root_inode->is_directory()) { - return INVALID_ROOT_INODE; + return operation_result::invalid_root_inode; } - return 0; + return operation_result::success; } auto filesystem::lookup(kstd::shared_ptr const & parent, std::string_view name) -- cgit v1.2.3 From 01d5f1b29fa04c69ac9f942a1075354ce5b25da2 Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Thu, 9 Apr 2026 12:32:50 +0200 Subject: add ext2 inode and filesystem tests --- kernel/src/filesystem/ext2/filesystem.cpp | 38 ++---- kernel/src/filesystem/ext2/filesystem.tests.cpp | 132 ++++++++++++++++++++ kernel/src/filesystem/ext2/inode.tests.cpp | 159 ++++++++++++++++++++++++ 3 files changed, 303 insertions(+), 26 deletions(-) create mode 100644 kernel/src/filesystem/ext2/filesystem.tests.cpp create mode 100644 kernel/src/filesystem/ext2/inode.tests.cpp (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/filesystem.cpp b/kernel/src/filesystem/ext2/filesystem.cpp index 6d5960e..0ad5c97 100644 --- a/kernel/src/filesystem/ext2/filesystem.cpp +++ b/kernel/src/filesystem/ext2/filesystem.cpp @@ -21,29 +21,14 @@ namespace kernel::filesystem::ext2 { namespace { - constexpr size_t SUPERBLOCK_OFFSET = 1024; - constexpr uint16_t MAGIC_NUMBER = 0xEF53; - - constexpr uint32_t ROOT_INODE_NUMBER = 2; - - constexpr size_t DIRECT_BLOCK_COUNT = 12; - constexpr size_t SINGLY_INDIRECT_BLOCK_INDEX = DIRECT_BLOCK_COUNT; - constexpr size_t DOUBLY_INDIRECT_BLOCK_INDEX = SINGLY_INDIRECT_BLOCK_INDEX + 1; - constexpr size_t TRIPLY_INDIRECT_BLOCK_INDEX = DOUBLY_INDIRECT_BLOCK_INDEX + 1; - - // Mode bits - constexpr uint16_t S_IFMT = 0xF000; - constexpr uint16_t S_IFREG = 0x8000; - constexpr uint16_t S_IFDIR = 0x4000; - auto S_ISREG(uint16_t mode) -> bool { - return (mode & S_IFMT) == S_IFREG; + return (mode & constants::mode_mask) == constants::mode_regular; } auto S_ISDIR(uint16_t mode) -> bool { - return (mode & S_IFMT) == S_IFDIR; + return (mode & constants::mode_mask) == constants::mode_directory; } } // namespace @@ -51,9 +36,10 @@ namespace kernel::filesystem::ext2 { kernel::filesystem::filesystem::mount(device); - kernel::devices::block_device_utils::read(m_device, &m_superblock, SUPERBLOCK_OFFSET, sizeof(m_superblock)); + kernel::devices::block_device_utils::read(m_device, &m_superblock, constants::superblock_offset, + sizeof(m_superblock)); - if (m_superblock.magic != MAGIC_NUMBER) + if (m_superblock.magic != constants::magic_number) { return operation_result::invalid_magic_number; } @@ -69,7 +55,7 @@ namespace kernel::filesystem::ext2 block_group_descriptor_table_offset, num_block_groups * sizeof(block_group_descriptor)); - m_root_inode = read_inode(ROOT_INODE_NUMBER); + m_root_inode = read_inode(constants::root_inode_number); if (!m_root_inode || !m_root_inode->is_directory()) { @@ -161,11 +147,11 @@ namespace kernel::filesystem::ext2 auto filesystem::map_inode_block_index_to_global_block_number(uint32_t inode_block_index, inode_data data) -> uint32_t { - if (inode_block_index < DIRECT_BLOCK_COUNT) + if (inode_block_index < constants::direct_block_count) { return data.block.at(inode_block_index); } - inode_block_index -= DIRECT_BLOCK_COUNT; + inode_block_index -= constants::direct_block_count; auto const block_size = get_block_size(); auto const numbers_per_block = block_size / sizeof(uint32_t); @@ -176,14 +162,14 @@ namespace kernel::filesystem::ext2 if (inode_block_index < block_numbers_per_singly_indirect_block) { - auto const singly_indirect_block_number = data.block.at(SINGLY_INDIRECT_BLOCK_INDEX); + auto const singly_indirect_block_number = data.block.at(constants::singly_indirect_block_index); return read_block_number_at_index(singly_indirect_block_number, inode_block_index); } inode_block_index -= block_numbers_per_singly_indirect_block; if (inode_block_index < block_numbers_per_doubly_indirect_block) { - auto const doubly_indirect_block_number = data.block.at(DOUBLY_INDIRECT_BLOCK_INDEX); + auto const doubly_indirect_block_number = data.block.at(constants::doubly_indirect_block_index); auto const singly_indirect_block_index_in_doubly_indirect_block = inode_block_index / block_numbers_per_singly_indirect_block; auto const singly_indirect_block_number = read_block_number_at_index( @@ -196,7 +182,7 @@ namespace kernel::filesystem::ext2 if (inode_block_index < block_numbers_per_triply_indirect_block) { - auto const triply_indirect_block_number = data.block.at(TRIPLY_INDIRECT_BLOCK_INDEX); + auto const triply_indirect_block_number = data.block.at(constants::triply_indirect_block_index); auto const doubly_indirect_block_index_in_triply_indirect_block = inode_block_index / block_numbers_per_doubly_indirect_block; auto const doubly_indirect_block_number = read_block_number_at_index( @@ -230,7 +216,7 @@ namespace kernel::filesystem::ext2 auto filesystem::get_block_size() -> size_t { - return 1024U << m_superblock.log_block_size; + return constants::base_block_size << m_superblock.log_block_size; } auto filesystem::get_inode_size() -> size_t diff --git a/kernel/src/filesystem/ext2/filesystem.tests.cpp b/kernel/src/filesystem/ext2/filesystem.tests.cpp new file mode 100644 index 0000000..b13ebf3 --- /dev/null +++ b/kernel/src/filesystem/ext2/filesystem.tests.cpp @@ -0,0 +1,132 @@ +#include "kernel/filesystem/ext2/filesystem.hpp" + +#include "kernel/devices/storage/management.hpp" +#include "kernel/filesystem/ext2/inode.hpp" +#include "kernel/filesystem/filesystem.hpp" +#include "kernel/test_support/devices/block_device.hpp" +#include "kernel/test_support/filesystem/ext2.hpp" +#include "kernel/test_support/filesystem/storage_boot_module_fixture.hpp" + +#include +#include + +#include + +#include +#include +#include + +SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture, + "Ext2 filesystem mount and lookup with real image", "[filesystem][ext2][filesystem][img]") +{ + auto const image_path = std::filesystem::path{KERNEL_TEST_ASSETS_DIR} / "ext2_1KB_fs.img"; + + GIVEN("a mounted ext2 filesystem from a real image") + { + REQUIRE(std::filesystem::exists(image_path)); + REQUIRE_NOTHROW(setup_modules_from_img({"test_img_module"}, {image_path})); + + auto boot_device = kernel::devices::storage::management::get().determine_boot_device(); + REQUIRE(boot_device != nullptr); + + auto fs = kernel::filesystem::ext2::filesystem{}; + REQUIRE(fs.mount(boot_device) == kernel::filesystem::filesystem::operation_result::success); + + THEN("the root inode is available and is a directory") + { + REQUIRE(fs.root_inode() != nullptr); + REQUIRE(fs.root_inode()->is_directory()); + } + + THEN("lookup resolves known entries from the image") + { + auto information = fs.lookup(fs.root_inode(), "information"); + REQUIRE(information != nullptr); + REQUIRE(information->is_directory()); + + auto info_1 = fs.lookup(information, "info_1.txt"); + REQUIRE(info_1 != nullptr); + REQUIRE(info_1->is_regular()); + } + + THEN("lookup returns null for invalid inputs") + { + REQUIRE(fs.lookup(nullptr, "information") == nullptr); + + auto information = fs.lookup(fs.root_inode(), "information"); + REQUIRE(information != nullptr); + auto info_1 = fs.lookup(information, "info_1.txt"); + REQUIRE(info_1 != nullptr); + + REQUIRE(fs.lookup(info_1, "anything") == nullptr); + REQUIRE(fs.lookup(fs.root_inode(), "does_not_exist") == nullptr); + } + } +} + +SCENARIO("Ext2 filesystem rejects invalid magic", "[filesystem][ext2][filesystem]") +{ + auto const block_size = 1024; + GIVEN("a block device that does not contain an ext2 superblock") + { + auto device = kstd::make_shared(0, 0, "mock", block_size, 2 * block_size); + REQUIRE(device != nullptr); + + auto fs = kernel::filesystem::ext2::filesystem{}; + + THEN("mount fails with invalid_magic_number") + { + REQUIRE(fs.mount(device) == kernel::filesystem::filesystem::operation_result::invalid_magic_number); + } + } +} + +SCENARIO("Ext2 block mapping includes direct and all indirect levels", "[filesystem][ext2][filesystem]") +{ + auto const block_size = 1024; + + GIVEN("a minimally valid ext2 layout with configured indirect block tables") + { + auto device = kstd::make_shared(0, 0, "mock", block_size, 128 * block_size); + REQUIRE(device != nullptr); + + kernel::tests::filesystem::ext2::setup_mock_ext2_layout(*device); + + auto fs = kernel::filesystem::ext2::filesystem{}; + REQUIRE(fs.mount(device) == kernel::filesystem::filesystem::operation_result::success); + + auto inode_data = kernel::filesystem::ext2::inode_data{}; + inode_data.block[0] = 7; + + inode_data.block[12] = 30; + kernel::tests::filesystem::ext2::write_u32(*device, 30 * block_size, 31); + + inode_data.block[13] = 40; + kernel::tests::filesystem::ext2::write_u32(*device, 40 * block_size, 41); + kernel::tests::filesystem::ext2::write_u32(*device, 41 * block_size, 42); + + inode_data.block[14] = 50; + kernel::tests::filesystem::ext2::write_u32(*device, 50 * block_size, 51); + kernel::tests::filesystem::ext2::write_u32(*device, 51 * block_size, 52); + kernel::tests::filesystem::ext2::write_u32(*device, 52 * block_size, 53); + + auto const numbers_per_block = static_cast(block_size / sizeof(uint32_t)); + auto const singly_start = static_cast(kernel::filesystem::ext2::constants::direct_block_count); + auto const doubly_start = singly_start + numbers_per_block; + auto const triply_start = doubly_start + numbers_per_block * numbers_per_block; + + THEN("mapping resolves direct, singly, doubly and triply indirect indexes") + { + REQUIRE(fs.map_inode_block_index_to_global_block_number(0, inode_data) == 7); + REQUIRE(fs.map_inode_block_index_to_global_block_number(singly_start, inode_data) == 31); + REQUIRE(fs.map_inode_block_index_to_global_block_number(doubly_start, inode_data) == 42); + REQUIRE(fs.map_inode_block_index_to_global_block_number(triply_start, inode_data) == 53); + } + + THEN("mapping returns zero for out-of-range indexes") + { + auto const beyond_triply = triply_start + numbers_per_block * numbers_per_block * numbers_per_block; + REQUIRE(fs.map_inode_block_index_to_global_block_number(beyond_triply, inode_data) == 0); + } + } +} diff --git a/kernel/src/filesystem/ext2/inode.tests.cpp b/kernel/src/filesystem/ext2/inode.tests.cpp new file mode 100644 index 0000000..795ff10 --- /dev/null +++ b/kernel/src/filesystem/ext2/inode.tests.cpp @@ -0,0 +1,159 @@ +#include "kernel/filesystem/ext2/inode.hpp" + +#include "kernel/devices/storage/management.hpp" +#include "kernel/filesystem/ext2/filesystem.hpp" +#include "kernel/filesystem/filesystem.hpp" +#include "kernel/test_support/cpu.hpp" +#include "kernel/test_support/devices/block_device.hpp" +#include "kernel/test_support/filesystem/ext2.hpp" +#include "kernel/test_support/filesystem/storage_boot_module_fixture.hpp" + +#include +#include + +#include + +#include +#include +#include + +SCENARIO("Ext2 inode initialization and properties", "[filesystem][ext2][inode]") +{ + GIVEN("an ext2 filesystem") + { + auto fs = kernel::filesystem::ext2::filesystem{}; + + THEN("the inode is initialized and has the kind regular") + { + auto inode = kernel::filesystem::ext2::inode{&fs}; + REQUIRE(inode.is_regular()); + REQUIRE(!inode.is_directory()); + REQUIRE(!inode.is_device()); + } + } + + GIVEN("no filesystem (null pointer)") + { + THEN("constructing an inode with a null filesystem pointer panics") + { + REQUIRE_THROWS_AS(kernel::filesystem::ext2::inode{nullptr}, kernel::tests::cpu::halt); + } + } +} + +SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture, "Ext2 inode reads from real image", + "[filesystem][ext2][inode][img]") +{ + auto const image_path = std::filesystem::path{KERNEL_TEST_ASSETS_DIR} / "ext2_1KB_fs.img"; + + GIVEN("a mounted ext2 filesystem and a regular file inode") + { + REQUIRE(std::filesystem::exists(image_path)); + REQUIRE_NOTHROW(setup_modules_from_img({"test_img_module"}, {image_path})); + + auto boot_device = kernel::devices::storage::management::get().determine_boot_device(); + REQUIRE(boot_device != nullptr); + + auto fs = kernel::filesystem::ext2::filesystem{}; + REQUIRE(fs.mount(boot_device) == kernel::filesystem::filesystem::operation_result::success); + + auto information = fs.lookup(fs.root_inode(), "information"); + REQUIRE(information != nullptr); + auto file = fs.lookup(information, "info_1.txt"); + REQUIRE(file != nullptr); + REQUIRE(file->is_regular()); + + THEN("reading from offset zero returns expected file prefix") + { + auto buffer = kstd::vector(6); + auto const bytes_read = file->read(buffer.data(), 0, buffer.size()); + + REQUIRE(bytes_read == 6); + + auto const text = std::string_view{reinterpret_cast(buffer.data()), bytes_read}; + REQUIRE(text == "info_1"); + } + + THEN("reading with an offset returns the expected byte") + { + auto buffer = kstd::vector(1); + auto const bytes_read = file->read(buffer.data(), 5, buffer.size()); + + REQUIRE(bytes_read == 1); + REQUIRE(static_cast(buffer[0]) == '1'); + } + } +} + +SCENARIO("Ext2 inode read stops when block mapping resolves to zero", "[filesystem][ext2][inode]") +{ + auto const block_size = 1024; + GIVEN("an ext2 inode without mapped data blocks") + { + auto device = kstd::make_shared(0, 0, "mock", block_size, 64 * block_size); + REQUIRE(device != nullptr); + kernel::tests::filesystem::ext2::setup_mock_ext2_layout(*device); + + auto fs = kernel::filesystem::ext2::filesystem{}; + REQUIRE(fs.mount(device) == kernel::filesystem::filesystem::operation_result::success); + + auto inode = kernel::filesystem::ext2::inode{&fs}; + inode.m_data.blocks = 2; + inode.m_data.block[0] = 0; + + auto buffer = kstd::vector(32, std::byte{0xAB}); + + THEN("no bytes are read") + { + auto const bytes_read = inode.read(buffer.data(), 0, buffer.size()); + REQUIRE(bytes_read == 0); + } + } +} + +SCENARIO("Ext2 inode read across block boundaries", "[filesystem][ext2][inode]") +{ + auto const block_size = 1024; + GIVEN("an ext2 inode with two direct blocks and a block size of 1024 bytes") + { + auto device = kstd::make_shared(0, 0, "mock", block_size, 64 * block_size); + REQUIRE(device != nullptr); + kernel::tests::filesystem::ext2::setup_mock_ext2_layout(*device); + + auto fs = kernel::filesystem::ext2::filesystem{}; + REQUIRE(fs.mount(device) == kernel::filesystem::filesystem::operation_result::success); + + auto inode = kernel::filesystem::ext2::inode{&fs}; + inode.m_data.blocks = 2; + inode.m_data.block[0] = 20; + kernel::tests::filesystem::ext2::write_bytes(*device, 21 * block_size - 6, "Hello ", 6); + inode.m_data.block[1] = 21; + kernel::tests::filesystem::ext2::write_bytes(*device, 21 * block_size, "World!", 6); + + auto buffer = kstd::vector(12, std::byte{0x00}); + + THEN("reading across the block boundary returns the combined content") + { + auto const bytes_read = inode.read(buffer.data(), block_size - 6, buffer.size()); + REQUIRE(bytes_read == 12); + + auto const text = std::string_view{reinterpret_cast(buffer.data()), bytes_read}; + REQUIRE(text == "Hello World!"); + } + } +} + +SCENARIO("Ext2 inode write is not implemented", "[filesystem][ext2][inode]") +{ + GIVEN("an ext2 inode") + { + auto fs = kernel::filesystem::ext2::filesystem{}; + auto inode = kernel::filesystem::ext2::inode{&fs}; + + THEN("writing to the inode panics") + { + auto buffer = kstd::vector(32, std::byte{0x00}); + REQUIRE_THROWS_AS(inode.write(buffer.data(), 0, buffer.size()), kernel::tests::cpu::halt); + } + } +} -- cgit v1.2.3 From 5e183b418b0e65dcdffa02a43702a0d6deb43b04 Mon Sep 17 00:00:00 2001 From: Marcel Braun Date: Mon, 13 Apr 2026 21:17:50 +0200 Subject: Back filesystem by inode and not device --- kernel/src/filesystem/ext2/filesystem.cpp | 21 ++++++++------------- kernel/src/filesystem/ext2/filesystem.tests.cpp | 13 ++++++++++--- kernel/src/filesystem/ext2/inode.cpp | 7 +++---- kernel/src/filesystem/ext2/inode.tests.cpp | 13 ++++++++++--- 4 files changed, 31 insertions(+), 23 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/filesystem.cpp b/kernel/src/filesystem/ext2/filesystem.cpp index 0ad5c97..c0f97ed 100644 --- a/kernel/src/filesystem/ext2/filesystem.cpp +++ b/kernel/src/filesystem/ext2/filesystem.cpp @@ -1,8 +1,5 @@ #include "kernel/filesystem/ext2/filesystem.hpp" -#include "kapi/devices/device.hpp" - -#include "kernel/devices/block_device_utils.hpp" #include "kernel/filesystem/ext2/block_group_descriptor.hpp" #include "kernel/filesystem/ext2/inode.hpp" #include "kernel/filesystem/ext2/linked_directory_entry.hpp" @@ -32,12 +29,11 @@ namespace kernel::filesystem::ext2 } } // namespace - auto filesystem::mount(kstd::shared_ptr const & device) -> operation_result + auto filesystem::mount(kstd::shared_ptr const & backing_inode) -> operation_result { - kernel::filesystem::filesystem::mount(device); + kernel::filesystem::filesystem::mount(backing_inode); - kernel::devices::block_device_utils::read(m_device, &m_superblock, constants::superblock_offset, - sizeof(m_superblock)); + m_backing_inode->read(&m_superblock, constants::superblock_offset, sizeof(m_superblock)); if (m_superblock.magic != constants::magic_number) { @@ -51,9 +47,8 @@ namespace kernel::filesystem::ext2 m_block_group_descriptors = kstd::vector(num_block_groups); auto const block_group_descriptor_table_offset = block_size == 1024 ? 2 * block_size : block_size; - kernel::devices::block_device_utils::read(m_device, m_block_group_descriptors.data(), - block_group_descriptor_table_offset, - num_block_groups * sizeof(block_group_descriptor)); + m_backing_inode->read(m_block_group_descriptors.data(), block_group_descriptor_table_offset, + num_block_groups * sizeof(block_group_descriptor)); m_root_inode = read_inode(constants::root_inode_number); @@ -86,7 +81,7 @@ namespace kernel::filesystem::ext2 { auto const global_block_number = map_inode_block_index_to_global_block_number(i, inode_data); auto const block_offset = global_block_number * block_size; - kernel::devices::block_device_utils::read(m_device, buffer.data(), block_offset, block_size); + m_backing_inode->read(buffer.data(), block_offset, block_size); auto const * entry = reinterpret_cast(buffer.data()); auto bytes_read = 0uz; @@ -125,7 +120,7 @@ namespace kernel::filesystem::ext2 auto const inode_offset = inode_table_offset + inode_index_within_group * get_inode_size(); auto new_inode = kstd::make_shared(this); - kernel::devices::block_device_utils::read(m_device, &new_inode->m_data, inode_offset, sizeof(inode_data)); + m_backing_inode->read(&new_inode->m_data, inode_offset, sizeof(inode_data)); // TODO BA-FS26 improve inode_kind really needed? or just map it to the mode bits? if (S_ISREG(new_inode->m_data.mode)) @@ -209,7 +204,7 @@ namespace kernel::filesystem::ext2 auto const block_start_offset = block_number * get_block_size(); auto const number_start_address = block_start_offset + index * sizeof(uint32_t); - kernel::devices::block_device_utils::read(m_device, &block_number_buffer, number_start_address, sizeof(uint32_t)); + m_backing_inode->read(&block_number_buffer, number_start_address, sizeof(uint32_t)); return block_number_buffer; } diff --git a/kernel/src/filesystem/ext2/filesystem.tests.cpp b/kernel/src/filesystem/ext2/filesystem.tests.cpp index b13ebf3..a7b8d5b 100644 --- a/kernel/src/filesystem/ext2/filesystem.tests.cpp +++ b/kernel/src/filesystem/ext2/filesystem.tests.cpp @@ -1,6 +1,7 @@ #include "kernel/filesystem/ext2/filesystem.hpp" #include "kernel/devices/storage/management.hpp" +#include "kernel/filesystem/device_inode.hpp" #include "kernel/filesystem/ext2/inode.hpp" #include "kernel/filesystem/filesystem.hpp" #include "kernel/test_support/devices/block_device.hpp" @@ -29,8 +30,10 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture, auto boot_device = kernel::devices::storage::management::get().determine_boot_device(); REQUIRE(boot_device != nullptr); + auto dev_inode = kstd::make_shared(boot_device); + auto fs = kernel::filesystem::ext2::filesystem{}; - REQUIRE(fs.mount(boot_device) == kernel::filesystem::filesystem::operation_result::success); + REQUIRE(fs.mount(dev_inode) == kernel::filesystem::filesystem::operation_result::success); THEN("the root inode is available and is a directory") { @@ -72,11 +75,13 @@ SCENARIO("Ext2 filesystem rejects invalid magic", "[filesystem][ext2][filesystem auto device = kstd::make_shared(0, 0, "mock", block_size, 2 * block_size); REQUIRE(device != nullptr); + auto dev_inode = kstd::make_shared(device); + auto fs = kernel::filesystem::ext2::filesystem{}; THEN("mount fails with invalid_magic_number") { - REQUIRE(fs.mount(device) == kernel::filesystem::filesystem::operation_result::invalid_magic_number); + REQUIRE(fs.mount(dev_inode) == kernel::filesystem::filesystem::operation_result::invalid_magic_number); } } } @@ -92,8 +97,10 @@ SCENARIO("Ext2 block mapping includes direct and all indirect levels", "[filesys kernel::tests::filesystem::ext2::setup_mock_ext2_layout(*device); + auto dev_inode = kstd::make_shared(device); + auto fs = kernel::filesystem::ext2::filesystem{}; - REQUIRE(fs.mount(device) == kernel::filesystem::filesystem::operation_result::success); + REQUIRE(fs.mount(dev_inode) == kernel::filesystem::filesystem::operation_result::success); auto inode_data = kernel::filesystem::ext2::inode_data{}; inode_data.block[0] = 7; diff --git a/kernel/src/filesystem/ext2/inode.cpp b/kernel/src/filesystem/ext2/inode.cpp index a29bb3b..bf3f0cf 100644 --- a/kernel/src/filesystem/ext2/inode.cpp +++ b/kernel/src/filesystem/ext2/inode.cpp @@ -2,7 +2,6 @@ #include "kapi/system.hpp" -#include "kernel/devices/block_device_utils.hpp" #include "kernel/filesystem/ext2/filesystem.hpp" #include "kernel/filesystem/inode.hpp" @@ -41,8 +40,8 @@ namespace kernel::filesystem::ext2 auto const read_offset = block_start_offset + in_block_offset; auto const bytes_to_read = std::min(size - bytes_read, m_filesystem->get_block_size() - in_block_offset); - bytes_read += kernel::devices::block_device_utils::read( - m_filesystem->device(), static_cast(buffer) + bytes_read, read_offset, bytes_to_read); + bytes_read += + m_filesystem->backing_inode()->read(static_cast(buffer) + bytes_read, read_offset, bytes_to_read); block_index++; in_block_offset = 0; // After the first block, we always start at the beginning of the block @@ -56,4 +55,4 @@ namespace kernel::filesystem::ext2 kapi::system::panic("[EXT2] inode::write is not implemented yet"); return 0; } -} // namespace kernel::filesystem::ext2 \ No newline at end of file +} // namespace kernel::filesystem::ext2 diff --git a/kernel/src/filesystem/ext2/inode.tests.cpp b/kernel/src/filesystem/ext2/inode.tests.cpp index 795ff10..ae66aff 100644 --- a/kernel/src/filesystem/ext2/inode.tests.cpp +++ b/kernel/src/filesystem/ext2/inode.tests.cpp @@ -1,6 +1,7 @@ #include "kernel/filesystem/ext2/inode.hpp" #include "kernel/devices/storage/management.hpp" +#include "kernel/filesystem/device_inode.hpp" #include "kernel/filesystem/ext2/filesystem.hpp" #include "kernel/filesystem/filesystem.hpp" #include "kernel/test_support/cpu.hpp" @@ -54,8 +55,10 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture, "Ext2 in auto boot_device = kernel::devices::storage::management::get().determine_boot_device(); REQUIRE(boot_device != nullptr); + auto dev_inode = kstd::make_shared(boot_device); + auto fs = kernel::filesystem::ext2::filesystem{}; - REQUIRE(fs.mount(boot_device) == kernel::filesystem::filesystem::operation_result::success); + REQUIRE(fs.mount(dev_inode) == kernel::filesystem::filesystem::operation_result::success); auto information = fs.lookup(fs.root_inode(), "information"); REQUIRE(information != nullptr); @@ -94,8 +97,10 @@ SCENARIO("Ext2 inode read stops when block mapping resolves to zero", "[filesyst REQUIRE(device != nullptr); kernel::tests::filesystem::ext2::setup_mock_ext2_layout(*device); + auto dev_inode = kstd::make_shared(device); + auto fs = kernel::filesystem::ext2::filesystem{}; - REQUIRE(fs.mount(device) == kernel::filesystem::filesystem::operation_result::success); + REQUIRE(fs.mount(dev_inode) == kernel::filesystem::filesystem::operation_result::success); auto inode = kernel::filesystem::ext2::inode{&fs}; inode.m_data.blocks = 2; @@ -120,8 +125,10 @@ SCENARIO("Ext2 inode read across block boundaries", "[filesystem][ext2][inode]") REQUIRE(device != nullptr); kernel::tests::filesystem::ext2::setup_mock_ext2_layout(*device); + auto dev_inode = kstd::make_shared(device); + auto fs = kernel::filesystem::ext2::filesystem{}; - REQUIRE(fs.mount(device) == kernel::filesystem::filesystem::operation_result::success); + REQUIRE(fs.mount(dev_inode) == kernel::filesystem::filesystem::operation_result::success); auto inode = kernel::filesystem::ext2::inode{&fs}; inode.m_data.blocks = 2; -- cgit v1.2.3 From 44b5f84ac7d563be0e2f518db71c273760aba8a3 Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Sun, 19 Apr 2026 09:40:09 +0200 Subject: add todo to support sparse files --- kernel/src/filesystem/ext2/inode.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/inode.cpp b/kernel/src/filesystem/ext2/inode.cpp index bf3f0cf..07a5525 100644 --- a/kernel/src/filesystem/ext2/inode.cpp +++ b/kernel/src/filesystem/ext2/inode.cpp @@ -31,7 +31,9 @@ namespace kernel::filesystem::ext2 while (bytes_read < size) { auto const block_number = m_filesystem->map_inode_block_index_to_global_block_number(block_index, m_data); - if (block_number == 0) // TODO BA-FS26 really correct? + // TODO BA-FS26 really correct? sparse files -> 0 means a full block with zeros --> function + // map_inode_block_index_to_global_block_number should return 0 if not possible to find an block + if (block_number == 0) { break; } -- cgit v1.2.3 From 2d8fed40bd0d0f8144783b6b344dc79944291b72 Mon Sep 17 00:00:00 2001 From: Felix Morgner Date: Thu, 23 Apr 2026 13:31:17 +0200 Subject: chore: organize includes --- kernel/src/filesystem/ext2/inode.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/inode.cpp b/kernel/src/filesystem/ext2/inode.cpp index 07a5525..6b42db6 100644 --- a/kernel/src/filesystem/ext2/inode.cpp +++ b/kernel/src/filesystem/ext2/inode.cpp @@ -1,10 +1,10 @@ #include "kernel/filesystem/ext2/inode.hpp" -#include "kapi/system.hpp" - #include "kernel/filesystem/ext2/filesystem.hpp" #include "kernel/filesystem/inode.hpp" +#include "kapi/system.hpp" + #include #include #include -- cgit v1.2.3 From f6f10575f75ac23d06e1d94f7861611503daa7af Mon Sep 17 00:00:00 2001 From: Felix Morgner Date: Thu, 23 Apr 2026 14:03:28 +0200 Subject: chore: banish relative includes --- kernel/src/filesystem/ext2/filesystem.cpp | 16 ++++++++-------- kernel/src/filesystem/ext2/filesystem.tests.cpp | 18 +++++++++--------- kernel/src/filesystem/ext2/inode.cpp | 8 ++++---- kernel/src/filesystem/ext2/inode.tests.cpp | 20 ++++++++++---------- 4 files changed, 31 insertions(+), 31 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/filesystem.cpp b/kernel/src/filesystem/ext2/filesystem.cpp index c0f97ed..41572ee 100644 --- a/kernel/src/filesystem/ext2/filesystem.cpp +++ b/kernel/src/filesystem/ext2/filesystem.cpp @@ -1,11 +1,11 @@ -#include "kernel/filesystem/ext2/filesystem.hpp" - -#include "kernel/filesystem/ext2/block_group_descriptor.hpp" -#include "kernel/filesystem/ext2/inode.hpp" -#include "kernel/filesystem/ext2/linked_directory_entry.hpp" -#include "kernel/filesystem/ext2/superblock.hpp" -#include "kernel/filesystem/filesystem.hpp" -#include "kernel/filesystem/inode.hpp" +#include + +#include +#include +#include +#include +#include +#include #include #include diff --git a/kernel/src/filesystem/ext2/filesystem.tests.cpp b/kernel/src/filesystem/ext2/filesystem.tests.cpp index a7b8d5b..31c4c29 100644 --- a/kernel/src/filesystem/ext2/filesystem.tests.cpp +++ b/kernel/src/filesystem/ext2/filesystem.tests.cpp @@ -1,12 +1,12 @@ -#include "kernel/filesystem/ext2/filesystem.hpp" - -#include "kernel/devices/storage/management.hpp" -#include "kernel/filesystem/device_inode.hpp" -#include "kernel/filesystem/ext2/inode.hpp" -#include "kernel/filesystem/filesystem.hpp" -#include "kernel/test_support/devices/block_device.hpp" -#include "kernel/test_support/filesystem/ext2.hpp" -#include "kernel/test_support/filesystem/storage_boot_module_fixture.hpp" +#include + +#include +#include +#include +#include +#include +#include +#include #include #include diff --git a/kernel/src/filesystem/ext2/inode.cpp b/kernel/src/filesystem/ext2/inode.cpp index 6b42db6..c45c41e 100644 --- a/kernel/src/filesystem/ext2/inode.cpp +++ b/kernel/src/filesystem/ext2/inode.cpp @@ -1,9 +1,9 @@ -#include "kernel/filesystem/ext2/inode.hpp" +#include -#include "kernel/filesystem/ext2/filesystem.hpp" -#include "kernel/filesystem/inode.hpp" +#include +#include -#include "kapi/system.hpp" +#include #include #include diff --git a/kernel/src/filesystem/ext2/inode.tests.cpp b/kernel/src/filesystem/ext2/inode.tests.cpp index ae66aff..4d61790 100644 --- a/kernel/src/filesystem/ext2/inode.tests.cpp +++ b/kernel/src/filesystem/ext2/inode.tests.cpp @@ -1,13 +1,13 @@ -#include "kernel/filesystem/ext2/inode.hpp" - -#include "kernel/devices/storage/management.hpp" -#include "kernel/filesystem/device_inode.hpp" -#include "kernel/filesystem/ext2/filesystem.hpp" -#include "kernel/filesystem/filesystem.hpp" -#include "kernel/test_support/cpu.hpp" -#include "kernel/test_support/devices/block_device.hpp" -#include "kernel/test_support/filesystem/ext2.hpp" -#include "kernel/test_support/filesystem/storage_boot_module_fixture.hpp" +#include + +#include +#include +#include +#include +#include +#include +#include +#include #include #include -- cgit v1.2.3 From b3209ac2564f21f3b78ecf5e0c05ca346a4a4276 Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Tue, 28 Apr 2026 10:49:34 +0200 Subject: refactor inode kind --- kernel/src/filesystem/ext2/filesystem.cpp | 36 ++++------------------------- kernel/src/filesystem/ext2/inode.cpp | 21 ++++++++++++++--- kernel/src/filesystem/ext2/inode.tests.cpp | 37 +++++++++++++++++++++--------- 3 files changed, 48 insertions(+), 46 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/filesystem.cpp b/kernel/src/filesystem/ext2/filesystem.cpp index 41572ee..47e54fe 100644 --- a/kernel/src/filesystem/ext2/filesystem.cpp +++ b/kernel/src/filesystem/ext2/filesystem.cpp @@ -16,19 +16,6 @@ namespace kernel::filesystem::ext2 { - namespace - { - auto S_ISREG(uint16_t mode) -> bool - { - return (mode & constants::mode_mask) == constants::mode_regular; - } - - auto S_ISDIR(uint16_t mode) -> bool - { - return (mode & constants::mode_mask) == constants::mode_directory; - } - } // namespace - auto filesystem::mount(kstd::shared_ptr const & backing_inode) -> operation_result { kernel::filesystem::filesystem::mount(backing_inode); @@ -74,7 +61,7 @@ namespace kernel::filesystem::ext2 } auto const block_size = get_block_size(); - auto const & inode_data = ext2_parent->m_data; + auto const & inode_data = ext2_parent->data(); kstd::vector buffer(block_size); for (uint32_t i = 0; i < get_inode_block_count(inode_data); ++i) @@ -119,25 +106,10 @@ namespace kernel::filesystem::ext2 auto const inode_table_offset = static_cast(inode_table_start_block) * block_size; auto const inode_offset = inode_table_offset + inode_index_within_group * get_inode_size(); - auto new_inode = kstd::make_shared(this); - m_backing_inode->read(&new_inode->m_data, inode_offset, sizeof(inode_data)); - - // TODO BA-FS26 improve inode_kind really needed? or just map it to the mode bits? - if (S_ISREG(new_inode->m_data.mode)) - { - new_inode->m_kind = inode::inode_kind::regular; - } - else if (S_ISDIR(new_inode->m_data.mode)) - { - new_inode->m_kind = inode::inode_kind::directory; - } - else - { - // TODO BA-FS26 really correct?? - return nullptr; - } + auto new_inode_data = inode_data{}; + m_backing_inode->read(&new_inode_data, inode_offset, sizeof(inode_data)); - return new_inode; + return kstd::make_shared(this, new_inode_data); } auto filesystem::map_inode_block_index_to_global_block_number(uint32_t inode_block_index, inode_data data) -> uint32_t diff --git a/kernel/src/filesystem/ext2/inode.cpp b/kernel/src/filesystem/ext2/inode.cpp index c45c41e..279c84f 100644 --- a/kernel/src/filesystem/ext2/inode.cpp +++ b/kernel/src/filesystem/ext2/inode.cpp @@ -11,9 +11,9 @@ namespace kernel::filesystem::ext2 { - inode::inode(filesystem * fs) - : kernel::filesystem::inode(inode_kind::regular) - , m_filesystem(fs) + inode::inode(filesystem * fs, inode_data const & data) + : m_filesystem(fs) + , m_data(data) { if (!m_filesystem) { @@ -57,4 +57,19 @@ namespace kernel::filesystem::ext2 kapi::system::panic("[EXT2] inode::write is not implemented yet"); return 0; } + + [[nodiscard]] auto inode::data() const -> inode_data const & + { + return m_data; + } + + auto inode::is_regular() const -> bool + { + return (m_data.mode & constants::mode_mask) == constants::mode_regular; + } + + auto inode::is_directory() const -> bool + { + return (m_data.mode & constants::mode_mask) == constants::mode_directory; + } } // namespace kernel::filesystem::ext2 diff --git a/kernel/src/filesystem/ext2/inode.tests.cpp b/kernel/src/filesystem/ext2/inode.tests.cpp index 4d61790..e68352f 100644 --- a/kernel/src/filesystem/ext2/inode.tests.cpp +++ b/kernel/src/filesystem/ext2/inode.tests.cpp @@ -23,21 +23,34 @@ SCENARIO("Ext2 inode initialization and properties", "[filesystem][ext2][inode]" GIVEN("an ext2 filesystem") { auto fs = kernel::filesystem::ext2::filesystem{}; + auto data = kernel::filesystem::ext2::inode_data{}; - THEN("the inode is initialized and has the kind regular") + THEN("the inode is initialized with regular file mode in data and has the kind regular") { - auto inode = kernel::filesystem::ext2::inode{&fs}; + data.mode = kernel::filesystem::ext2::constants::mode_regular; + auto inode = kernel::filesystem::ext2::inode(&fs, data); + REQUIRE(inode.is_regular()); REQUIRE(!inode.is_directory()); REQUIRE(!inode.is_device()); } + + THEN("the inode is initialized with directory mode in data and has the kind directory") + { + data.mode = kernel::filesystem::ext2::constants::mode_directory; + auto inode = kernel::filesystem::ext2::inode(&fs, data); + + REQUIRE(!inode.is_regular()); + REQUIRE(inode.is_directory()); + REQUIRE(!inode.is_device()); + } } GIVEN("no filesystem (null pointer)") { THEN("constructing an inode with a null filesystem pointer panics") { - REQUIRE_THROWS_AS(kernel::filesystem::ext2::inode{nullptr}, kernel::tests::cpu::halt); + REQUIRE_THROWS_AS(kernel::filesystem::ext2::inode(nullptr, {}), kernel::tests::cpu::halt); } } } @@ -102,9 +115,10 @@ SCENARIO("Ext2 inode read stops when block mapping resolves to zero", "[filesyst auto fs = kernel::filesystem::ext2::filesystem{}; REQUIRE(fs.mount(dev_inode) == kernel::filesystem::filesystem::operation_result::success); - auto inode = kernel::filesystem::ext2::inode{&fs}; - inode.m_data.blocks = 2; - inode.m_data.block[0] = 0; + auto data = kernel::filesystem::ext2::inode_data{}; + data.blocks = 2; + data.block[0] = 0; + auto inode = kernel::filesystem::ext2::inode{&fs, data}; auto buffer = kstd::vector(32, std::byte{0xAB}); @@ -130,12 +144,13 @@ SCENARIO("Ext2 inode read across block boundaries", "[filesystem][ext2][inode]") auto fs = kernel::filesystem::ext2::filesystem{}; REQUIRE(fs.mount(dev_inode) == kernel::filesystem::filesystem::operation_result::success); - auto inode = kernel::filesystem::ext2::inode{&fs}; - inode.m_data.blocks = 2; - inode.m_data.block[0] = 20; + auto inode_data = kernel::filesystem::ext2::inode_data{}; + inode_data.blocks = 2; + inode_data.block[0] = 20; kernel::tests::filesystem::ext2::write_bytes(*device, 21 * block_size - 6, "Hello ", 6); - inode.m_data.block[1] = 21; + inode_data.block[1] = 21; kernel::tests::filesystem::ext2::write_bytes(*device, 21 * block_size, "World!", 6); + auto inode = kernel::filesystem::ext2::inode{&fs, inode_data}; auto buffer = kstd::vector(12, std::byte{0x00}); @@ -155,7 +170,7 @@ SCENARIO("Ext2 inode write is not implemented", "[filesystem][ext2][inode]") GIVEN("an ext2 inode") { auto fs = kernel::filesystem::ext2::filesystem{}; - auto inode = kernel::filesystem::ext2::inode{&fs}; + auto inode = kernel::filesystem::ext2::inode{&fs, kernel::filesystem::ext2::inode_data{}}; THEN("writing to the inode panics") { -- cgit v1.2.3 From 6790ab170578594f26e8e84a3e57b80cb6094e21 Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Tue, 28 Apr 2026 10:55:37 +0200 Subject: add is_symbolic_link method in ext2 inode --- kernel/src/filesystem/ext2/inode.cpp | 5 +++++ kernel/src/filesystem/ext2/inode.tests.cpp | 24 ++++++++++++++++++++++++ 2 files changed, 29 insertions(+) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/inode.cpp b/kernel/src/filesystem/ext2/inode.cpp index 279c84f..5b6bcb3 100644 --- a/kernel/src/filesystem/ext2/inode.cpp +++ b/kernel/src/filesystem/ext2/inode.cpp @@ -72,4 +72,9 @@ namespace kernel::filesystem::ext2 { return (m_data.mode & constants::mode_mask) == constants::mode_directory; } + + auto inode::is_symbolic_link() const -> bool + { + return (m_data.mode & constants::mode_mask) == constants::mode_symbolic_link; + } } // namespace kernel::filesystem::ext2 diff --git a/kernel/src/filesystem/ext2/inode.tests.cpp b/kernel/src/filesystem/ext2/inode.tests.cpp index e68352f..f0f4aaf 100644 --- a/kernel/src/filesystem/ext2/inode.tests.cpp +++ b/kernel/src/filesystem/ext2/inode.tests.cpp @@ -33,6 +33,7 @@ SCENARIO("Ext2 inode initialization and properties", "[filesystem][ext2][inode]" REQUIRE(inode.is_regular()); REQUIRE(!inode.is_directory()); REQUIRE(!inode.is_device()); + REQUIRE(!inode.is_symbolic_link()); } THEN("the inode is initialized with directory mode in data and has the kind directory") @@ -43,6 +44,29 @@ SCENARIO("Ext2 inode initialization and properties", "[filesystem][ext2][inode]" REQUIRE(!inode.is_regular()); REQUIRE(inode.is_directory()); REQUIRE(!inode.is_device()); + REQUIRE(!inode.is_symbolic_link()); + } + + THEN("the inode is initialized with symbolic link mode in data and has the kind symbolic link") + { + data.mode = kernel::filesystem::ext2::constants::mode_symbolic_link; + auto inode = kernel::filesystem::ext2::inode(&fs, data); + + REQUIRE(!inode.is_regular()); + REQUIRE(!inode.is_directory()); + REQUIRE(!inode.is_device()); + REQUIRE(inode.is_symbolic_link()); + } + + THEN("the inode is initialized with zero mode in data and has no specific kind") + { + data.mode = 0; + auto inode = kernel::filesystem::ext2::inode(&fs, data); + + REQUIRE(!inode.is_regular()); + REQUIRE(!inode.is_directory()); + REQUIRE(!inode.is_device()); + REQUIRE(!inode.is_symbolic_link()); } } -- cgit v1.2.3 From 40fbefab704695b905e3de3e80668447cc64b20e Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Sat, 2 May 2026 15:36:19 +0200 Subject: refactoring and extend tests --- kernel/src/filesystem/ext2/inode.tests.cpp | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/inode.tests.cpp b/kernel/src/filesystem/ext2/inode.tests.cpp index f0f4aaf..49ba21b 100644 --- a/kernel/src/filesystem/ext2/inode.tests.cpp +++ b/kernel/src/filesystem/ext2/inode.tests.cpp @@ -31,9 +31,9 @@ SCENARIO("Ext2 inode initialization and properties", "[filesystem][ext2][inode]" auto inode = kernel::filesystem::ext2::inode(&fs, data); REQUIRE(inode.is_regular()); - REQUIRE(!inode.is_directory()); - REQUIRE(!inode.is_device()); - REQUIRE(!inode.is_symbolic_link()); + REQUIRE_FALSE(inode.is_directory()); + REQUIRE_FALSE(inode.is_device()); + REQUIRE_FALSE(inode.is_symbolic_link()); } THEN("the inode is initialized with directory mode in data and has the kind directory") @@ -41,10 +41,10 @@ SCENARIO("Ext2 inode initialization and properties", "[filesystem][ext2][inode]" data.mode = kernel::filesystem::ext2::constants::mode_directory; auto inode = kernel::filesystem::ext2::inode(&fs, data); - REQUIRE(!inode.is_regular()); + REQUIRE_FALSE(inode.is_regular()); REQUIRE(inode.is_directory()); - REQUIRE(!inode.is_device()); - REQUIRE(!inode.is_symbolic_link()); + REQUIRE_FALSE(inode.is_device()); + REQUIRE_FALSE(inode.is_symbolic_link()); } THEN("the inode is initialized with symbolic link mode in data and has the kind symbolic link") @@ -52,9 +52,9 @@ SCENARIO("Ext2 inode initialization and properties", "[filesystem][ext2][inode]" data.mode = kernel::filesystem::ext2::constants::mode_symbolic_link; auto inode = kernel::filesystem::ext2::inode(&fs, data); - REQUIRE(!inode.is_regular()); - REQUIRE(!inode.is_directory()); - REQUIRE(!inode.is_device()); + REQUIRE_FALSE(inode.is_regular()); + REQUIRE_FALSE(inode.is_directory()); + REQUIRE_FALSE(inode.is_device()); REQUIRE(inode.is_symbolic_link()); } @@ -63,10 +63,10 @@ SCENARIO("Ext2 inode initialization and properties", "[filesystem][ext2][inode]" data.mode = 0; auto inode = kernel::filesystem::ext2::inode(&fs, data); - REQUIRE(!inode.is_regular()); - REQUIRE(!inode.is_directory()); - REQUIRE(!inode.is_device()); - REQUIRE(!inode.is_symbolic_link()); + REQUIRE_FALSE(inode.is_regular()); + REQUIRE_FALSE(inode.is_directory()); + REQUIRE_FALSE(inode.is_device()); + REQUIRE_FALSE(inode.is_symbolic_link()); } } -- cgit v1.2.3 From d90d6bb4b4820df6cb4b0747439293bb85b8cbec Mon Sep 17 00:00:00 2001 From: Marcel Braun Date: Mon, 4 May 2026 20:17:43 +0200 Subject: Implement symlink read in inode, fix max amount of bytes to read --- kernel/src/filesystem/ext2/inode.cpp | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/inode.cpp b/kernel/src/filesystem/ext2/inode.cpp index 5b6bcb3..1914c70 100644 --- a/kernel/src/filesystem/ext2/inode.cpp +++ b/kernel/src/filesystem/ext2/inode.cpp @@ -5,6 +5,8 @@ #include +#include + #include #include #include @@ -23,6 +25,17 @@ namespace kernel::filesystem::ext2 auto inode::read(void * buffer, size_t offset, size_t size) const -> size_t { + // TODO BA-FS26 use revision 1 size + auto const max_readable = static_cast(m_data.size) - offset; + auto const requested_size = std::min(size, max_readable); + + if (is_symbolic_link() && m_data.size <= sizeof(m_data.block)) + { + auto inline_target = reinterpret_cast(m_data.block.data()); + kstd::libc::memcpy(static_cast(buffer), inline_target + offset, requested_size); + return requested_size; + } + auto block_index = offset / m_filesystem->get_block_size(); auto in_block_offset = offset % m_filesystem->get_block_size(); @@ -40,7 +53,8 @@ namespace kernel::filesystem::ext2 auto const block_start_offset = block_number * m_filesystem->get_block_size(); auto const read_offset = block_start_offset + in_block_offset; - auto const bytes_to_read = std::min(size - bytes_read, m_filesystem->get_block_size() - in_block_offset); + auto const bytes_to_read = + std::min(requested_size - bytes_read, m_filesystem->get_block_size() - in_block_offset); bytes_read += m_filesystem->backing_inode()->read(static_cast(buffer) + bytes_read, read_offset, bytes_to_read); -- cgit v1.2.3 From 988977b80cd118749b6b813e0909f4607a4f27fe Mon Sep 17 00:00:00 2001 From: Marcel Braun Date: Tue, 12 May 2026 13:50:56 +0200 Subject: Determine ext2 inode size depending on revision level, add const to several methods --- kernel/src/filesystem/ext2/filesystem.cpp | 20 +++++++++++++------- kernel/src/filesystem/ext2/inode.cpp | 20 ++++++++++++++++---- 2 files changed, 29 insertions(+), 11 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/filesystem.cpp b/kernel/src/filesystem/ext2/filesystem.cpp index 47e54fe..aaa50c7 100644 --- a/kernel/src/filesystem/ext2/filesystem.cpp +++ b/kernel/src/filesystem/ext2/filesystem.cpp @@ -89,7 +89,7 @@ namespace kernel::filesystem::ext2 return nullptr; } - auto filesystem::read_inode(uint32_t inode_number) -> kstd::shared_ptr + auto filesystem::read_inode(uint32_t inode_number) const -> kstd::shared_ptr { auto const block_size = get_block_size(); auto const inodes_per_group = m_superblock.inodes_per_group; @@ -112,7 +112,8 @@ namespace kernel::filesystem::ext2 return kstd::make_shared(this, new_inode_data); } - auto filesystem::map_inode_block_index_to_global_block_number(uint32_t inode_block_index, inode_data data) -> uint32_t + auto filesystem::map_inode_block_index_to_global_block_number(uint32_t inode_block_index, inode_data data) const + -> uint32_t { if (inode_block_index < constants::direct_block_count) { @@ -170,7 +171,7 @@ namespace kernel::filesystem::ext2 return 0; // TODO BA-FS26 really correct?? } - auto filesystem::read_block_number_at_index(uint32_t block_number, uint32_t index) -> uint32_t + auto filesystem::read_block_number_at_index(uint32_t block_number, uint32_t index) const -> uint32_t { uint32_t block_number_buffer = 0; @@ -181,17 +182,22 @@ namespace kernel::filesystem::ext2 return block_number_buffer; } - auto filesystem::get_block_size() -> size_t + auto filesystem::get_block_size() const -> size_t { return constants::base_block_size << m_superblock.log_block_size; } - auto filesystem::get_inode_size() -> size_t + auto filesystem::get_revision_level() const -> size_t { - return m_superblock.rev_level == 0 ? 128 : m_superblock.inode_size; + return m_superblock.rev_level; } - auto filesystem::get_inode_block_count(inode_data const & data) -> uint32_t + auto filesystem::get_inode_size() const -> size_t + { + return get_revision_level() == constants::good_old_revision ? 128 : m_superblock.inode_size; + } + + auto filesystem::get_inode_block_count(inode_data const & data) const -> uint32_t { return data.blocks / (2 << m_superblock.log_block_size); } diff --git a/kernel/src/filesystem/ext2/inode.cpp b/kernel/src/filesystem/ext2/inode.cpp index 1914c70..303838e 100644 --- a/kernel/src/filesystem/ext2/inode.cpp +++ b/kernel/src/filesystem/ext2/inode.cpp @@ -13,7 +13,7 @@ namespace kernel::filesystem::ext2 { - inode::inode(filesystem * fs, inode_data const & data) + inode::inode(filesystem const * fs, inode_data const & data) : m_filesystem(fs) , m_data(data) { @@ -25,11 +25,10 @@ namespace kernel::filesystem::ext2 auto inode::read(void * buffer, size_t offset, size_t size) const -> size_t { - // TODO BA-FS26 use revision 1 size - auto const max_readable = static_cast(m_data.size) - offset; + auto const max_readable = get_size() - offset; auto const requested_size = std::min(size, max_readable); - if (is_symbolic_link() && m_data.size <= sizeof(m_data.block)) + if (is_symbolic_link() && get_size() <= sizeof(m_data.block)) { auto inline_target = reinterpret_cast(m_data.block.data()); kstd::libc::memcpy(static_cast(buffer), inline_target + offset, requested_size); @@ -91,4 +90,17 @@ namespace kernel::filesystem::ext2 { return (m_data.mode & constants::mode_mask) == constants::mode_symbolic_link; } + + auto inode::get_size() const -> size_t + { + uint64_t size = m_data.size; + + if (m_filesystem->get_revision_level() > constants::good_old_revision && is_regular()) + { + size |= static_cast(m_data.dir_acl) << 32; + } + + return size; + } + } // namespace kernel::filesystem::ext2 -- cgit v1.2.3 From 7b1e578480f2f522fe39a742e688012a7f5ea4ed Mon Sep 17 00:00:00 2001 From: Marcel Braun Date: Tue, 12 May 2026 14:46:02 +0200 Subject: Add tests for ext2 inode get_size() --- kernel/src/filesystem/ext2/inode.tests.cpp | 90 +++++++++++++++++++++++++++++- 1 file changed, 88 insertions(+), 2 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/inode.tests.cpp b/kernel/src/filesystem/ext2/inode.tests.cpp index 49ba21b..783d930 100644 --- a/kernel/src/filesystem/ext2/inode.tests.cpp +++ b/kernel/src/filesystem/ext2/inode.tests.cpp @@ -1,5 +1,6 @@ #include +#include "kernel/filesystem/ext2/superblock.hpp" #include #include #include @@ -127,7 +128,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture, "Ext2 in SCENARIO("Ext2 inode read stops when block mapping resolves to zero", "[filesystem][ext2][inode]") { - auto const block_size = 1024; + auto const block_size = 1024uz; GIVEN("an ext2 inode without mapped data blocks") { auto device = kstd::make_shared(0, 0, "mock", block_size, 64 * block_size); @@ -156,7 +157,7 @@ SCENARIO("Ext2 inode read stops when block mapping resolves to zero", "[filesyst SCENARIO("Ext2 inode read across block boundaries", "[filesystem][ext2][inode]") { - auto const block_size = 1024; + auto const block_size = 1024uz; GIVEN("an ext2 inode with two direct blocks and a block size of 1024 bytes") { auto device = kstd::make_shared(0, 0, "mock", block_size, 64 * block_size); @@ -203,3 +204,88 @@ SCENARIO("Ext2 inode write is not implemented", "[filesystem][ext2][inode]") } } } + +SCENARIO("Ext2 inode get_size() correctly returns size depending on revision level", "[filesystem][ext2][inode]") +{ + auto const block_size = 1024uz; + + auto superblock = kernel::filesystem::ext2::superblock{}; + superblock.magic = kernel::filesystem::ext2::constants::magic_number; + superblock.log_block_size = 0; + superblock.blocks_count = 64; + superblock.blocks_per_group = 64; + superblock.inodes_per_group = 32; + superblock.inode_size = 128; + + GIVEN("an ext2 inode with good old revision and inode_data.size = 256, inode_data.dir_acl = 32") + { + superblock.rev_level = 0; + + auto device = kstd::make_shared(0, 0, "mock", block_size, 64 * block_size); + REQUIRE(device != nullptr); + kernel::tests::filesystem::ext2::setup_mock_ext2_layout(*device, superblock); + + auto dev_inode = kstd::make_shared(device); + + auto fs = kernel::filesystem::ext2::filesystem{}; + REQUIRE(fs.mount(dev_inode) == kernel::filesystem::filesystem::operation_result::success); + + auto data = kernel::filesystem::ext2::inode_data{}; + data.size = 256; + data.dir_acl = 32; + + THEN("the inode size is 256 if mode = regular") + { + data.mode = kernel::filesystem::ext2::constants::mode_regular; + + auto inode = kernel::filesystem::ext2::inode{&fs, data}; + + REQUIRE(inode.get_size() == 256); + } + + THEN("the inode size is 256 if mode = directory") + { + data.mode = kernel::filesystem::ext2::constants::mode_directory; + + auto inode = kernel::filesystem::ext2::inode{&fs, data}; + + REQUIRE(inode.get_size() == 256); + } + } + + GIVEN("an ext2 inode with good dynamic revision and inode_data.size = 256, inode_data.dir_acl = 32") + { + superblock.rev_level = 1; + + auto device = kstd::make_shared(0, 0, "mock", block_size, 64 * block_size); + REQUIRE(device != nullptr); + kernel::tests::filesystem::ext2::setup_mock_ext2_layout(*device, superblock); + + auto dev_inode = kstd::make_shared(device); + + auto fs = kernel::filesystem::ext2::filesystem{}; + REQUIRE(fs.mount(dev_inode) == kernel::filesystem::filesystem::operation_result::success); + + auto data = kernel::filesystem::ext2::inode_data{}; + data.size = 256; + data.dir_acl = 32; + + THEN("the inode size is 256 if mode = regular") + { + data.mode = kernel::filesystem::ext2::constants::mode_regular; + + auto inode = kernel::filesystem::ext2::inode{&fs, data}; + + REQUIRE(inode.get_size() == 0x0000'0020'0000'0100); + } + + THEN("the inode size is 256 if mode = directory") + { + data.mode = kernel::filesystem::ext2::constants::mode_directory; + + auto inode = kernel::filesystem::ext2::inode{&fs, data}; + + REQUIRE(inode.get_size() == 256); + } + } +} \ No newline at end of file -- cgit v1.2.3 From d061f31f33feccb4203979c6e8d9bbaeabecb453 Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Wed, 13 May 2026 10:13:13 +0200 Subject: refactor ext2 map_inode_block_index_to_global_block_number --- kernel/src/filesystem/ext2/filesystem.cpp | 86 ++++++++++++++++++------- kernel/src/filesystem/ext2/filesystem.tests.cpp | 2 +- 2 files changed, 62 insertions(+), 26 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/filesystem.cpp b/kernel/src/filesystem/ext2/filesystem.cpp index aaa50c7..0f34cfe 100644 --- a/kernel/src/filesystem/ext2/filesystem.cpp +++ b/kernel/src/filesystem/ext2/filesystem.cpp @@ -13,6 +13,7 @@ #include #include #include +#include namespace kernel::filesystem::ext2 { @@ -113,7 +114,7 @@ namespace kernel::filesystem::ext2 } auto filesystem::map_inode_block_index_to_global_block_number(uint32_t inode_block_index, inode_data data) const - -> uint32_t + -> ssize_t { if (inode_block_index < constants::direct_block_count) { @@ -121,9 +122,7 @@ namespace kernel::filesystem::ext2 } inode_block_index -= constants::direct_block_count; - auto const block_size = get_block_size(); - auto const numbers_per_block = block_size / sizeof(uint32_t); - + auto const numbers_per_block = block_numbers_per_block(); auto const block_numbers_per_singly_indirect_block = numbers_per_block; auto const block_numbers_per_doubly_indirect_block = numbers_per_block * block_numbers_per_singly_indirect_block; auto const block_numbers_per_triply_indirect_block = numbers_per_block * block_numbers_per_doubly_indirect_block; @@ -131,44 +130,76 @@ namespace kernel::filesystem::ext2 if (inode_block_index < block_numbers_per_singly_indirect_block) { auto const singly_indirect_block_number = data.block.at(constants::singly_indirect_block_index); - return read_block_number_at_index(singly_indirect_block_number, inode_block_index); + return read_singly_indirect_block_number(singly_indirect_block_number, inode_block_index); } inode_block_index -= block_numbers_per_singly_indirect_block; if (inode_block_index < block_numbers_per_doubly_indirect_block) { auto const doubly_indirect_block_number = data.block.at(constants::doubly_indirect_block_index); - auto const singly_indirect_block_index_in_doubly_indirect_block = - inode_block_index / block_numbers_per_singly_indirect_block; - auto const singly_indirect_block_number = read_block_number_at_index( - doubly_indirect_block_number, singly_indirect_block_index_in_doubly_indirect_block); - - auto const block_index_in_singly_indirect_block = inode_block_index % block_numbers_per_singly_indirect_block; - return read_block_number_at_index(singly_indirect_block_number, block_index_in_singly_indirect_block); + return read_doubly_indirect_block_number(doubly_indirect_block_number, inode_block_index); } inode_block_index -= block_numbers_per_doubly_indirect_block; if (inode_block_index < block_numbers_per_triply_indirect_block) { auto const triply_indirect_block_number = data.block.at(constants::triply_indirect_block_index); - auto const doubly_indirect_block_index_in_triply_indirect_block = - inode_block_index / block_numbers_per_doubly_indirect_block; - auto const doubly_indirect_block_number = read_block_number_at_index( - triply_indirect_block_number, doubly_indirect_block_index_in_triply_indirect_block); + return read_triply_indirect_block_number(triply_indirect_block_number, inode_block_index); + } + + return -1; + } + + auto filesystem::read_singly_indirect_block_number(uint32_t singly_indirect_block_number, + uint32_t block_index_in_singly_indirect_block) const -> uint32_t + { + if (singly_indirect_block_number == 0) + { + return 0; + } + return read_block_number_at_index(singly_indirect_block_number, block_index_in_singly_indirect_block); + } + + auto filesystem::read_doubly_indirect_block_number(uint32_t doubly_indirect_block_number, + uint32_t block_index_in_doubly_indirect_block) const -> uint32_t + { + auto const block_numbers_per_singly_indirect_block = block_numbers_per_block(); - auto const remaining_block_numbers = inode_block_index % block_numbers_per_doubly_indirect_block; + if (doubly_indirect_block_number == 0) + { + return 0; + } + + auto const singly_indirect_block_index_in_doubly_indirect_block = + block_index_in_doubly_indirect_block / block_numbers_per_singly_indirect_block; + auto const block_index_in_singly_indirect_block = + block_index_in_doubly_indirect_block % block_numbers_per_singly_indirect_block; + + auto const singly_indirect_block_number = + read_block_number_at_index(doubly_indirect_block_number, singly_indirect_block_index_in_doubly_indirect_block); - auto const singly_indirect_block_index_in_doubly_indirect_block = - remaining_block_numbers / block_numbers_per_singly_indirect_block; - auto const singly_indirect_block_number = read_block_number_at_index( - doubly_indirect_block_number, singly_indirect_block_index_in_doubly_indirect_block); + return read_singly_indirect_block_number(singly_indirect_block_number, block_index_in_singly_indirect_block); + } + + auto filesystem::read_triply_indirect_block_number(uint32_t triply_indirect_block_number, + uint32_t block_index_in_triply_indirect_block) const -> uint32_t + { + auto const block_numbers_per_doubly_indirect_block = block_numbers_per_block() * block_numbers_per_block(); - auto const block_index_in_singly_indirect_block = - remaining_block_numbers % block_numbers_per_singly_indirect_block; - return read_block_number_at_index(singly_indirect_block_number, block_index_in_singly_indirect_block); + if (triply_indirect_block_number == 0) + { + return 0; } - return 0; // TODO BA-FS26 really correct?? + auto const doubly_indirect_block_index_in_triply_indirect_block = + block_index_in_triply_indirect_block / block_numbers_per_doubly_indirect_block; + auto const block_index_in_doubly_indirect_block = + block_index_in_triply_indirect_block % block_numbers_per_doubly_indirect_block; + + auto const doubly_indirect_block_number = + read_block_number_at_index(triply_indirect_block_number, doubly_indirect_block_index_in_triply_indirect_block); + + return read_doubly_indirect_block_number(doubly_indirect_block_number, block_index_in_doubly_indirect_block); } auto filesystem::read_block_number_at_index(uint32_t block_number, uint32_t index) const -> uint32_t @@ -182,6 +213,11 @@ namespace kernel::filesystem::ext2 return block_number_buffer; } + auto filesystem::block_numbers_per_block() const -> uint32_t + { + return get_block_size() / sizeof(uint32_t); + } + auto filesystem::get_block_size() const -> size_t { return constants::base_block_size << m_superblock.log_block_size; diff --git a/kernel/src/filesystem/ext2/filesystem.tests.cpp b/kernel/src/filesystem/ext2/filesystem.tests.cpp index 31c4c29..8341070 100644 --- a/kernel/src/filesystem/ext2/filesystem.tests.cpp +++ b/kernel/src/filesystem/ext2/filesystem.tests.cpp @@ -133,7 +133,7 @@ SCENARIO("Ext2 block mapping includes direct and all indirect levels", "[filesys THEN("mapping returns zero for out-of-range indexes") { auto const beyond_triply = triply_start + numbers_per_block * numbers_per_block * numbers_per_block; - REQUIRE(fs.map_inode_block_index_to_global_block_number(beyond_triply, inode_data) == 0); + REQUIRE(fs.map_inode_block_index_to_global_block_number(beyond_triply, inode_data) == -1); } } } -- cgit v1.2.3 From de0ef46e7bab75d0ab94f02d569df62e2b4281f2 Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Wed, 13 May 2026 10:14:21 +0200 Subject: implement sparse files, fix bug with reading more than inode size --- kernel/src/filesystem/ext2/inode.cpp | 22 ++++++++++++++-------- 1 file changed, 14 insertions(+), 8 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/inode.cpp b/kernel/src/filesystem/ext2/inode.cpp index 303838e..cfe0a35 100644 --- a/kernel/src/filesystem/ext2/inode.cpp +++ b/kernel/src/filesystem/ext2/inode.cpp @@ -40,23 +40,29 @@ namespace kernel::filesystem::ext2 auto bytes_read = 0uz; - while (bytes_read < size) + while (bytes_read < requested_size) { auto const block_number = m_filesystem->map_inode_block_index_to_global_block_number(block_index, m_data); - // TODO BA-FS26 really correct? sparse files -> 0 means a full block with zeros --> function - // map_inode_block_index_to_global_block_number should return 0 if not possible to find an block - if (block_number == 0) + if (block_number == -1) { break; } - auto const block_start_offset = block_number * m_filesystem->get_block_size(); - auto const read_offset = block_start_offset + in_block_offset; auto const bytes_to_read = std::min(requested_size - bytes_read, m_filesystem->get_block_size() - in_block_offset); + if (block_number == 0) + { + kstd::libc::memset(static_cast(buffer) + bytes_read, 0, bytes_to_read); + bytes_read += bytes_to_read; + } + else + { + auto const block_start_offset = block_number * m_filesystem->get_block_size(); + auto const read_offset = block_start_offset + in_block_offset; - bytes_read += - m_filesystem->backing_inode()->read(static_cast(buffer) + bytes_read, read_offset, bytes_to_read); + bytes_read += m_filesystem->backing_inode()->read(static_cast(buffer) + bytes_read, read_offset, + bytes_to_read); + } block_index++; in_block_offset = 0; // After the first block, we always start at the beginning of the block -- cgit v1.2.3 From f0715177763e1154668a656fbd7abfb8bb2c3261 Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Wed, 13 May 2026 11:04:47 +0200 Subject: add inode sparse files tests --- kernel/src/filesystem/ext2/inode.tests.cpp | 101 ++++++++++++++++++++++++++--- 1 file changed, 93 insertions(+), 8 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/inode.tests.cpp b/kernel/src/filesystem/ext2/inode.tests.cpp index 783d930..8381ee0 100644 --- a/kernel/src/filesystem/ext2/inode.tests.cpp +++ b/kernel/src/filesystem/ext2/inode.tests.cpp @@ -15,6 +15,7 @@ #include +#include #include #include #include @@ -126,10 +127,10 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture, "Ext2 in } } -SCENARIO("Ext2 inode read stops when block mapping resolves to zero", "[filesystem][ext2][inode]") +SCENARIO("Ext2 inode handles zeros in block mappings as file holes", "[filesystem][ext2][inode]") { auto const block_size = 1024uz; - GIVEN("an ext2 inode without mapped data blocks") + GIVEN("an ext2 inode with only direct mapped data blocks") { auto device = kstd::make_shared(0, 0, "mock", block_size, 64 * block_size); REQUIRE(device != nullptr); @@ -141,16 +142,100 @@ SCENARIO("Ext2 inode read stops when block mapping resolves to zero", "[filesyst REQUIRE(fs.mount(dev_inode) == kernel::filesystem::filesystem::operation_result::success); auto data = kernel::filesystem::ext2::inode_data{}; - data.blocks = 2; - data.block[0] = 0; + data.block[0] = 30; + data.block[1] = 0; + data.block[2] = 31; + data.size = block_size * 3; + + kernel::tests::filesystem::ext2::write_bytes(*device, 30 * block_size, "Hello", 5); + kernel::tests::filesystem::ext2::write_bytes(*device, 31 * block_size, "World!", 6); + + auto inode = kernel::filesystem::ext2::inode{&fs, data}; + + auto buffer = kstd::vector(data.size, std::byte{0xAB}); + + THEN("correct number of bytes are read and holes are returned as zeros") + { + auto const bytes_read = inode.read(buffer.data(), 0, buffer.size()); + REQUIRE(bytes_read == data.size); + + auto const text = std::string_view{reinterpret_cast(buffer.data()), bytes_read}; + REQUIRE(text.substr(0, 5) == "Hello"); + REQUIRE(std::ranges::all_of(text.substr(5, block_size - 5), [](char c) { return c == '\0'; })); + REQUIRE(text.substr(2 * block_size, 6) == "World!"); + REQUIRE(std::ranges::all_of(text.substr(2 * block_size + 6, 3 * block_size), [](char c) { return c == '\0'; })); + } + } + + GIVEN("an ext2 indode with file holes in singly indirect blocks") + { + auto device = kstd::make_shared(0, 0, "mock", block_size, 64 * block_size); + REQUIRE(device != nullptr); + kernel::tests::filesystem::ext2::setup_mock_ext2_layout(*device); + + auto dev_inode = kstd::make_shared(device); + + auto fs = kernel::filesystem::ext2::filesystem{}; + REQUIRE(fs.mount(dev_inode) == kernel::filesystem::filesystem::operation_result::success); + + auto data = kernel::filesystem::ext2::inode_data{}; + data.block[0] = 30; + data.block[12] = 31; + data.size = block_size * 15; + + kernel::tests::filesystem::ext2::write_u32(*device, 31 * block_size, 50); + kernel::tests::filesystem::ext2::write_u32(*device, 31 * block_size + 4, 0); + kernel::tests::filesystem::ext2::write_u32(*device, 31 * block_size + 8, 51); + + kernel::tests::filesystem::ext2::write_bytes(*device, 30 * block_size, "Hello", 5); + kernel::tests::filesystem::ext2::write_bytes(*device, 50 * block_size, "Blub", 4); + kernel::tests::filesystem::ext2::write_bytes(*device, 51 * block_size, "World!", 6); + + auto inode = kernel::filesystem::ext2::inode{&fs, data}; + + auto buffer = kstd::vector(data.size, std::byte{0xAB}); + + THEN("correct number of bytes are read and holes are returned as zeros") + { + auto const bytes_read = inode.read(buffer.data(), 0, buffer.size()); + REQUIRE(bytes_read == data.size); + + auto const text = std::string_view{reinterpret_cast(buffer.data()), bytes_read}; + REQUIRE(text.substr(0, 5) == "Hello"); + REQUIRE(std::ranges::all_of(text.substr(5, 12 * block_size - 5), [](char c) { return c == '\0'; })); + REQUIRE(text.substr(12 * block_size, 4) == "Blub"); + REQUIRE( + std::ranges::all_of(text.substr(12 * block_size + 4, 2 * block_size - 4), [](char c) { return c == '\0'; })); + REQUIRE(text.substr(14 * block_size, 6) == "World!"); + REQUIRE( + std::ranges::all_of(text.substr(14 * block_size + 6, 1 * block_size - 6), [](char c) { return c == '\0'; })); + } + } + + GIVEN("an ext2 inode with zero singly indirect block pointer") + { + auto device = kstd::make_shared(0, 0, "mock", block_size, 64 * block_size); + REQUIRE(device != nullptr); + kernel::tests::filesystem::ext2::setup_mock_ext2_layout(*device); + + auto dev_inode = kstd::make_shared(device); + + auto fs = kernel::filesystem::ext2::filesystem{}; + REQUIRE(fs.mount(dev_inode) == kernel::filesystem::filesystem::operation_result::success); + + auto data = kernel::filesystem::ext2::inode_data{}; + data.block[12] = 0; + data.size = block_size * 15; + auto inode = kernel::filesystem::ext2::inode{&fs, data}; - auto buffer = kstd::vector(32, std::byte{0xAB}); + auto buffer = kstd::vector(block_size * 3, std::byte{0xAB}); - THEN("no bytes are read") + THEN("all direct blocks are zero when singly indirect block pointer is zero") { auto const bytes_read = inode.read(buffer.data(), 0, buffer.size()); - REQUIRE(bytes_read == 0); + REQUIRE(bytes_read == buffer.size()); + REQUIRE(std::ranges::all_of(buffer, [](std::byte c) { return c == std::byte{0x00}; })); } } } @@ -170,7 +255,7 @@ SCENARIO("Ext2 inode read across block boundaries", "[filesystem][ext2][inode]") REQUIRE(fs.mount(dev_inode) == kernel::filesystem::filesystem::operation_result::success); auto inode_data = kernel::filesystem::ext2::inode_data{}; - inode_data.blocks = 2; + inode_data.size = block_size * 2; inode_data.block[0] = 20; kernel::tests::filesystem::ext2::write_bytes(*device, 21 * block_size - 6, "Hello ", 6); inode_data.block[1] = 21; -- cgit v1.2.3 From 117b16cc5e3506da637a806a25bb22b82a02ef9e Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Wed, 13 May 2026 11:11:22 +0200 Subject: refactoring --- kernel/src/filesystem/ext2/filesystem.cpp | 42 ++++++++++++++++++------------- 1 file changed, 24 insertions(+), 18 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/filesystem.cpp b/kernel/src/filesystem/ext2/filesystem.cpp index 0f34cfe..893cc38 100644 --- a/kernel/src/filesystem/ext2/filesystem.cpp +++ b/kernel/src/filesystem/ext2/filesystem.cpp @@ -122,26 +122,21 @@ namespace kernel::filesystem::ext2 } inode_block_index -= constants::direct_block_count; - auto const numbers_per_block = block_numbers_per_block(); - auto const block_numbers_per_singly_indirect_block = numbers_per_block; - auto const block_numbers_per_doubly_indirect_block = numbers_per_block * block_numbers_per_singly_indirect_block; - auto const block_numbers_per_triply_indirect_block = numbers_per_block * block_numbers_per_doubly_indirect_block; - - if (inode_block_index < block_numbers_per_singly_indirect_block) + if (inode_block_index < block_numbers_per_singly_indirect_block()) { auto const singly_indirect_block_number = data.block.at(constants::singly_indirect_block_index); return read_singly_indirect_block_number(singly_indirect_block_number, inode_block_index); } - inode_block_index -= block_numbers_per_singly_indirect_block; + inode_block_index -= block_numbers_per_singly_indirect_block(); - if (inode_block_index < block_numbers_per_doubly_indirect_block) + if (inode_block_index < block_numbers_per_doubly_indirect_block()) { auto const doubly_indirect_block_number = data.block.at(constants::doubly_indirect_block_index); return read_doubly_indirect_block_number(doubly_indirect_block_number, inode_block_index); } - inode_block_index -= block_numbers_per_doubly_indirect_block; + inode_block_index -= block_numbers_per_doubly_indirect_block(); - if (inode_block_index < block_numbers_per_triply_indirect_block) + if (inode_block_index < block_numbers_per_triply_indirect_block()) { auto const triply_indirect_block_number = data.block.at(constants::triply_indirect_block_index); return read_triply_indirect_block_number(triply_indirect_block_number, inode_block_index); @@ -163,17 +158,15 @@ namespace kernel::filesystem::ext2 auto filesystem::read_doubly_indirect_block_number(uint32_t doubly_indirect_block_number, uint32_t block_index_in_doubly_indirect_block) const -> uint32_t { - auto const block_numbers_per_singly_indirect_block = block_numbers_per_block(); - if (doubly_indirect_block_number == 0) { return 0; } auto const singly_indirect_block_index_in_doubly_indirect_block = - block_index_in_doubly_indirect_block / block_numbers_per_singly_indirect_block; + block_index_in_doubly_indirect_block / block_numbers_per_singly_indirect_block(); auto const block_index_in_singly_indirect_block = - block_index_in_doubly_indirect_block % block_numbers_per_singly_indirect_block; + block_index_in_doubly_indirect_block % block_numbers_per_singly_indirect_block(); auto const singly_indirect_block_number = read_block_number_at_index(doubly_indirect_block_number, singly_indirect_block_index_in_doubly_indirect_block); @@ -184,17 +177,15 @@ namespace kernel::filesystem::ext2 auto filesystem::read_triply_indirect_block_number(uint32_t triply_indirect_block_number, uint32_t block_index_in_triply_indirect_block) const -> uint32_t { - auto const block_numbers_per_doubly_indirect_block = block_numbers_per_block() * block_numbers_per_block(); - if (triply_indirect_block_number == 0) { return 0; } auto const doubly_indirect_block_index_in_triply_indirect_block = - block_index_in_triply_indirect_block / block_numbers_per_doubly_indirect_block; + block_index_in_triply_indirect_block / block_numbers_per_doubly_indirect_block(); auto const block_index_in_doubly_indirect_block = - block_index_in_triply_indirect_block % block_numbers_per_doubly_indirect_block; + block_index_in_triply_indirect_block % block_numbers_per_doubly_indirect_block(); auto const doubly_indirect_block_number = read_block_number_at_index(triply_indirect_block_number, doubly_indirect_block_index_in_triply_indirect_block); @@ -218,6 +209,21 @@ namespace kernel::filesystem::ext2 return get_block_size() / sizeof(uint32_t); } + auto filesystem::block_numbers_per_singly_indirect_block() const -> uint32_t + { + return block_numbers_per_block(); + } + + auto filesystem::block_numbers_per_doubly_indirect_block() const -> uint32_t + { + return block_numbers_per_singly_indirect_block() * block_numbers_per_block(); + } + + auto filesystem::block_numbers_per_triply_indirect_block() const -> uint32_t + { + return block_numbers_per_doubly_indirect_block() * block_numbers_per_block(); + } + auto filesystem::get_block_size() const -> size_t { return constants::base_block_size << m_superblock.log_block_size; -- cgit v1.2.3 From 15afa6a030ee6e1fc6c255f9567b54d78c530d25 Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Wed, 13 May 2026 11:23:33 +0200 Subject: increase buffer size to really test the singly indirect block pointer --- kernel/src/filesystem/ext2/inode.tests.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/inode.tests.cpp b/kernel/src/filesystem/ext2/inode.tests.cpp index 8381ee0..45bea51 100644 --- a/kernel/src/filesystem/ext2/inode.tests.cpp +++ b/kernel/src/filesystem/ext2/inode.tests.cpp @@ -229,7 +229,7 @@ SCENARIO("Ext2 inode handles zeros in block mappings as file holes", "[filesyste auto inode = kernel::filesystem::ext2::inode{&fs, data}; - auto buffer = kstd::vector(block_size * 3, std::byte{0xAB}); + auto buffer = kstd::vector(block_size * 15, std::byte{0xAB}); THEN("all direct blocks are zero when singly indirect block pointer is zero") { -- cgit v1.2.3 From 245f47af9362e83235a28f993c89f844886e65c3 Mon Sep 17 00:00:00 2001 From: Marcel Braun Date: Thu, 14 May 2026 16:25:15 +0200 Subject: Unify header inclusion syntax --- kernel/src/filesystem/ext2/inode.tests.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/inode.tests.cpp b/kernel/src/filesystem/ext2/inode.tests.cpp index 45bea51..efc0660 100644 --- a/kernel/src/filesystem/ext2/inode.tests.cpp +++ b/kernel/src/filesystem/ext2/inode.tests.cpp @@ -1,9 +1,9 @@ #include -#include "kernel/filesystem/ext2/superblock.hpp" #include #include #include +#include #include #include #include -- cgit v1.2.3 From 3b2f36d242eb895fd893ec7a674ff608f44f69ac Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Sat, 16 May 2026 16:12:36 +0200 Subject: refactoring --- kernel/src/filesystem/ext2/filesystem.cpp | 70 +++++++++++++++--------------- kernel/src/filesystem/ext2/inode.cpp | 19 ++++---- kernel/src/filesystem/ext2/inode.tests.cpp | 8 ++-- 3 files changed, 49 insertions(+), 48 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/filesystem.cpp b/kernel/src/filesystem/ext2/filesystem.cpp index 893cc38..7633972 100644 --- a/kernel/src/filesystem/ext2/filesystem.cpp +++ b/kernel/src/filesystem/ext2/filesystem.cpp @@ -28,14 +28,12 @@ namespace kernel::filesystem::ext2 return operation_result::invalid_magic_number; } - auto const block_size = get_block_size(); auto const blocks_per_group = m_superblock.blocks_per_group; auto const num_block_groups = (m_superblock.blocks_count + blocks_per_group - 1) / blocks_per_group; m_block_group_descriptors = kstd::vector(num_block_groups); - auto const block_group_descriptor_table_offset = block_size == 1024 ? 2 * block_size : block_size; - m_backing_inode->read(m_block_group_descriptors.data(), block_group_descriptor_table_offset, + m_backing_inode->read(m_block_group_descriptors.data(), block_group_descriptor_table_offset(), num_block_groups * sizeof(block_group_descriptor)); m_root_inode = read_inode(constants::root_inode_number); @@ -47,7 +45,7 @@ namespace kernel::filesystem::ext2 return operation_result::success; } - auto filesystem::lookup(kstd::shared_ptr const & parent, std::string_view name) + auto filesystem::lookup(kstd::shared_ptr const & parent, std::string_view name) const -> kstd::shared_ptr { if (!parent || !parent->is_directory()) @@ -61,20 +59,19 @@ namespace kernel::filesystem::ext2 return nullptr; } - auto const block_size = get_block_size(); auto const & inode_data = ext2_parent->data(); - kstd::vector buffer(block_size); + kstd::vector buffer(block_size()); - for (uint32_t i = 0; i < get_inode_block_count(inode_data); ++i) + for (auto i = 0uz; i < inode_block_count(inode_data); ++i) { auto const global_block_number = map_inode_block_index_to_global_block_number(i, inode_data); - auto const block_offset = global_block_number * block_size; - m_backing_inode->read(buffer.data(), block_offset, block_size); + auto const block_offset = global_block_number * block_size(); + m_backing_inode->read(buffer.data(), block_offset, block_size()); auto const * entry = reinterpret_cast(buffer.data()); auto bytes_read = 0uz; - while (bytes_read < block_size && entry->inode != 0) + while (bytes_read < block_size() && entry->inode != 0) { auto const entry_name = std::string_view{entry->name.data(), entry->name_len}; if (entry_name == name) @@ -90,9 +87,8 @@ namespace kernel::filesystem::ext2 return nullptr; } - auto filesystem::read_inode(uint32_t inode_number) const -> kstd::shared_ptr + auto filesystem::read_inode(size_t inode_number) const -> kstd::shared_ptr { - auto const block_size = get_block_size(); auto const inodes_per_group = m_superblock.inodes_per_group; auto const block_group_index = (inode_number - 1) / inodes_per_group; auto const inode_index_within_group = (inode_number - 1) % inodes_per_group; @@ -104,8 +100,8 @@ namespace kernel::filesystem::ext2 auto const & block_group_descriptor = m_block_group_descriptors.at(block_group_index); auto const inode_table_start_block = block_group_descriptor.inode_table; - auto const inode_table_offset = static_cast(inode_table_start_block) * block_size; - auto const inode_offset = inode_table_offset + inode_index_within_group * get_inode_size(); + auto const inode_table_offset = static_cast(inode_table_start_block) * block_size(); + auto const inode_offset = inode_table_offset + inode_index_within_group * inode_size(); auto new_inode_data = inode_data{}; m_backing_inode->read(&new_inode_data, inode_offset, sizeof(inode_data)); @@ -113,7 +109,7 @@ namespace kernel::filesystem::ext2 return kstd::make_shared(this, new_inode_data); } - auto filesystem::map_inode_block_index_to_global_block_number(uint32_t inode_block_index, inode_data data) const + auto filesystem::map_inode_block_index_to_global_block_number(size_t inode_block_index, inode_data data) const -> ssize_t { if (inode_block_index < constants::direct_block_count) @@ -145,18 +141,19 @@ namespace kernel::filesystem::ext2 return -1; } - auto filesystem::read_singly_indirect_block_number(uint32_t singly_indirect_block_number, - uint32_t block_index_in_singly_indirect_block) const -> uint32_t + auto filesystem::read_singly_indirect_block_number(size_t singly_indirect_block_number, + size_t block_index_in_singly_indirect_block) const -> size_t { if (singly_indirect_block_number == 0) { return 0; } + return read_block_number_at_index(singly_indirect_block_number, block_index_in_singly_indirect_block); } - auto filesystem::read_doubly_indirect_block_number(uint32_t doubly_indirect_block_number, - uint32_t block_index_in_doubly_indirect_block) const -> uint32_t + auto filesystem::read_doubly_indirect_block_number(size_t doubly_indirect_block_number, + size_t block_index_in_doubly_indirect_block) const -> size_t { if (doubly_indirect_block_number == 0) { @@ -174,8 +171,8 @@ namespace kernel::filesystem::ext2 return read_singly_indirect_block_number(singly_indirect_block_number, block_index_in_singly_indirect_block); } - auto filesystem::read_triply_indirect_block_number(uint32_t triply_indirect_block_number, - uint32_t block_index_in_triply_indirect_block) const -> uint32_t + auto filesystem::read_triply_indirect_block_number(size_t triply_indirect_block_number, + size_t block_index_in_triply_indirect_block) const -> size_t { if (triply_indirect_block_number == 0) { @@ -193,54 +190,59 @@ namespace kernel::filesystem::ext2 return read_doubly_indirect_block_number(doubly_indirect_block_number, block_index_in_doubly_indirect_block); } - auto filesystem::read_block_number_at_index(uint32_t block_number, uint32_t index) const -> uint32_t + auto filesystem::read_block_number_at_index(size_t block_number, size_t index) const -> size_t { - uint32_t block_number_buffer = 0; + auto block_number_buffer = 0uz; - auto const block_start_offset = block_number * get_block_size(); + auto const block_start_offset = block_number * block_size(); auto const number_start_address = block_start_offset + index * sizeof(uint32_t); m_backing_inode->read(&block_number_buffer, number_start_address, sizeof(uint32_t)); return block_number_buffer; } - auto filesystem::block_numbers_per_block() const -> uint32_t + auto filesystem::block_numbers_per_block() const -> size_t { - return get_block_size() / sizeof(uint32_t); + return block_size() / sizeof(uint32_t); } - auto filesystem::block_numbers_per_singly_indirect_block() const -> uint32_t + auto filesystem::block_numbers_per_singly_indirect_block() const -> size_t { return block_numbers_per_block(); } - auto filesystem::block_numbers_per_doubly_indirect_block() const -> uint32_t + auto filesystem::block_numbers_per_doubly_indirect_block() const -> size_t { return block_numbers_per_singly_indirect_block() * block_numbers_per_block(); } - auto filesystem::block_numbers_per_triply_indirect_block() const -> uint32_t + auto filesystem::block_numbers_per_triply_indirect_block() const -> size_t { return block_numbers_per_doubly_indirect_block() * block_numbers_per_block(); } - auto filesystem::get_block_size() const -> size_t + auto filesystem::block_size() const -> size_t { return constants::base_block_size << m_superblock.log_block_size; } - auto filesystem::get_revision_level() const -> size_t + auto filesystem::revision_level() const -> size_t { return m_superblock.rev_level; } - auto filesystem::get_inode_size() const -> size_t + auto filesystem::inode_size() const -> size_t { - return get_revision_level() == constants::good_old_revision ? 128 : m_superblock.inode_size; + return revision_level() == constants::good_old_revision ? 128 : m_superblock.inode_size; } - auto filesystem::get_inode_block_count(inode_data const & data) const -> uint32_t + auto filesystem::inode_block_count(inode_data const & data) const -> size_t { return data.blocks / (2 << m_superblock.log_block_size); } + + auto filesystem::block_group_descriptor_table_offset() const -> size_t + { + return block_size() == 1024 ? 2 * block_size() : block_size(); + } } // namespace kernel::filesystem::ext2 diff --git a/kernel/src/filesystem/ext2/inode.cpp b/kernel/src/filesystem/ext2/inode.cpp index cfe0a35..f8c818c 100644 --- a/kernel/src/filesystem/ext2/inode.cpp +++ b/kernel/src/filesystem/ext2/inode.cpp @@ -25,18 +25,18 @@ namespace kernel::filesystem::ext2 auto inode::read(void * buffer, size_t offset, size_t size) const -> size_t { - auto const max_readable = get_size() - offset; + auto const max_readable = this->size() - offset; auto const requested_size = std::min(size, max_readable); - if (is_symbolic_link() && get_size() <= sizeof(m_data.block)) + if (is_symbolic_link() && this->size() <= sizeof(m_data.block)) { auto inline_target = reinterpret_cast(m_data.block.data()); kstd::libc::memcpy(static_cast(buffer), inline_target + offset, requested_size); return requested_size; } - auto block_index = offset / m_filesystem->get_block_size(); - auto in_block_offset = offset % m_filesystem->get_block_size(); + auto block_index = offset / m_filesystem->block_size(); + auto in_block_offset = offset % m_filesystem->block_size(); auto bytes_read = 0uz; @@ -48,8 +48,7 @@ namespace kernel::filesystem::ext2 break; } - auto const bytes_to_read = - std::min(requested_size - bytes_read, m_filesystem->get_block_size() - in_block_offset); + auto const bytes_to_read = std::min(requested_size - bytes_read, m_filesystem->block_size() - in_block_offset); if (block_number == 0) { kstd::libc::memset(static_cast(buffer) + bytes_read, 0, bytes_to_read); @@ -57,7 +56,7 @@ namespace kernel::filesystem::ext2 } else { - auto const block_start_offset = block_number * m_filesystem->get_block_size(); + auto const block_start_offset = block_number * m_filesystem->block_size(); auto const read_offset = block_start_offset + in_block_offset; bytes_read += m_filesystem->backing_inode()->read(static_cast(buffer) + bytes_read, read_offset, @@ -71,7 +70,7 @@ namespace kernel::filesystem::ext2 return bytes_read; } - auto inode::write(void const * /*buffer*/, size_t /*offset*/, size_t /*size*/) -> size_t + auto inode::write(void const *, size_t, size_t) -> size_t { kapi::system::panic("[EXT2] inode::write is not implemented yet"); return 0; @@ -97,11 +96,11 @@ namespace kernel::filesystem::ext2 return (m_data.mode & constants::mode_mask) == constants::mode_symbolic_link; } - auto inode::get_size() const -> size_t + auto inode::size() const -> size_t { uint64_t size = m_data.size; - if (m_filesystem->get_revision_level() > constants::good_old_revision && is_regular()) + if (m_filesystem->revision_level() > constants::good_old_revision && is_regular()) { size |= static_cast(m_data.dir_acl) << 32; } diff --git a/kernel/src/filesystem/ext2/inode.tests.cpp b/kernel/src/filesystem/ext2/inode.tests.cpp index efc0660..4aecc04 100644 --- a/kernel/src/filesystem/ext2/inode.tests.cpp +++ b/kernel/src/filesystem/ext2/inode.tests.cpp @@ -325,7 +325,7 @@ SCENARIO("Ext2 inode get_size() correctly returns size depending on revision lev auto inode = kernel::filesystem::ext2::inode{&fs, data}; - REQUIRE(inode.get_size() == 256); + REQUIRE(inode.size() == 256); } THEN("the inode size is 256 if mode = directory") @@ -334,7 +334,7 @@ SCENARIO("Ext2 inode get_size() correctly returns size depending on revision lev auto inode = kernel::filesystem::ext2::inode{&fs, data}; - REQUIRE(inode.get_size() == 256); + REQUIRE(inode.size() == 256); } } @@ -361,7 +361,7 @@ SCENARIO("Ext2 inode get_size() correctly returns size depending on revision lev auto inode = kernel::filesystem::ext2::inode{&fs, data}; - REQUIRE(inode.get_size() == 0x0000'0020'0000'0100); + REQUIRE(inode.size() == 0x0000'0020'0000'0100); } THEN("the inode size is 256 if mode = directory") @@ -370,7 +370,7 @@ SCENARIO("Ext2 inode get_size() correctly returns size depending on revision lev auto inode = kernel::filesystem::ext2::inode{&fs, data}; - REQUIRE(inode.get_size() == 256); + REQUIRE(inode.size() == 256); } } } \ No newline at end of file -- cgit v1.2.3 From 3d8ea5b1b833f39b77f0591fb2a301842ed5eb1c Mon Sep 17 00:00:00 2001 From: Marcel Braun Date: Sat, 16 May 2026 17:00:10 +0200 Subject: Refactor data types in ext2 --- kernel/src/filesystem/ext2/filesystem.cpp | 20 ++++++++++---------- kernel/src/filesystem/ext2/inode.cpp | 2 +- 2 files changed, 11 insertions(+), 11 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/filesystem.cpp b/kernel/src/filesystem/ext2/filesystem.cpp index 7633972..df5b4c4 100644 --- a/kernel/src/filesystem/ext2/filesystem.cpp +++ b/kernel/src/filesystem/ext2/filesystem.cpp @@ -62,7 +62,7 @@ namespace kernel::filesystem::ext2 auto const & inode_data = ext2_parent->data(); kstd::vector buffer(block_size()); - for (auto i = 0uz; i < inode_block_count(inode_data); ++i) + for (uint32_t i = 0; i < inode_block_count(inode_data); ++i) { auto const global_block_number = map_inode_block_index_to_global_block_number(i, inode_data); auto const block_offset = global_block_number * block_size(); @@ -87,7 +87,7 @@ namespace kernel::filesystem::ext2 return nullptr; } - auto filesystem::read_inode(size_t inode_number) const -> kstd::shared_ptr + auto filesystem::read_inode(uint32_t inode_number) const -> kstd::shared_ptr { auto const inodes_per_group = m_superblock.inodes_per_group; auto const block_group_index = (inode_number - 1) / inodes_per_group; @@ -141,7 +141,7 @@ namespace kernel::filesystem::ext2 return -1; } - auto filesystem::read_singly_indirect_block_number(size_t singly_indirect_block_number, + auto filesystem::read_singly_indirect_block_number(uint32_t singly_indirect_block_number, size_t block_index_in_singly_indirect_block) const -> size_t { if (singly_indirect_block_number == 0) @@ -152,7 +152,7 @@ namespace kernel::filesystem::ext2 return read_block_number_at_index(singly_indirect_block_number, block_index_in_singly_indirect_block); } - auto filesystem::read_doubly_indirect_block_number(size_t doubly_indirect_block_number, + auto filesystem::read_doubly_indirect_block_number(uint32_t doubly_indirect_block_number, size_t block_index_in_doubly_indirect_block) const -> size_t { if (doubly_indirect_block_number == 0) @@ -171,7 +171,7 @@ namespace kernel::filesystem::ext2 return read_singly_indirect_block_number(singly_indirect_block_number, block_index_in_singly_indirect_block); } - auto filesystem::read_triply_indirect_block_number(size_t triply_indirect_block_number, + auto filesystem::read_triply_indirect_block_number(uint32_t triply_indirect_block_number, size_t block_index_in_triply_indirect_block) const -> size_t { if (triply_indirect_block_number == 0) @@ -190,9 +190,9 @@ namespace kernel::filesystem::ext2 return read_doubly_indirect_block_number(doubly_indirect_block_number, block_index_in_doubly_indirect_block); } - auto filesystem::read_block_number_at_index(size_t block_number, size_t index) const -> size_t + auto filesystem::read_block_number_at_index(uint32_t block_number, size_t index) const -> uint32_t { - auto block_number_buffer = 0uz; + uint32_t block_number_buffer = 0; auto const block_start_offset = block_number * block_size(); auto const number_start_address = block_start_offset + index * sizeof(uint32_t); @@ -226,17 +226,17 @@ namespace kernel::filesystem::ext2 return constants::base_block_size << m_superblock.log_block_size; } - auto filesystem::revision_level() const -> size_t + auto filesystem::revision_level() const -> uint32_t { return m_superblock.rev_level; } - auto filesystem::inode_size() const -> size_t + auto filesystem::inode_size() const -> uint16_t { return revision_level() == constants::good_old_revision ? 128 : m_superblock.inode_size; } - auto filesystem::inode_block_count(inode_data const & data) const -> size_t + auto filesystem::inode_block_count(inode_data const & data) const -> uint32_t { return data.blocks / (2 << m_superblock.log_block_size); } diff --git a/kernel/src/filesystem/ext2/inode.cpp b/kernel/src/filesystem/ext2/inode.cpp index f8c818c..35a32ee 100644 --- a/kernel/src/filesystem/ext2/inode.cpp +++ b/kernel/src/filesystem/ext2/inode.cpp @@ -96,7 +96,7 @@ namespace kernel::filesystem::ext2 return (m_data.mode & constants::mode_mask) == constants::mode_symbolic_link; } - auto inode::size() const -> size_t + auto inode::size() const -> uint64_t { uint64_t size = m_data.size; -- cgit v1.2.3 From 2063d3e165a1b92a46c73badf56927228ed4d5e8 Mon Sep 17 00:00:00 2001 From: Marcel Braun Date: Mon, 25 May 2026 10:15:21 +0200 Subject: Refactor ssize_t --- kernel/src/filesystem/ext2/filesystem.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/filesystem.cpp b/kernel/src/filesystem/ext2/filesystem.cpp index df5b4c4..a30149e 100644 --- a/kernel/src/filesystem/ext2/filesystem.cpp +++ b/kernel/src/filesystem/ext2/filesystem.cpp @@ -8,12 +8,12 @@ #include #include +#include #include #include #include #include -#include namespace kernel::filesystem::ext2 { @@ -110,7 +110,7 @@ namespace kernel::filesystem::ext2 } auto filesystem::map_inode_block_index_to_global_block_number(size_t inode_block_index, inode_data data) const - -> ssize_t + -> kstd::ssize_t { if (inode_block_index < constants::direct_block_count) { -- cgit v1.2.3 From e4dfaac871b9c0e38ed3e500f86ff1f74d8a3a52 Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Sun, 31 May 2026 15:55:47 +0200 Subject: refactor and simplify mapping logic --- kernel/src/filesystem/ext2/filesystem.cpp | 101 ++++++++++++------------------ 1 file changed, 39 insertions(+), 62 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/filesystem.cpp b/kernel/src/filesystem/ext2/filesystem.cpp index a30149e..720f0a8 100644 --- a/kernel/src/filesystem/ext2/filesystem.cpp +++ b/kernel/src/filesystem/ext2/filesystem.cpp @@ -11,6 +11,7 @@ #include #include +#include #include #include #include @@ -109,6 +110,15 @@ namespace kernel::filesystem::ext2 return kstd::make_shared(this, new_inode_data); } + auto filesystem::indirect_levels() const -> std::array + { + return { + {{constants::singly_indirect_block_index, block_numbers_per_singly_indirect_block()}, + {constants::doubly_indirect_block_index, block_numbers_per_doubly_indirect_block()}, + {constants::triply_indirect_block_index, block_numbers_per_triply_indirect_block()}} + }; + } + auto filesystem::map_inode_block_index_to_global_block_number(size_t inode_block_index, inode_data data) const -> kstd::ssize_t { @@ -116,78 +126,45 @@ namespace kernel::filesystem::ext2 { return data.block.at(inode_block_index); } - inode_block_index -= constants::direct_block_count; - - if (inode_block_index < block_numbers_per_singly_indirect_block()) - { - auto const singly_indirect_block_number = data.block.at(constants::singly_indirect_block_index); - return read_singly_indirect_block_number(singly_indirect_block_number, inode_block_index); - } - inode_block_index -= block_numbers_per_singly_indirect_block(); - - if (inode_block_index < block_numbers_per_doubly_indirect_block()) - { - auto const doubly_indirect_block_number = data.block.at(constants::doubly_indirect_block_index); - return read_doubly_indirect_block_number(doubly_indirect_block_number, inode_block_index); - } - inode_block_index -= block_numbers_per_doubly_indirect_block(); - if (inode_block_index < block_numbers_per_triply_indirect_block()) - { - auto const triply_indirect_block_number = data.block.at(constants::triply_indirect_block_index); - return read_triply_indirect_block_number(triply_indirect_block_number, inode_block_index); - } - - return -1; - } + inode_block_index -= constants::direct_block_count; + auto const levels = indirect_levels(); - auto filesystem::read_singly_indirect_block_number(uint32_t singly_indirect_block_number, - size_t block_index_in_singly_indirect_block) const -> size_t - { - if (singly_indirect_block_number == 0) + for (auto const & level : levels) { - return 0; - } - - return read_block_number_at_index(singly_indirect_block_number, block_index_in_singly_indirect_block); - } + if (inode_block_index >= level.capacity) + { + inode_block_index -= level.capacity; + continue; + } - auto filesystem::read_doubly_indirect_block_number(uint32_t doubly_indirect_block_number, - size_t block_index_in_doubly_indirect_block) const -> size_t - { - if (doubly_indirect_block_number == 0) - { - return 0; - } + auto block_number = data.block[level.slot_index]; + if (block_number == 0) + { + return 0; + } - auto const singly_indirect_block_index_in_doubly_indirect_block = - block_index_in_doubly_indirect_block / block_numbers_per_singly_indirect_block(); - auto const block_index_in_singly_indirect_block = - block_index_in_doubly_indirect_block % block_numbers_per_singly_indirect_block(); + for (auto stride = level.capacity / block_numbers_per_block();; stride /= block_numbers_per_block()) + { + auto const idx = inode_block_index / stride; + inode_block_index %= stride; - auto const singly_indirect_block_number = - read_block_number_at_index(doubly_indirect_block_number, singly_indirect_block_index_in_doubly_indirect_block); + block_number = read_block_number_at_index(block_number, idx); + if (block_number == 0) + { + return 0; + } - return read_singly_indirect_block_number(singly_indirect_block_number, block_index_in_singly_indirect_block); - } + if (stride == 1) + { + break; + } + } - auto filesystem::read_triply_indirect_block_number(uint32_t triply_indirect_block_number, - size_t block_index_in_triply_indirect_block) const -> size_t - { - if (triply_indirect_block_number == 0) - { - return 0; + return block_number; } - auto const doubly_indirect_block_index_in_triply_indirect_block = - block_index_in_triply_indirect_block / block_numbers_per_doubly_indirect_block(); - auto const block_index_in_doubly_indirect_block = - block_index_in_triply_indirect_block % block_numbers_per_doubly_indirect_block(); - - auto const doubly_indirect_block_number = - read_block_number_at_index(triply_indirect_block_number, doubly_indirect_block_index_in_triply_indirect_block); - - return read_doubly_indirect_block_number(doubly_indirect_block_number, block_index_in_doubly_indirect_block); + return -1; } auto filesystem::read_block_number_at_index(uint32_t block_number, size_t index) const -> uint32_t -- cgit v1.2.3 From f26569c6a4e5f0ed61b7efa81ebdddd532d542c5 Mon Sep 17 00:00:00 2001 From: Lukas Oesch Date: Sun, 31 May 2026 16:06:38 +0200 Subject: small refactoring --- kernel/src/filesystem/ext2/filesystem.cpp | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/filesystem.cpp b/kernel/src/filesystem/ext2/filesystem.cpp index 720f0a8..12aeaaa 100644 --- a/kernel/src/filesystem/ext2/filesystem.cpp +++ b/kernel/src/filesystem/ext2/filesystem.cpp @@ -128,9 +128,8 @@ namespace kernel::filesystem::ext2 } inode_block_index -= constants::direct_block_count; - auto const levels = indirect_levels(); - for (auto const & level : levels) + for (auto const & level : indirect_levels()) { if (inode_block_index >= level.capacity) { -- cgit v1.2.3 From dc9bd3b44cbbd0235a176f05c27eb15ff31f5e09 Mon Sep 17 00:00:00 2001 From: Felix Morgner Date: Fri, 22 May 2026 20:18:05 +0200 Subject: kernel/vfs: prepare fs type registration support --- kernel/src/filesystem/ext2/filesystem.cpp | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/filesystem.cpp b/kernel/src/filesystem/ext2/filesystem.cpp index 12aeaaa..6959653 100644 --- a/kernel/src/filesystem/ext2/filesystem.cpp +++ b/kernel/src/filesystem/ext2/filesystem.cpp @@ -6,6 +6,7 @@ #include #include #include +#include #include #include @@ -18,6 +19,28 @@ namespace kernel::filesystem::ext2 { + + struct type final : kernel::filesystem::type + { + [[nodiscard]] auto name() const noexcept -> std::string_view override + { + return "ext2"; + } + + [[nodiscard]] auto requires_device() const noexcept -> bool override + { + return true; + } + + [[nodiscard]] auto make_instance() const -> kstd::shared_ptr override + { + return kstd::make_shared(); + } + } const constinit type_instance{}; + + [[gnu::section(".vfs_type_descriptors"), gnu::used]] + auto const * const type_descriptor_pointer = static_cast(&type_instance); + auto filesystem::mount(kstd::shared_ptr const & backing_inode) -> operation_result { kernel::filesystem::filesystem::mount(backing_inode); -- cgit v1.2.3 From 86170be29f6cb72b29865db0975de09bec89f854 Mon Sep 17 00:00:00 2001 From: Felix Morgner Date: Mon, 1 Jun 2026 10:40:39 +0200 Subject: kernel/vfs: rename type descriptor section --- kernel/src/filesystem/ext2/filesystem.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/filesystem.cpp b/kernel/src/filesystem/ext2/filesystem.cpp index 6959653..7b5d2d7 100644 --- a/kernel/src/filesystem/ext2/filesystem.cpp +++ b/kernel/src/filesystem/ext2/filesystem.cpp @@ -38,7 +38,7 @@ namespace kernel::filesystem::ext2 } } const constinit type_instance{}; - [[gnu::section(".vfs_type_descriptors"), gnu::used]] + [[gnu::section("vfs_type_descriptors"), gnu::used]] auto const * const type_descriptor_pointer = static_cast(&type_instance); auto filesystem::mount(kstd::shared_ptr const & backing_inode) -> operation_result -- cgit v1.2.3 From d2d4fa3330a09f421b8658c077166cc493532b9e Mon Sep 17 00:00:00 2001 From: Felix Morgner Date: Tue, 2 Jun 2026 10:54:17 +0200 Subject: kernel/vfs: extract fs type registry --- kernel/src/filesystem/ext2/filesystem.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'kernel/src/filesystem/ext2') diff --git a/kernel/src/filesystem/ext2/filesystem.cpp b/kernel/src/filesystem/ext2/filesystem.cpp index 7b5d2d7..3180a19 100644 --- a/kernel/src/filesystem/ext2/filesystem.cpp +++ b/kernel/src/filesystem/ext2/filesystem.cpp @@ -36,10 +36,10 @@ namespace kernel::filesystem::ext2 { return kstd::make_shared(); } - } const constinit type_instance{}; + }; - [[gnu::section("vfs_type_descriptors"), gnu::used]] - auto const * const type_descriptor_pointer = static_cast(&type_instance); + [[gnu::used]] + constexpr auto registration = type_registration{}; auto filesystem::mount(kstd::shared_ptr const & backing_inode) -> operation_result { -- cgit v1.2.3