always set all access rights, update parent's inode size

3 files changed, 65 insertions, 22 deletions

diff --git a/kernel/kernel/filesystem/ext2/filesystem.cpp b/kernel/kernel/filesystem/ext2/filesystem.cpp
index 97f13b93..091b1399 100644
--- a/kernel/kernel/filesystem/ext2/filesystem.cpp
+++ b/kernel/kernel/filesystem/ext2/filesystem.cpp
@@ -195,7 +195,8 @@ namespace kernel::filesystem::ext2
 
     inode_data new_inode_data{};
 
-    new_inode_data.mode = map_vfs_inode_type_to_inode_mode(inode_type);
+    uint16_t const full_access_mode = 0x01FF;  // TODO use correct access rights
+    new_inode_data.mode = map_vfs_inode_type_into_inode_mode(inode_type, full_access_mode);
     new_inode_data.size = 0;
     new_inode_data.dir_acl = 0;
     new_inode_data.links_count = 1;
@@ -213,13 +214,14 @@ namespace kernel::filesystem::ext2
 
     if (new_inode->is_directory())
     {
+      // TODO increment used_dirs_count in block group descriptor
       if (auto result = init_directory(new_inode, ext2_parent); !result)
       {
         return kstd::failure(result.error());
       }
     }
 
-    if (auto write_result = write_inode(inode_number, new_inode_data); !write_result)
+    if (auto write_result = write_inode(inode_number, new_inode->data()); !write_result)
     {
       return kstd::failure(write_result.error());
     }
@@ -272,26 +274,32 @@ namespace kernel::filesystem::ext2
       return global_block.and_then([&](auto block_number) { return write_block(block_number, buffer.data()); })
           .transform([](auto) {});
     }
-
-    if (!ext2_parent->append_blocks(1))
+    else
     {
-      return kstd::failure(ext2_errc::not_enough_free_blocks);
-    }
+      if (!ext2_parent->append_blocks(1))
+      {
+        return kstd::failure(ext2_errc::not_enough_free_blocks);
+      }
 
-    auto new_last_block_index = inode_block_count(ext2_parent->data()) - 1;
+      auto const new_block_index = inode_block_count(ext2_parent->data()) - 1;
+      auto const new_global_block = map_inode_block_index_to_global_block_number(new_block_index, ext2_parent->data());
+      if (!new_global_block)
+      {
+        return kstd::failure(new_global_block.error());
+      }
 
-    auto new_global_block = map_inode_block_index_to_global_block_number(new_last_block_index, ext2_parent->data());
-    if (!new_global_block)
-    {
-      return kstd::failure(new_global_block.error());
+      kstd::libc::memset(buffer.data(), 0, block_size());
+      write_directory_entry_to_buffer(buffer.data(), 0, child_inode_number, name, file_type);
+      if (auto update_result =
+              new_global_block.and_then([&](auto block_number) { return write_block(block_number, buffer.data()); });
+          !update_result)
+      {
+        return kstd::failure(update_result.error());
+      }
     }
 
-    kstd::libc::memset(buffer.data(), 0, block_size());
-    write_directory_entry_to_buffer(buffer.data(), 0, child_inode_number, name, file_type);
-
-    return write_block(static_cast<uint32_t>(*new_global_block), buffer.data()).and_then([&](auto) {
-      return write_inode(ext2_parent->number(), ext2_parent->data());
-    });
+    ext2_parent->data_mutable().size = inode_block_count(ext2_parent->data()) * block_size();
+    return write_inode(ext2_parent->number(), ext2_parent->data());
   }
 
   auto filesystem::init_directory(kstd::shared_ptr<kernel::filesystem::ext2::inode> const & new_inode,
@@ -712,16 +720,17 @@ namespace kernel::filesystem::ext2
     }
   }
 
-  auto filesystem::map_vfs_inode_type_to_inode_mode(kernel::filesystem::vfs_types::inode_type vfs_type) -> uint16_t
+  auto filesystem::map_vfs_inode_type_into_inode_mode(kernel::filesystem::vfs_types::inode_type vfs_type, uint16_t mode)
+      -> uint16_t
   {
     switch (vfs_type)
     {
       case kernel::filesystem::vfs_types::inode_type::directory:
-        return constants::mode_directory;
+        return mode | constants::mode_directory;
       case kernel::filesystem::vfs_types::inode_type::regular:
-        return constants::mode_regular;
+        return mode | constants::mode_regular;
       case kernel::filesystem::vfs_types::inode_type::symbolic_link:
-        // return constants::mode_symbolic_link; // TODO implement
+        // return mode | constants::mode_symbolic_link; // TODO implement
       default:
         kapi::system::panic("[EXT2] Not implemented.");
     }
diff --git a/kernel/kernel/filesystem/ext2/filesystem.hpp b/kernel/kernel/filesystem/ext2/filesystem.hpp
index 9af9aeb1..e5192ec0 100644
--- a/kernel/kernel/filesystem/ext2/filesystem.hpp
+++ b/kernel/kernel/filesystem/ext2/filesystem.hpp
@@ -191,7 +191,8 @@ namespace kernel::filesystem::ext2
     [[nodiscard]] auto write_superblock() const -> kstd::result<void>;
 
     auto map_inode_mode_to_file_type(uint16_t mode) -> uint8_t;
-    auto map_vfs_inode_type_to_inode_mode(kernel::filesystem::vfs_types::inode_type vfs_type) -> uint16_t;
+    auto map_vfs_inode_type_into_inode_mode(kernel::filesystem::vfs_types::inode_type vfs_type, uint16_t mode)
+        -> uint16_t;
 
     superblock m_superblock{};
     kstd::vector<block_group_descriptor> m_block_group_descriptors;
diff --git a/kernel/kernel/main.cpp b/kernel/kernel/main.cpp
index 8dce5143..2da18e0b 100644
--- a/kernel/kernel/main.cpp
+++ b/kernel/kernel/main.cpp
@@ -107,6 +107,39 @@ auto run_demo() -> void
   kstd::println("--> written {} bytes to /dev/ram32: {::#04x}", bytes_written, write_buffer);
 
   // 10) do memory dump to show that the write to the device file had an effect
+
+  // 11) dmp the module before create new directory and file
+  // -exec monitor memsave 0xffffffff80259000 0xA00000 dump_before.bin
+
+  // 12) create new folder and file
+  auto creation_result = kapi::filesystem::mkdir("/test_files").and_then([] {
+    return kapi::filesystem::create("/test_files/test_file.txt");
+  });
+
+  if (!creation_result)
+  {
+    kapi::system::panic("demo failed", creation_result.error());
+  }
+
+  // 13) write to the new file
+  auto fd_4 = kapi::filesystem::open("/test_files/test_file.txt");
+  if (fd_4)
+  {
+    kstd::println("--> successfully opened /test_files/test_file.txt as a file with file descriptor {}", fd_4.value());
+  }
+  else
+  {
+    kapi::system::panic("demo failed");
+  }
+
+  kstd::vector<std::byte> test_write_buffer{
+    std::byte{'H'}, std::byte{'e'}, std::byte{'l'}, std::byte{'l'}, std::byte{'o'}, std::byte{' '}, std::byte{'T'},
+    std::byte{'e'}, std::byte{'a'}, std::byte{'c'}, std::byte{'h'}, std::byte{'O'}, std::byte{'S'}};
+  bytes_written = *kapi::filesystem::write(*fd_4, test_write_buffer.data(), test_write_buffer.size());
+  kstd::println("--> written {} bytes to /test_files/test_file.txt: {::#04x}", bytes_written, test_write_buffer);
+
+  // 14) dmp the module after create new directory and file
+  // -exec monitor memsave 0xffffffff80259000 0xA00000 dump_after.bin
 }
 
 auto main() -> int