remove unneeded function

3 files changed, 31 insertions, 43 deletions

diff --git a/kernel/kernel/filesystem/ext2/filesystem.cpp b/kernel/kernel/filesystem/ext2/filesystem.cpp
index a5bc5f4d..97f13b93 100644
--- a/kernel/kernel/filesystem/ext2/filesystem.cpp
+++ b/kernel/kernel/filesystem/ext2/filesystem.cpp
@@ -23,7 +23,6 @@
 #include <cstddef>
 #include <cstdint>
 #include <expected>
-#include <optional>
 #include <string_view>
 #include <tuple>
 
@@ -220,6 +219,11 @@ namespace kernel::filesystem::ext2
       }
     }
 
+    if (auto write_result = write_inode(inode_number, new_inode_data); !write_result)
+    {
+      return kstd::failure(write_result.error());
+    }
+
     return new_inode;
   }
 
@@ -663,21 +667,6 @@ namespace kernel::filesystem::ext2
     return kstd::success();
   }
 
-  auto filesystem::ensure_and_get_block(uint32_t block_number) -> std::optional<uint32_t>
-  {
-    if (block_number != 0)
-    {
-      return block_number;
-    }
-
-    if (auto allocated = allocate_blocks(1))
-    {
-      return allocated->front();
-    }
-
-    return std::nullopt;
-  }
-
   auto filesystem::read_block(uint32_t block_number, void * buffer) const -> kstd::result<size_t>
   {
     auto const block_offset = static_cast<size_t>(block_number) * block_size();
diff --git a/kernel/kernel/filesystem/ext2/filesystem.hpp b/kernel/kernel/filesystem/ext2/filesystem.hpp
index e8f72727..03398f00 100644
--- a/kernel/kernel/filesystem/ext2/filesystem.hpp
+++ b/kernel/kernel/filesystem/ext2/filesystem.hpp
@@ -180,8 +180,6 @@ namespace kernel::filesystem::ext2
     [[nodiscard]] auto read_inode(uint32_t inode_number) const -> kstd::result<kstd::shared_ptr<inode>>;
     [[nodiscard]] auto read_block_number_at_index(uint32_t block_number, size_t index) const -> kstd::result<uint32_t>;
 
-    auto ensure_and_get_block(uint32_t block_number) -> std::optional<uint32_t>;
-
     [[nodiscard]] auto block_group_descriptor_table_offset() const -> size_t;
 
     [[nodiscard]] auto block_numbers_per_block() const -> size_t;
diff --git a/kernel/kernel/filesystem/ext2/filesystem.tests.cpp b/kernel/kernel/filesystem/ext2/filesystem.tests.cpp
index 277ff385..74e99c26 100644
--- a/kernel/kernel/filesystem/ext2/filesystem.tests.cpp
+++ b/kernel/kernel/filesystem/ext2/filesystem.tests.cpp
@@ -36,7 +36,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture,
     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);
+    REQUIRE(boot_device);
 
     auto dev_inode = kstd::make_shared<kernel::filesystem::device_inode>(boot_device);
 
@@ -45,7 +45,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture,
 
     THEN("the root inode is available and is a directory")
     {
-      REQUIRE(fs.root_inode() != nullptr);
+      REQUIRE(fs.root_inode());
       REQUIRE(fs.root_inode()->is_directory());
     }
 
@@ -86,70 +86,71 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture,
     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);
+    REQUIRE(boot_device);
 
     auto dev_inode = kstd::make_shared<kernel::filesystem::device_inode>(boot_device);
 
     auto fs = kernel::filesystem::ext2::filesystem{};
-    REQUIRE(fs.mount(dev_inode) == kernel::filesystem::filesystem::operation_result::success);
+    REQUIRE(fs.mount(dev_inode));
 
     THEN("a file can be created")
     {
       auto lookup_result = fs.lookup(fs.root_inode(), "blub");
-      REQUIRE(lookup_result == nullptr);
+      REQUIRE(!lookup_result);
 
       auto new_inode = fs.create_inode(fs.root_inode(), "blub", kernel::filesystem::vfs_types::inode_type::regular);
-      REQUIRE(new_inode != nullptr);
-      REQUIRE(new_inode->is_regular());
+      REQUIRE(new_inode);
+      REQUIRE(new_inode.value()->is_regular());
 
       lookup_result = fs.lookup(fs.root_inode(), "blub");
-      REQUIRE(lookup_result != nullptr);
+      REQUIRE(lookup_result);
     }
 
     THEN("a directory can be created")
     {
       auto lookup_result = fs.lookup(fs.root_inode(), "blub");
-      REQUIRE(lookup_result == nullptr);
+      REQUIRE(!lookup_result);
 
       auto new_directory =
           fs.create_inode(fs.root_inode(), "blub", kernel::filesystem::vfs_types::inode_type::directory);
-      REQUIRE(new_directory != nullptr);
-      REQUIRE(new_directory->is_directory());
+      REQUIRE(new_directory);
+      REQUIRE(new_directory.value()->is_directory());
 
       lookup_result = fs.lookup(fs.root_inode(), "blub");
-      REQUIRE(lookup_result != nullptr);
+      REQUIRE(lookup_result);
     }
 
     THEN("a directory and a file within can be created")
     {
       auto new_directory =
           fs.create_inode(fs.root_inode(), "blub", kernel::filesystem::vfs_types::inode_type::directory);
-      REQUIRE(new_directory != nullptr);
+      REQUIRE(new_directory);
 
-      auto new_file = fs.create_inode(new_directory, "blub_file", kernel::filesystem::vfs_types::inode_type::regular);
-      REQUIRE(new_file != nullptr);
+      auto new_file =
+          fs.create_inode(new_directory.value(), "blub_file", kernel::filesystem::vfs_types::inode_type::regular);
+      REQUIRE(new_file);
 
-      auto lookup_result = fs.lookup(new_directory, "blub_file");
-      REQUIRE(lookup_result != nullptr);
-      REQUIRE(lookup_result->is_regular());
+      auto lookup_result = fs.lookup(new_directory.value(), "blub_file");
+      REQUIRE(lookup_result);
+      REQUIRE(lookup_result.value()->is_regular());
     }
 
     THEN("a file can be created and written to")
     {
       auto new_inode = fs.create_inode(fs.root_inode(), "blub", kernel::filesystem::vfs_types::inode_type::regular);
-      REQUIRE(new_inode != nullptr);
+      REQUIRE(new_inode);
 
       auto buffer = std::vector<std::byte>{std::byte{'H'}, std::byte{'e'}, std::byte{'l'}, std::byte{'l'},
                                            std::byte{'o'}, std::byte{' '}, std::byte{'W'}, std::byte{'o'},
                                            std::byte{'r'}, std::byte{'l'}, std::byte{'d'}, std::byte{'!'}};
-      auto bytes_written = new_inode->write(buffer.data(), 0, buffer.size());
+      auto bytes_written = new_inode.value()->write(buffer.data(), 0, buffer.size());
       REQUIRE(bytes_written == buffer.size());
 
       auto read_buffer = std::vector<std::byte>(5, std::byte{0xAA});
-      auto bytes_read = new_inode->read(read_buffer.data(), 0, read_buffer.size());
+      auto bytes_read = new_inode.value()->read(read_buffer.data(), 0, read_buffer.size());
       REQUIRE(bytes_read == read_buffer.size());
 
-      std::string_view result{reinterpret_cast<char *>(read_buffer.data()), static_cast<size_t>(bytes_read)};
+      std::string_view result{reinterpret_cast<char *>(read_buffer.data()), static_cast<size_t>(*bytes_read)};
       REQUIRE(result == "Hello");
     }
   }
@@ -161,7 +162,7 @@ SCENARIO("Ext2 filesystem rejects invalid magic", "[filesystem][ext2][filesystem
   GIVEN("a block device that does not contain an ext2 superblock")
   {
     auto device = kstd::make_shared<kernel::tests::devices::block_device>(0, 0, "mock", block_size, 2 * block_size);
-    REQUIRE(device != nullptr);
+    REQUIRE(device);
 
     auto dev_inode = kstd::make_shared<kernel::filesystem::device_inode>(device);
 
@@ -181,7 +182,7 @@ SCENARIO("Ext2 block mapping includes direct and all indirect levels", "[filesys
   GIVEN("a minimally valid ext2 layout with configured indirect block tables")
   {
     auto device = kstd::make_shared<kernel::tests::devices::block_device>(0, 0, "mock", block_size, 128 * block_size);
-    REQUIRE(device != nullptr);
+    REQUIRE(device);
 
     kernel::tests::filesystem::ext2::setup_mock_ext2_layout(*device);
 
@@ -233,7 +234,7 @@ SCENARIO("Ext2 block writing includes direct and all indirect levels", "[filesys
   GIVEN("a mounted ext2 filesystem with free blocks available for indirect table allocation")
   {
     auto device = kstd::make_shared<kernel::tests::devices::block_device>(0, 0, "mock", block_size, 256 * block_size);
-    REQUIRE(device != nullptr);
+    REQUIRE(device);
 
     auto superblock = kernel::filesystem::ext2::superblock{};
     superblock.magic = kernel::filesystem::ext2::constants::magic_number;