chore: apply stylistic cleanups

30 files changed, 216 insertions, 209 deletions

diff --git a/kernel/kapi/devices/bus.cpp b/kernel/kapi/devices/bus.cpp
index e4b5a2c5..300151d5 100644
--- a/kernel/kapi/devices/bus.cpp
+++ b/kernel/kapi/devices/bus.cpp
@@ -34,7 +34,7 @@ namespace kapi::devices
     }
   }
 
-  auto bus::add_child(kstd::shared_ptr<device> child) -> void
+  auto bus::add_child(kstd::shared_ptr<device> const & child) -> void
   {
     {
       auto guard = kstd::lock_guard{m_lock};
diff --git a/kernel/kapi/devices/device_registry.cpp b/kernel/kapi/devices/device_registry.cpp
index 080ae39b..09da35ae 100644
--- a/kernel/kapi/devices/device_registry.cpp
+++ b/kernel/kapi/devices/device_registry.cpp
@@ -42,7 +42,7 @@ namespace kapi::devices
     return *instance;
   }
 
-  auto device_registry::add(kstd::shared_ptr<device> device) -> bool
+  auto device_registry::add(kstd::shared_ptr<device> const & device) -> bool
   {
     if (!device)
     {
diff --git a/kernel/kapi/filesystem.cpp b/kernel/kapi/filesystem.cpp
index 2f3c524e..8ebda7cc 100644
--- a/kernel/kapi/filesystem.cpp
+++ b/kernel/kapi/filesystem.cpp
@@ -38,7 +38,7 @@ namespace kapi::filesystem
         .and_then([](auto file_descriptor) { return kernel::vfs::open_file_table::get().add_file(file_descriptor); });
   }
 
-  auto close(size_t file_descriptor) -> kstd::result<void>
+  auto close(std::size_t file_descriptor) -> kstd::result<void>
   {
     return kernel::vfs::open_file_table::get()
         .file(file_descriptor)
@@ -47,21 +47,21 @@ namespace kapi::filesystem
         .and_then([=]() { return kernel::vfs::open_file_table::get().remove_file(file_descriptor); });
   }
 
-  auto read(size_t file_descriptor, std::span<std::byte> buffer) -> kstd::result<kstd::bytes>
+  auto read(std::size_t file_descriptor, std::span<std::byte> buffer) -> kstd::result<kstd::bytes>
   {
     return kernel::vfs::open_file_table::get().file(file_descriptor).and_then([=](auto descriptor) {
       return descriptor->read(buffer);
     });
   }
 
-  auto write(size_t file_descriptor, std::span<std::byte const> buffer) -> kstd::result<kstd::bytes>
+  auto write(std::size_t file_descriptor, std::span<std::byte const> buffer) -> kstd::result<kstd::bytes>
   {
     return kernel::vfs::open_file_table::get().file(file_descriptor).and_then([=](auto descriptor) {
       return descriptor->write(buffer);
     });
   }
 
-  auto seek(size_t file_descriptor, kstd::offset offset, seek_origin origin) -> kstd::result<kstd::bytes>
+  auto seek(std::size_t file_descriptor, kstd::offset offset, seek_origin origin) -> kstd::result<kstd::bytes>
   {
     return kernel::vfs::open_file_table::get().file(file_descriptor).and_then([=](auto file) {
       return file->seek(offset, origin);
diff --git a/kernel/kapi/filesystem.tests.cpp b/kernel/kapi/filesystem.tests.cpp
index 6fa2de3d..efcb4fd3 100644
--- a/kernel/kapi/filesystem.tests.cpp
+++ b/kernel/kapi/filesystem.tests.cpp
@@ -258,7 +258,8 @@ SCENARIO_METHOD(kernel::tests::vfs::storage_boot_module_vfs_fixture, "Kapi files
       auto read_buffer = std::vector<std::byte>(4);
       auto bytes_read = kapi::filesystem::read(*fd, read_buffer);
 
-      std::string_view buffer_as_str{reinterpret_cast<char *>(read_buffer.data()), static_cast<size_t>(*bytes_read)};
+      std::string_view buffer_as_str{reinterpret_cast<char *>(read_buffer.data()),
+                                     static_cast<std::size_t>(*bytes_read)};
       REQUIRE(buffer_as_str == "Test");
 
       REQUIRE(kapi::filesystem::close(*fd));
diff --git a/kernel/kernel/devices/block_device_utils.cpp b/kernel/kernel/devices/block_device_utils.cpp
index 398e5e2a..473df371 100644
--- a/kernel/kernel/devices/block_device_utils.cpp
+++ b/kernel/kernel/devices/block_device_utils.cpp
@@ -18,7 +18,7 @@ namespace kernel::devices::block_device_utils
 
   namespace
   {
-    using block_op = kstd::result<kstd::bytes> (*)(size_t idx, kstd::bytes off, kstd::bytes len, kstd::bytes done,
+    using block_op = kstd::result<kstd::bytes> (*)(std::size_t idx, kstd::bytes off, kstd::bytes len, kstd::bytes done,
                                                    kapi::filesystem::block_special_file & device,
                                                    std::span<std::byte> scratch, std::span<std::byte> buffer);
 
@@ -64,7 +64,7 @@ namespace kernel::devices::block_device_utils
     }
   }  // namespace
 
-  auto calculate_transfer(kapi::filesystem::block_special_file const & device, size_t block_index) -> transfer_info
+  auto calculate_transfer(kapi::filesystem::block_special_file const & device, std::size_t block_index) -> transfer_info
   {
     auto const offset = block_index * device.block_size();
     auto const limit = device.capacity();
diff --git a/kernel/kernel/devices/block_device_utils.hpp b/kernel/kernel/devices/block_device_utils.hpp
index b9c8c416..1fb7cd9d 100644
--- a/kernel/kernel/devices/block_device_utils.hpp
+++ b/kernel/kernel/devices/block_device_utils.hpp
@@ -21,7 +21,7 @@ namespace kernel::devices::block_device_utils
     kstd::bytes remainder;
   };
 
-  [[nodiscard]] auto calculate_transfer(kapi::filesystem::block_special_file const & device, size_t block_index)
+  [[nodiscard]] auto calculate_transfer(kapi::filesystem::block_special_file const & device, std::size_t block_index)
       -> transfer_info;
 
   //! Read data from a block device into a given buffer.
diff --git a/kernel/kernel/devices/block_device_utils.tests.cpp b/kernel/kernel/devices/block_device_utils.tests.cpp
index 576c9284..9d90259b 100644
--- a/kernel/kernel/devices/block_device_utils.tests.cpp
+++ b/kernel/kernel/devices/block_device_utils.tests.cpp
@@ -23,7 +23,7 @@ SCENARIO("reading from a block device with block_device_utils", "[devices][block
     auto const block_size = 512_B;
     auto device = kstd::make_shared<kernel::tests::devices::block_device>("test_block_device", block_size);
     kstd::vector<std::byte> block_data(block_size.value);
-    for (size_t i = 0; i < block_data.size(); ++i)
+    for (std::size_t i = 0; i < block_data.size(); ++i)
     {
       block_data[i] = static_cast<std::byte>(i % 256);
     }
@@ -58,7 +58,7 @@ SCENARIO("reading from a block device with block_device_utils", "[devices][block
 
       THEN("the data read matches the expected data across block boundaries")
       {
-        for (size_t i = 0; i < bytes_read.value().value; ++i)
+        for (std::size_t i = 0; i < bytes_read.value().value; ++i)
         {
           auto expected_value = static_cast<std::byte>((256 + i) % 256);
           REQUIRE(read_buffer[i] == expected_value);
@@ -101,7 +101,7 @@ SCENARIO("writing to a block device using block_device_utils", "[devices][block_
     WHEN("writing to the block device using block_device_utils")
     {
       kstd::vector<std::byte> write_buffer(block_size.value);
-      for (size_t i = 0; i < write_buffer.size(); ++i)
+      for (std::size_t i = 0; i < write_buffer.size(); ++i)
       {
         write_buffer[i] = static_cast<std::byte>(i % 256);
       }
@@ -124,7 +124,7 @@ SCENARIO("writing to a block device using block_device_utils", "[devices][block_
     WHEN("writing over block boundaries")
     {
       kstd::vector<std::byte> write_buffer(2 * block_size.value);
-      for (size_t i = 0; i < write_buffer.size(); ++i)
+      for (std::size_t i = 0; i < write_buffer.size(); ++i)
       {
         write_buffer[i] = static_cast<std::byte>(i % 256);
       }
@@ -141,7 +141,7 @@ SCENARIO("writing to a block device using block_device_utils", "[devices][block_
         kstd::vector<std::byte> read_buffer(2 * block_size.value);
         auto bytes_read = kernel::devices::block_device_utils::read(*device, read_buffer, 256_B);
 
-        for (size_t i = 0; i < bytes_read.value().value; ++i)
+        for (std::size_t i = 0; i < bytes_read.value().value; ++i)
         {
           REQUIRE(read_buffer[i] == write_buffer[i]);
         }
diff --git a/kernel/kernel/filesystems/ext2/block_group_descriptor.hpp b/kernel/kernel/filesystems/ext2/block_group_descriptor.hpp
index dd9c3317..d447c855 100644
--- a/kernel/kernel/filesystems/ext2/block_group_descriptor.hpp
+++ b/kernel/kernel/filesystems/ext2/block_group_descriptor.hpp
@@ -9,14 +9,14 @@ namespace kernel::filesystems::ext2
   //! A block group descriptor in the ext2 filesystem.
   struct [[gnu::packed]] block_group_descriptor
   {
-    uint32_t block_bitmap;
-    uint32_t inode_bitmap;
-    uint32_t inode_table;
-    uint16_t free_blocks_count;
-    uint16_t free_inodes_count;
-    uint16_t used_dirs_count;
-    std::array<uint8_t, 2> padding;
-    std::array<uint8_t, 12> reserved;  // NOLINT(readability-magic-numbers)
+    std::uint32_t block_bitmap;
+    std::uint32_t inode_bitmap;
+    std::uint32_t inode_table;
+    std::uint16_t free_blocks_count;
+    std::uint16_t free_inodes_count;
+    std::uint16_t used_dirs_count;
+    std::array<std::uint8_t, 2> padding;
+    std::array<std::uint8_t, 12> reserved;  // NOLINT(readability-magic-numbers)
   };
 }  // namespace kernel::filesystems::ext2
 #endif
\ No newline at end of file
diff --git a/kernel/kernel/filesystems/ext2/filesystem.cpp b/kernel/kernel/filesystems/ext2/filesystem.cpp
index 7eaeeba2..1785c0d7 100644
--- a/kernel/kernel/filesystems/ext2/filesystem.cpp
+++ b/kernel/kernel/filesystems/ext2/filesystem.cpp
@@ -47,8 +47,8 @@ namespace kernel::filesystems::ext2
   {
     struct indirect_level
     {
-      uint32_t slot_index;
-      size_t capacity;
+      std::uint32_t slot_index;
+      std::size_t capacity;
     };
 
     //! Check if the given bit has the bit at the given index set.
@@ -57,7 +57,7 @@ namespace kernel::filesystems::ext2
     //!
     //! @param bitmap The bitmap to check.
     //! @param index The index of the bit to check.
-    [[nodiscard]] constexpr auto bitmap_is_set(kstd::vector<std::byte> const & bitmap, size_t index) -> bool
+    [[nodiscard]] constexpr auto bitmap_is_set(kstd::vector<std::byte> const & bitmap, std::size_t index) -> bool
     {
       auto const byte_index = index / 8;
       auto const bit_index = index % 8;
@@ -70,7 +70,7 @@ namespace kernel::filesystems::ext2
     //!
     //! @param bitmap The bitmap to manipulate.
     //! @param index The index of the bit to set.
-    constexpr auto bitmap_set(kstd::vector<std::byte> & bitmap, size_t index) -> void
+    constexpr auto bitmap_set(kstd::vector<std::byte> & bitmap, std::size_t index) -> void
     {
       auto const byte_index = index / 8;
       auto const bit_index = index % 8;
@@ -114,7 +114,7 @@ namespace kernel::filesystems::ext2
     //!
     //! @param mode The mode to extract the type from.
     //! @return The file type encoded in the mode.
-    constexpr auto to_filetype(uint16_t mode) -> kapi::filesystem::file_type
+    constexpr auto to_filetype(std::uint16_t mode) -> kapi::filesystem::file_type
     {
       switch (mode & constants::mode_mask)
       {
@@ -141,7 +141,7 @@ namespace kernel::filesystems::ext2
     //!
     //! @param type The type to encode.
     //! @param mode The original ext2 file mode.
-    constexpr auto combine(kapi::filesystem::file_type type, uint16_t mode) -> uint16_t
+    constexpr auto combine(kapi::filesystem::file_type type, std::uint16_t mode) -> std::uint16_t
     {
       if (mode & constants::mode_mask)
       {
@@ -210,7 +210,7 @@ namespace kernel::filesystems::ext2
                                          std::string_view name, kapi::filesystem::file_type type)
         -> kstd::result<linked_directory_entry *>
     {
-      auto const name_length = static_cast<uint8_t>(name.size());
+      auto const name_length = static_cast<std::uint8_t>(name.size());
       auto const record_size = (sizeof(linked_directory_entry) - 1 + name_length + 3u) & ~3u;
       if (buffer.size() - offset.value < record_size)
       {
@@ -231,7 +231,7 @@ namespace kernel::filesystems::ext2
     //!
     //! @param state The driver state to operate on.
     //! @return The revision level.
-    [[nodiscard]] constexpr auto revision_level(driver_state const & state) -> uint32_t
+    [[nodiscard]] constexpr auto revision_level(driver_state const & state) -> std::uint32_t
     {
       return state.superblock.rev_level;
     }
@@ -251,7 +251,7 @@ namespace kernel::filesystems::ext2
     //! @param buffer The buffer to read the block data into.
     //! @param state The state to operate on.
     //! @return The number of bytes read.
-    [[nodiscard]] auto read_block(uint32_t block_number, std::span<std::byte> buffer, driver_state const & state)
+    [[nodiscard]] auto read_block(std::uint32_t block_number, std::span<std::byte> buffer, driver_state const & state)
         -> kstd::result<kstd::bytes>
     {
       if (buffer.size() < block_size(state).value)
@@ -259,7 +259,7 @@ namespace kernel::filesystems::ext2
         return kstd::failure(vfs::errc::invalid_argument);
       }
 
-      auto const block_offset = static_cast<size_t>(block_number) * block_size(state);
+      auto const block_offset = static_cast<std::size_t>(block_number) * block_size(state);
       return state.backing_inode->read(buffer, block_offset);
     }
 
@@ -269,7 +269,7 @@ namespace kernel::filesystems::ext2
     //! @param buffer The buffer containing the data to write.
     //! @param state The state to operate on.
     //! @return The number of bytes written.
-    [[nodiscard]] auto write_block(uint32_t block_number, std::span<std::byte const> buffer, driver_state & state)
+    [[nodiscard]] auto write_block(std::uint32_t block_number, std::span<std::byte const> buffer, driver_state & state)
         -> kstd::result<kstd::bytes>
     {
       if (buffer.size() < block_size(state).value)
@@ -277,7 +277,7 @@ namespace kernel::filesystems::ext2
         return kstd::failure(vfs::errc::invalid_argument);
       }
 
-      auto const block_offset = static_cast<size_t>(block_number) * block_size(state);
+      auto const block_offset = static_cast<std::size_t>(block_number) * block_size(state);
       return state.backing_inode->write(buffer, block_offset);
     }
 
@@ -286,7 +286,7 @@ namespace kernel::filesystems::ext2
     //! @param state The driver state to operate on.
     //! @param batch The active write batch.
     //! @return An inode number on success, an error otherwise.
-    auto allocate_inode(driver_state & state, write_batch & batch) -> kstd::result<uint32_t>
+    auto allocate_inode(driver_state & state, write_batch & batch) -> kstd::result<std::uint32_t>
     {
       auto & superblock = state.superblock;
       auto & block_group_descriptors = state.block_group_descriptors;
@@ -311,7 +311,7 @@ namespace kernel::filesystems::ext2
           return kstd::failure(read_result.error());
         }
 
-        for (auto i = 0uz; i < static_cast<size_t>(superblock.inodes_per_group); ++i)
+        for (auto i = 0uz; i < static_cast<std::size_t>(superblock.inodes_per_group); ++i)
         {
           if (!bitmap_is_set(inode_bitmap, i))
           {
@@ -375,7 +375,7 @@ namespace kernel::filesystems::ext2
       }
 
       auto const file_type = to_filetype(mode);
-      auto const name_len = static_cast<uint8_t>(name.size());
+      auto const name_len = static_cast<std::uint8_t>(name.size());
       auto const needed_rec_len = static_cast<kstd::bytes>((8u + name_len + 3u) & ~3u);
 
       auto * last_entry = reinterpret_cast<linked_directory_entry *>(buffer.data() + offset);
@@ -546,12 +546,12 @@ namespace kernel::filesystems::ext2
     //! @param state The driver state to operate on.
     //! @return The block number at the given index in the given indirect block on success, an error otherwise.
     [[nodiscard]] auto read_block_number_at_index(std::uint32_t block, std::size_t index, driver_state const & state)
-        -> kstd::result<uint32_t>
+        -> kstd::result<std::uint32_t>
     {
-      uint32_t block_number_buffer = 0;
+      std::uint32_t block_number_buffer = 0;
 
       auto const block_offset = block * block_size(state);
-      auto const number_offset = block_offset + index * kstd::size_of<uint32_t>();
+      auto const number_offset = block_offset + index * kstd::size_of<std::uint32_t>();
 
       if (auto read_result = state.backing_inode->read(kstd::raw_bytes(block_number_buffer), number_offset);
           !read_result)
@@ -778,7 +778,7 @@ namespace kernel::filesystems::ext2
     return kstd::bytes{constants::base_block_size.value << state.superblock.log_block_size};
   }
 
-  auto block_count(inode const & inode, driver_state const & state) -> uint32_t
+  auto block_count(inode const & inode, driver_state const & state) -> std::uint32_t
   {
     return inode.data().blocks / (2 << state.superblock.log_block_size);
   }
@@ -799,9 +799,9 @@ namespace kernel::filesystems::ext2
   {
     if (revision_level(state) > constants::good_old_revision && inode.is_regular())
     {
-      inode.data().dir_acl = static_cast<uint32_t>(new_size.value >> 32);
+      inode.data().dir_acl = static_cast<std::uint32_t>(new_size.value >> 32);
     }
-    inode.data().size = static_cast<uint32_t>(new_size.value);
+    inode.data().size = static_cast<std::uint32_t>(new_size.value);
   }
 
   auto do_read(inode const & inode, std::span<std::byte> buffer, kstd::bytes offset, driver_state const & state)
@@ -852,7 +852,8 @@ namespace kernel::filesystems::ext2
     return bytes_read;
   }
 
-  auto allocate_blocks(size_t count, driver_state & state, write_batch & batch) -> kstd::result<kstd::vector<uint32_t>>
+  auto allocate_blocks(std::size_t count, driver_state & state, write_batch & batch)
+      -> kstd::result<kstd::vector<std::uint32_t>>
   {
     auto & superblock = state.superblock;
     auto & block_group_descriptors = state.block_group_descriptors;
@@ -870,7 +871,7 @@ namespace kernel::filesystems::ext2
     };
 
     auto pending = kstd::vector<pending_group>{};
-    auto allocated_blocks = kstd::vector<uint32_t>{};
+    auto allocated_blocks = kstd::vector<std::uint32_t>{};
 
     for (auto group_index = 0uz; group_index < block_group_descriptors.size() && allocated_blocks.size() < count;
          ++group_index)
@@ -888,7 +889,8 @@ namespace kernel::filesystems::ext2
       }
 
       auto claimed = 0uz;
-      for (auto i = 0uz; i < static_cast<size_t>(superblock.blocks_per_group) && allocated_blocks.size() < count; ++i)
+      for (auto i = 0uz; i < static_cast<std::size_t>(superblock.blocks_per_group) && allocated_blocks.size() < count;
+           ++i)
       {
         if (!bitmap_is_set(block_bitmap, i))
         {
@@ -925,12 +927,12 @@ namespace kernel::filesystems::ext2
     return allocated_blocks;
   }
 
-  auto update_inode_block_count(inode_data & data, uint32_t delta, driver_state & state) -> void
+  auto update_inode_block_count(inode_data & data, std::uint32_t delta, driver_state & state) -> void
   {
     data.blocks += delta * (2 << state.superblock.log_block_size);
   }
 
-  auto write_inode(uint32_t inode_number, inode_data const & data, driver_state & state) -> kstd::result<void>
+  auto write_inode(std::uint32_t inode_number, inode_data const & data, driver_state & state) -> kstd::result<void>
   {
     if (auto inode_offset = calculate_inode_offset(inode_number, state))
     {
@@ -942,7 +944,8 @@ namespace kernel::filesystems::ext2
     }
   }
 
-  auto inode_block_number(size_t index, inode const & inode, driver_state const & state) -> kstd::result<std::size_t>
+  auto inode_block_number(std::size_t index, inode const & inode, driver_state const & state)
+      -> kstd::result<std::size_t>
   {
     auto const & block_array = inode.data().block;
 
@@ -1000,8 +1003,8 @@ namespace kernel::filesystems::ext2
     return kstd::failure(errc::invalid_block_index);
   }
 
-  auto write_global_block_number_to_inode_block_index(size_t inode_block_index, inode_data & data,
-                                                      uint32_t global_block_number, driver_state & state,
+  auto write_global_block_number_to_inode_block_index(std::size_t inode_block_index, inode_data & data,
+                                                      std::uint32_t global_block_number, driver_state & state,
                                                       write_batch & batch) -> kstd::result<void>
   {
     if (inode_block_index < constants::direct_block_count)
@@ -1055,7 +1058,7 @@ namespace kernel::filesystems::ext2
           }
         }
 
-        auto const byte_offset = block_number * block_size + idx * kstd::size_of<uint32_t>();
+        auto const byte_offset = block_number * block_size + idx * kstd::size_of<std::uint32_t>();
 
         if (stride == 1)
         {
@@ -1084,7 +1087,7 @@ namespace kernel::filesystems::ext2
   }
 
   auto write_block_group_descriptor(block_group_descriptor const & block_group_descriptor,
-                                    size_t block_group_descriptor_index, driver_state const & state)
+                                    std::size_t block_group_descriptor_index, driver_state const & state)
       -> kstd::result<void>
   {
     // TODO update all block group descriptors
diff --git a/kernel/kernel/filesystems/ext2/filesystem.hpp b/kernel/kernel/filesystems/ext2/filesystem.hpp
index 7ea7b43a..15328d94 100644
--- a/kernel/kernel/filesystems/ext2/filesystem.hpp
+++ b/kernel/kernel/filesystems/ext2/filesystem.hpp
@@ -32,26 +32,26 @@ namespace kernel::filesystems::ext2
   {
     constexpr kstd::bytes inline base_block_size = kstd::bytes{1024};
     constexpr kstd::bytes inline superblock_offset = base_block_size;
-    constexpr uint16_t inline magic_number = 0xEF53;
+    constexpr std::uint16_t inline magic_number = 0xEF53;
 
-    constexpr uint32_t inline good_old_revision = 0;
-    constexpr uint32_t inline dynamic_revision = 1;
+    constexpr std::uint32_t inline good_old_revision = 0;
+    constexpr std::uint32_t inline dynamic_revision = 1;
 
-    constexpr uint32_t inline root_inode_number = 2;
+    constexpr std::uint32_t inline root_inode_number = 2;
 
-    constexpr size_t inline direct_block_count = 12;
-    constexpr size_t inline singly_indirect_block_index = direct_block_count;
-    constexpr size_t inline doubly_indirect_block_index = singly_indirect_block_index + 1;
-    constexpr size_t inline triply_indirect_block_index = doubly_indirect_block_index + 1;
+    constexpr std::size_t inline direct_block_count = 12;
+    constexpr std::size_t inline singly_indirect_block_index = direct_block_count;
+    constexpr std::size_t inline doubly_indirect_block_index = singly_indirect_block_index + 1;
+    constexpr std::size_t inline triply_indirect_block_index = doubly_indirect_block_index + 1;
 
-    constexpr uint16_t inline mode_mask = 0xF000;
-    constexpr uint16_t inline mode_regular = 0x8000;
-    constexpr uint16_t inline mode_directory = 0x4000;
-    constexpr uint16_t inline mode_symbolic_link = 0xA000;
-    constexpr uint16_t inline mode_block_device = 0x6000;
-    constexpr uint16_t inline mode_character_device = 0x2000;
-    constexpr uint16_t inline mode_fifo = 0x1000;
-    constexpr uint16_t inline mode_socket = 0xC000;
+    constexpr std::uint16_t inline mode_mask = 0xF000;
+    constexpr std::uint16_t inline mode_regular = 0x8000;
+    constexpr std::uint16_t inline mode_directory = 0x4000;
+    constexpr std::uint16_t inline mode_symbolic_link = 0xA000;
+    constexpr std::uint16_t inline mode_block_device = 0x6000;
+    constexpr std::uint16_t inline mode_character_device = 0x2000;
+    constexpr std::uint16_t inline mode_fifo = 0x1000;
+    constexpr std::uint16_t inline mode_socket = 0xC000;
 
   }  // namespace constants
 
@@ -87,7 +87,7 @@ namespace kernel::filesystems::ext2
   //! @param inode The inode whose block count to query.
   //! @param state The driver state to operate on.
   //! @return The number of blocks allocated to the inode.
-  [[nodiscard]] auto block_count(inode const & inode, driver_state const & state) -> uint32_t;
+  [[nodiscard]] auto block_count(inode const & inode, driver_state const & state) -> std::uint32_t;
 
   //! Determine the size of an inode's data on disk.
   //!
@@ -119,21 +119,22 @@ namespace kernel::filesystems::ext2
   //! @param state The state to operate on.
   //! @param batch The active write batch.
   //! @return A vector of the allocated block numbers.
-  auto allocate_blocks(size_t count, driver_state & state, write_batch & batch) -> kstd::result<kstd::vector<uint32_t>>;
+  auto allocate_blocks(std::size_t count, driver_state & state, write_batch & batch)
+      -> kstd::result<kstd::vector<std::uint32_t>>;
 
   //! Update the number of blocks allocated to an inode.
   //!
   //! @param data The inode data.
   //! @param state The state to operate on.
   //! @param delta The change in the number of blocks.
-  auto update_inode_block_count(inode_data & data, uint32_t delta, driver_state & state) -> void;
+  auto update_inode_block_count(inode_data & data, std::uint32_t delta, driver_state & state) -> void;
 
   //! Write an inode to the backing inode.
   //!
   //! @param inode_number The number of the inode to write.
   //! @param state The state to operate on.
   //! @param data The inode data to write.
-  auto write_inode(uint32_t inode_number, inode_data const & data, driver_state & state) -> kstd::result<void>;
+  auto write_inode(std::uint32_t inode_number, inode_data const & data, driver_state & state) -> kstd::result<void>;
 
   //! Get the block number associated with the nth block of an inode.
   //!
@@ -141,7 +142,7 @@ namespace kernel::filesystems::ext2
   //! @param inode The inode.
   //! @param state The state to operate on.
   //! @return The global block number on success, an error otherwise.
-  [[nodiscard]] auto inode_block_number(size_t index, inode const & inode, driver_state const & state)
+  [[nodiscard]] auto inode_block_number(std::size_t index, inode const & inode, driver_state const & state)
       -> kstd::result<std::size_t>;
 
   //! Write a global block number to an inode block index.
@@ -151,12 +152,12 @@ namespace kernel::filesystems::ext2
   //! @param global_block_number The global block number to write.
   //! @param state The state to operate on.
   //! @param batch The active write batch.
-  auto write_global_block_number_to_inode_block_index(size_t block_index, inode_data & data,
-                                                      uint32_t global_block_number, driver_state & state,
+  auto write_global_block_number_to_inode_block_index(std::size_t block_index, inode_data & data,
+                                                      std::uint32_t global_block_number, driver_state & state,
                                                       write_batch & batch) -> kstd::result<void>;
 
   [[nodiscard]] auto write_block_group_descriptor(block_group_descriptor const & block_group_descriptor,
-                                                  size_t block_group_descriptor_index, driver_state const & state)
+                                                  std::size_t block_group_descriptor_index, driver_state const & state)
       -> kstd::result<void>;
   [[nodiscard]] auto write_superblock(driver_state & state) -> kstd::result<void>;
 }  // namespace kernel::filesystems::ext2
diff --git a/kernel/kernel/filesystems/ext2/filesystem.tests.cpp b/kernel/kernel/filesystems/ext2/filesystem.tests.cpp
index 7477a51b..01dc3ad5 100644
--- a/kernel/kernel/filesystems/ext2/filesystem.tests.cpp
+++ b/kernel/kernel/filesystems/ext2/filesystem.tests.cpp
@@ -173,7 +173,7 @@ SCENARIO_METHOD(kernel::tests::vfs::storage_boot_module_fixture, "Ext2 filesyste
       auto bytes_read = new_inode.value()->read(read_buffer, 0_B);
       REQUIRE(bytes_read == kstd::bytes{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<std::size_t>(*bytes_read)};
       REQUIRE(result == "Hello");
     }
   }
@@ -232,8 +232,8 @@ SCENARIO("Ext2 block mapping includes direct and all indirect levels", "[filesys
     kernel::tests::filesystems::ext2::write_u32(*device, 51 * block_size, 52);
     kernel::tests::filesystems::ext2::write_u32(*device, 52 * block_size, 53);
 
-    auto const numbers_per_block = static_cast<uint32_t>(block_size / kstd::size_of<uint32_t>());
-    auto const singly_start = static_cast<uint32_t>(kernel::filesystems::ext2::constants::direct_block_count);
+    auto const numbers_per_block = static_cast<std::uint32_t>(block_size / kstd::size_of<std::uint32_t>());
+    auto const singly_start = static_cast<std::uint32_t>(kernel::filesystems::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;
 
@@ -295,16 +295,16 @@ SCENARIO("Ext2 block writing includes direct and all indirect levels", "[filesys
     auto driver_state = static_pointer_cast<kernel::filesystems::ext2::driver_state>(mount->second);
     REQUIRE(driver_state);
 
-    auto read_u32 = [&](kstd::bytes offset) -> uint32_t {
-      auto value = uint32_t{0};
+    auto read_u32 = [&](kstd::bytes offset) -> std::uint32_t {
+      auto value = std::uint32_t{0};
       std::memcpy(&value, device->data.data() + offset, sizeof(value));
       return value;
     };
 
     auto inode_data = kernel::filesystems::ext2::inode_data{};
 
-    auto const numbers_per_block = static_cast<uint32_t>(block_size / kstd::size_of<uint32_t>());
-    auto const singly_start = static_cast<uint32_t>(kernel::filesystems::ext2::constants::direct_block_count);
+    auto const numbers_per_block = static_cast<std::uint32_t>(block_size / kstd::size_of<std::uint32_t>());
+    auto const singly_start = static_cast<std::uint32_t>(kernel::filesystems::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;
 
@@ -330,23 +330,23 @@ SCENARIO("Ext2 block writing includes direct and all indirect levels", "[filesys
       REQUIRE(write_global_block_number_to_inode_block_index(singly_start + 1, inode_data,
                                                              singly_global_block_number + 1, *driver_state, batch));
       REQUIRE(read_u32(static_cast<kstd::bytes>(inode_data.block[12]) * block_size.value +
-                       1 * kstd::size_of<uint32_t>()) == singly_global_block_number + 1);
+                       1 * kstd::size_of<std::uint32_t>()) == singly_global_block_number + 1);
 
       REQUIRE(write_global_block_number_to_inode_block_index(doubly_start, inode_data, doubly_global_block_number,
                                                              *driver_state, batch));
       REQUIRE(inode_data.block[13] == 18);
-      auto const doubly_leaf_table = read_u32(static_cast<size_t>(inode_data.block[13]) * block_size);
+      auto const doubly_leaf_table = read_u32(static_cast<std::size_t>(inode_data.block[13]) * block_size);
       REQUIRE(doubly_leaf_table == 19);
-      REQUIRE(read_u32(static_cast<size_t>(doubly_leaf_table) * block_size) == doubly_global_block_number);
+      REQUIRE(read_u32(static_cast<std::size_t>(doubly_leaf_table) * block_size) == doubly_global_block_number);
 
       REQUIRE(write_global_block_number_to_inode_block_index(triply_start, inode_data, triply_global_block_number,
                                                              *driver_state, batch));
       REQUIRE(inode_data.block[14] == 20);
-      auto const triply_middle_table = read_u32(static_cast<size_t>(inode_data.block[14]) * block_size);
+      auto const triply_middle_table = read_u32(static_cast<std::size_t>(inode_data.block[14]) * block_size);
       REQUIRE(triply_middle_table == 21);
-      auto const triply_leaf_table = read_u32(static_cast<size_t>(triply_middle_table) * block_size);
+      auto const triply_leaf_table = read_u32(static_cast<std::size_t>(triply_middle_table) * block_size);
       REQUIRE(triply_leaf_table == 22);
-      REQUIRE(read_u32(static_cast<size_t>(triply_leaf_table) * block_size) == triply_global_block_number);
+      REQUIRE(read_u32(static_cast<std::size_t>(triply_leaf_table) * block_size) == triply_global_block_number);
 
       auto inode = kernel::filesystems::ext2::inode{42, inode_data};
 
diff --git a/kernel/kernel/filesystems/ext2/inode.cpp b/kernel/kernel/filesystems/ext2/inode.cpp
index 22e95ee7..4abf8599 100644
--- a/kernel/kernel/filesystems/ext2/inode.cpp
+++ b/kernel/kernel/filesystems/ext2/inode.cpp
@@ -57,7 +57,7 @@ namespace kernel::filesystems::ext2
     }
   }  // namespace
 
-  inode::inode(uint32_t inode_number, inode_data const & data)
+  inode::inode(std::uint32_t inode_number, inode_data const & data)
       : m_inode_number(inode_number)
       , m_data(data)
   {}
@@ -68,7 +68,7 @@ namespace kernel::filesystems::ext2
     {
       auto const max_readable = this->size() - offset;
       auto const requested_size = std::min(kstd::bytes{buffer.size()}, max_readable);
-      auto inline_target = reinterpret_cast<uint8_t const *>(m_data.block.data());
+      auto inline_target = reinterpret_cast<std::uint8_t const *>(m_data.block.data());
       kstd::libc::memcpy(buffer.data(), inline_target + offset, requested_size.value);
       return requested_size;
     }
@@ -266,7 +266,7 @@ namespace kernel::filesystems::ext2
     return std::pair{count, kapi::filesystem::directory_cursor{it.offset().value}};
   }
 
-  auto inode::append_blocks(size_t count, write_batch & batch) -> bool
+  auto inode::append_blocks(std::size_t count, write_batch & batch) -> bool
   {
     auto state = static_pointer_cast<ext2::driver_state>(driver_state().lock());
     if (!state)
@@ -331,7 +331,7 @@ namespace kernel::filesystems::ext2
     return ext2::data_size(*this, *state);
   }
 
-  [[nodiscard]] auto inode::number() const -> uint32_t
+  [[nodiscard]] auto inode::number() const -> std::uint32_t
   {
     return m_inode_number;
   }
diff --git a/kernel/kernel/filesystems/ext2/inode.hpp b/kernel/kernel/filesystems/ext2/inode.hpp
index cffbf679..9a3561f7 100644
--- a/kernel/kernel/filesystems/ext2/inode.hpp
+++ b/kernel/kernel/filesystems/ext2/inode.hpp
@@ -25,24 +25,24 @@ namespace kernel::filesystems::ext2
   //! The data for a single ext2 inode.
   struct [[gnu::packed]] inode_data
   {
-    uint16_t mode;
-    uint16_t uid;
-    uint32_t size;
-    uint32_t atime;
-    uint32_t ctime;
-    uint32_t mtime;
-    uint32_t dtime;
-    uint16_t gid;
-    uint16_t links_count;
-    uint32_t blocks;
-    uint32_t flags;
-    uint32_t osd1;
-    std::array<uint32_t, 15> block;  // NOLINT(readability-magic-numbers)
-    uint32_t generation;
-    uint32_t file_acl;
-    uint32_t dir_acl;
-    uint32_t faddr;
-    std::array<uint8_t, 12> osd2;  // NOLINT(readability-magic-numbers)
+    std::uint16_t mode;
+    std::uint16_t uid;
+    std::uint32_t size;
+    std::uint32_t atime;
+    std::uint32_t ctime;
+    std::uint32_t mtime;
+    std::uint32_t dtime;
+    std::uint16_t gid;
+    std::uint16_t links_count;
+    std::uint32_t blocks;
+    std::uint32_t flags;
+    std::uint32_t osd1;
+    std::array<std::uint32_t, 15> block;  // NOLINT(readability-magic-numbers)
+    std::uint32_t generation;
+    std::uint32_t file_acl;
+    std::uint32_t dir_acl;
+    std::uint32_t faddr;
+    std::array<std::uint8_t, 12> osd2;  // NOLINT(readability-magic-numbers)
   };
 
   struct inode : kernel::vfs::inode
@@ -54,7 +54,7 @@ namespace kernel::filesystems::ext2
     //!
     //! @param inode_number The inode number on disk.
     //! @param data The data associated with this inode, read from the disk.
-    explicit inode(uint32_t inode_number, inode_data const & data);
+    explicit inode(std::uint32_t inode_number, inode_data const & data);
 
     //! @}
 
@@ -104,7 +104,7 @@ namespace kernel::filesystems::ext2
     //! @param count The number of blocks to append.
     //! @param batch The active write batch.
     //! @return true if the blocks were successfully appended, false otherwise.
-    auto append_blocks(size_t count, write_batch & batch) -> bool;
+    auto append_blocks(std::size_t count, write_batch & batch) -> bool;
 
     //! Set the size of the file represented by this inode.
     //!
@@ -134,13 +134,13 @@ namespace kernel::filesystems::ext2
     //! @brief Get the inode number of this inode.
     //!
     //! @return The inode number.
-    [[nodiscard]] auto number() const -> uint32_t;
+    [[nodiscard]] auto number() const -> std::uint32_t;
 
     //! @}
 
   private:
     //! The inode number on disk.
-    uint32_t m_inode_number{};
+    std::uint32_t m_inode_number{};
     //! The inode data.
     inode_data m_data{};
   };
diff --git a/kernel/kernel/filesystems/ext2/inode.tests.cpp b/kernel/kernel/filesystems/ext2/inode.tests.cpp
index bdfb661d..277f4401 100644
--- a/kernel/kernel/filesystems/ext2/inode.tests.cpp
+++ b/kernel/kernel/filesystems/ext2/inode.tests.cpp
@@ -39,8 +39,9 @@ using namespace kstd::units_literals;
 
 namespace
 {
-  auto write_entry(std::vector<std::byte> & block, std::size_t offset, uint32_t inode_number, std::string_view name,
-                   uint8_t file_type, kstd::bytes block_size, bool extend_to_block_end) -> std::size_t
+  auto write_entry(std::vector<std::byte> & block, std::size_t offset, std::uint32_t inode_number,
+                   std::string_view name, std::uint8_t file_type, kstd::bytes block_size, bool extend_to_block_end)
+      -> std::size_t
   {
     auto const header_and_name = 8uz + name.size();
     auto const rounded = (header_and_name + 3uz) & ~3uz;
@@ -48,8 +49,8 @@ namespace
 
     auto * entry = reinterpret_cast<kernel::filesystems::ext2::linked_directory_entry *>(block.data() + offset);
     entry->inode = inode_number;
-    entry->rec_len = static_cast<uint16_t>(rec_len);
-    entry->name_len = static_cast<uint8_t>(name.size());
+    entry->rec_len = static_cast<std::uint16_t>(rec_len);
+    entry->name_len = static_cast<std::uint8_t>(name.size());
     entry->file_type = file_type;
     std::copy(name.begin(), name.end(), &entry->name_start);
 
@@ -454,7 +455,7 @@ SCENARIO("Ext2 inode write across block boundaries", "[filesystem][ext2][inode]"
   inode_data.block[1] = 21;
   inode_data.mode = kernel::filesystems::ext2::constants::mode_regular;
 
-  uint32_t inode_number = 3;
+  std::uint32_t inode_number = 3;
   auto const inode_data_offset = block_group_descriptor.inode_table * block_size +
                                  kstd::bytes{(inode_number - 1) * driver_state->superblock.inode_size};
 
@@ -592,8 +593,8 @@ SCENARIO("Ext2 inode get_size() and set_size() handles size correctly depending
     data.size = 256;
     data.dir_acl = 32;
 
-    auto const verify_size_and_set_size = [&](uint16_t mode, kstd::bytes expected_initial_size,
-                                              uint32_t expected_dir_acl_after_set_size) {
+    auto const verify_size_and_set_size = [&](std::uint16_t mode, kstd::bytes expected_initial_size,
+                                              std::uint32_t expected_dir_acl_after_set_size) {
       data.mode = mode;
 
       auto inode = kernel::filesystems::ext2::inode{42, data};
@@ -639,8 +640,8 @@ SCENARIO("Ext2 inode get_size() and set_size() handles size correctly depending
     data.size = 256;
     data.dir_acl = 32;
 
-    auto const verify_size_and_set_size = [&](uint16_t mode, kstd::bytes expected_initial_size,
-                                              uint32_t expected_dir_acl_after_set_size) {
+    auto const verify_size_and_set_size = [&](std::uint16_t mode, kstd::bytes expected_initial_size,
+                                              std::uint32_t expected_dir_acl_after_set_size) {
       data.mode = mode;
 
       auto inode = kernel::filesystems::ext2::inode{42, data};
@@ -806,15 +807,15 @@ SCENARIO("Ext2 inode read_directory skips deleted entries and paginates correctl
 
     auto block = std::vector<std::byte>(block_size.value, std::byte{0});
     auto offset = 0uz;
-    offset +=
-        write_entry(block, offset, 10, "alpha",
-                    static_cast<uint8_t>(kernel::filesystems::ext2::constants::mode_regular >> 8), block_size, false);
+    offset += write_entry(block, offset, 10, "alpha",
+                          static_cast<std::uint8_t>(kernel::filesystems::ext2::constants::mode_regular >> 8),
+                          block_size, false);
     offset += write_entry(block, offset, 0, "deleted", 0, block_size, false);
-    offset +=
-        write_entry(block, offset, 11, "beta",
-                    static_cast<uint8_t>(kernel::filesystems::ext2::constants::mode_regular >> 8), block_size, false);
+    offset += write_entry(block, offset, 11, "beta",
+                          static_cast<std::uint8_t>(kernel::filesystems::ext2::constants::mode_regular >> 8),
+                          block_size, false);
     write_entry(block, offset, 12, "gamma",
-                static_cast<uint8_t>(kernel::filesystems::ext2::constants::mode_regular >> 8), block_size, true);
+                static_cast<std::uint8_t>(kernel::filesystems::ext2::constants::mode_regular >> 8), block_size, true);
 
     kernel::tests::filesystems::ext2::write_bytes(*device, 30 * block_size, block.data(), block_size);
 
diff --git a/kernel/kernel/filesystems/ext2/linked_directory_entry.hpp b/kernel/kernel/filesystems/ext2/linked_directory_entry.hpp
index 9530a586..98db586f 100644
--- a/kernel/kernel/filesystems/ext2/linked_directory_entry.hpp
+++ b/kernel/kernel/filesystems/ext2/linked_directory_entry.hpp
@@ -14,10 +14,10 @@ namespace kernel::filesystems::ext2
       return std::string_view{&name_start, name_len};
     }
 
-    uint32_t inode;
-    uint16_t rec_len;
-    uint8_t name_len;
-    uint8_t file_type;
+    std::uint32_t inode;
+    std::uint16_t rec_len;
+    std::uint8_t name_len;
+    std::uint8_t file_type;
     char name_start;  // NOLINT(readability-magic-numbers)
   };
 }  // namespace kernel::filesystems::ext2
diff --git a/kernel/kernel/filesystems/ext2/superblock.hpp b/kernel/kernel/filesystems/ext2/superblock.hpp
index 92c73513..40474e70 100644
--- a/kernel/kernel/filesystems/ext2/superblock.hpp
+++ b/kernel/kernel/filesystems/ext2/superblock.hpp
@@ -48,64 +48,64 @@ namespace kernel::filesystems::ext2
   //! The superblock in the ext2 filesystem.
   struct [[gnu::packed]] superblock
   {
-    uint32_t inodes_count;
-    uint32_t blocks_count;
-    uint32_t reserved_blocks_count;
-    uint32_t free_blocks_count;
-    uint32_t free_inodes_count;
-    uint32_t first_data_block;
-    uint32_t log_block_size;
-    uint32_t log_frag_size;
-    uint32_t blocks_per_group;
-    uint32_t frags_per_group;
-    uint32_t inodes_per_group;
-    uint32_t mtime;
-    uint32_t wtime;
-    uint16_t mnt_count;
-    uint16_t max_mnt_count;
-    uint16_t magic;
-    uint16_t state;
-    uint16_t errors;
-    uint16_t minor_rev_level;
-    uint32_t lastcheck;
-    uint32_t checkinterval;
-    uint32_t creator_os;
-    uint32_t rev_level;
-    uint16_t def_resuid;
-    uint16_t def_resgid;
+    std::uint32_t inodes_count;
+    std::uint32_t blocks_count;
+    std::uint32_t reserved_blocks_count;
+    std::uint32_t free_blocks_count;
+    std::uint32_t free_inodes_count;
+    std::uint32_t first_data_block;
+    std::uint32_t log_block_size;
+    std::uint32_t log_frag_size;
+    std::uint32_t blocks_per_group;
+    std::uint32_t frags_per_group;
+    std::uint32_t inodes_per_group;
+    std::uint32_t mtime;
+    std::uint32_t wtime;
+    std::uint16_t mnt_count;
+    std::uint16_t max_mnt_count;
+    std::uint16_t magic;
+    std::uint16_t state;
+    std::uint16_t errors;
+    std::uint16_t minor_rev_level;
+    std::uint32_t lastcheck;
+    std::uint32_t checkinterval;
+    std::uint32_t creator_os;
+    std::uint32_t rev_level;
+    std::uint16_t def_resuid;
+    std::uint16_t def_resgid;
 
     // EXT2_DYNAMIC_REV superblock only
-    uint32_t first_ino;
-    uint16_t inode_size;
-    uint16_t block_group_nr;
+    std::uint32_t first_ino;
+    std::uint16_t inode_size;
+    std::uint16_t block_group_nr;
     compatible_features feature_compat;
     incompatible_features feature_incompat;
     read_only_compatible_features feature_ro_compat;
-    std::array<uint8_t, 16> uuid;
-    std::array<uint8_t, 16> volume_name;
-    std::array<uint8_t, 64> last_mounted;
-    uint32_t algorithm_usage_bitmap;
+    std::array<std::uint8_t, 16> uuid;
+    std::array<std::uint8_t, 16> volume_name;
+    std::array<std::uint8_t, 64> last_mounted;
+    std::uint32_t algorithm_usage_bitmap;
 
     // Performance Hints
-    uint8_t prealloc_blocks;
-    uint8_t prealloc_dir_blocks;
-    uint16_t padding1;
+    std::uint8_t prealloc_blocks;
+    std::uint8_t prealloc_dir_blocks;
+    std::uint16_t padding1;
 
     // Journaling Support
-    std::array<uint8_t, 16> journal_uuid;
-    uint32_t journal_inum;
-    uint32_t journal_dev;
-    uint32_t last_orphan;
+    std::array<std::uint8_t, 16> journal_uuid;
+    std::uint32_t journal_inum;
+    std::uint32_t journal_dev;
+    std::uint32_t last_orphan;
 
     // Directory Indexing Support
-    std::array<uint32_t, 4> hash_seed;
-    uint8_t def_hash_version;
-    std::array<uint8_t, 3> padding2;
+    std::array<std::uint32_t, 4> hash_seed;
+    std::uint8_t def_hash_version;
+    std::array<std::uint8_t, 3> padding2;
 
     // Other options
-    uint32_t default_mount_options;
-    uint32_t first_meta_bg;
-    std::array<uint8_t, 760> unused;  // NOLINT(readability-magic-numbers)
+    std::uint32_t default_mount_options;
+    std::uint32_t first_meta_bg;
+    std::array<std::uint8_t, 760> unused;  // NOLINT(readability-magic-numbers)
   };
 }  // namespace kernel::filesystems::ext2
 
diff --git a/kernel/kernel/main.cpp b/kernel/kernel/main.cpp
index 7083d517..f59b4ad7 100644
--- a/kernel/kernel/main.cpp
+++ b/kernel/kernel/main.cpp
@@ -81,7 +81,7 @@ auto run_demo() -> void
   // 6) read from the new file
   kstd::vector<std::byte> buffer_2{10};
   bytes_read = *kapi::filesystem::read(fd_2.value(), buffer_2);
-  buffer_as_str = std::string_view{reinterpret_cast<char *>(buffer_2.data()), static_cast<size_t>(bytes_read)};
+  buffer_as_str = std::string_view{reinterpret_cast<char *>(buffer_2.data()), static_cast<std::size_t>(bytes_read)};
   kstd::println("--> read {} from /entrance/information/info_1.txt: {}", bytes_read, buffer_as_str);
 
   // 7) open device as file
diff --git a/kernel/kernel/test_support/devices/block_device.cpp b/kernel/kernel/test_support/devices/block_device.cpp
index c9ab4a5e..462dc79d 100644
--- a/kernel/kernel/test_support/devices/block_device.cpp
+++ b/kernel/kernel/test_support/devices/block_device.cpp
@@ -25,7 +25,7 @@ namespace kernel::tests::devices
     data.resize(initial_size.value, 0);
   }
 
-  auto block_device::read_block(size_t block_index, std::span<std::byte> buffer) -> kstd::result<kstd::bytes>
+  auto block_device::read_block(std::size_t block_index, std::span<std::byte> buffer) -> kstd::result<kstd::bytes>
   {
     auto const offset = block_index * block_size();
     if (offset.value >= data.size())
@@ -44,7 +44,8 @@ namespace kernel::tests::devices
     return bytes_to_read;
   }
 
-  auto block_device::write_block(size_t block_index, std::span<std::byte const> buffer) -> kstd::result<kstd::bytes>
+  auto block_device::write_block(std::size_t block_index, std::span<std::byte const> buffer)
+      -> kstd::result<kstd::bytes>
   {
     auto const offset = block_index * block_size();
     auto const write_end = offset + block_size();
diff --git a/kernel/kernel/test_support/devices/block_device.hpp b/kernel/kernel/test_support/devices/block_device.hpp
index 5f00f27e..9e64ed18 100644
--- a/kernel/kernel/test_support/devices/block_device.hpp
+++ b/kernel/kernel/test_support/devices/block_device.hpp
@@ -20,13 +20,13 @@ namespace kernel::tests::devices
   {
     block_device(kstd::string const & name, kstd::bytes block_size, kstd::bytes initial_size = {});
 
-    auto read_block(size_t block_index, std::span<std::byte> buffer) -> kstd::result<kstd::bytes> override;
-    auto write_block(size_t block_index, std::span<std::byte const> buffer) -> kstd::result<kstd::bytes> override;
+    auto read_block(std::size_t block_index, std::span<std::byte> buffer) -> kstd::result<kstd::bytes> override;
+    auto write_block(std::size_t block_index, std::span<std::byte const> buffer) -> kstd::result<kstd::bytes> override;
 
     [[nodiscard]] auto block_size() const -> kstd::bytes override;
     [[nodiscard]] auto capacity() const -> kstd::bytes override;
 
-    kstd::vector<uint8_t> data{};
+    kstd::vector<std::uint8_t> data{};
 
   private:
     [[nodiscard]] auto query_facet(kapi::capabilities::facet_id facet) -> void * override;
diff --git a/kernel/kernel/test_support/filesystems/ext2.cpp b/kernel/kernel/test_support/filesystems/ext2.cpp
index 92f56aef..df224f63 100644
--- a/kernel/kernel/test_support/filesystems/ext2.cpp
+++ b/kernel/kernel/test_support/filesystems/ext2.cpp
@@ -17,7 +17,7 @@ namespace kernel::tests::filesystems::ext2
 {
   namespace
   {
-    constexpr uint32_t root_directory_data_block = 20;
+    constexpr std::uint32_t root_directory_data_block = 20;
   }  // namespace
 
   auto write_bytes(kernel::tests::devices::block_device & device, kstd::bytes offset, void const * source,
@@ -32,7 +32,7 @@ namespace kernel::tests::filesystems::ext2
     std::memcpy(device.data.data() + offset, source, size.value);
   }
 
-  auto write_u32(kernel::tests::devices::block_device & device, kstd::bytes offset, uint32_t value) -> void
+  auto write_u32(kernel::tests::devices::block_device & device, kstd::bytes offset, std::uint32_t value) -> void
   {
     write_bytes(device, offset, &value, kstd::size_of(value));
   }
@@ -74,7 +74,7 @@ namespace kernel::tests::filesystems::ext2
     root_inode_data.block[0] = root_directory_data_block;
 
     auto const root_inode_offset =
-        static_cast<size_t>(group_descriptor.inode_table) * kernel::filesystems::ext2::constants::base_block_size +
+        static_cast<std::size_t>(group_descriptor.inode_table) * kernel::filesystems::ext2::constants::base_block_size +
         (kernel::filesystems::ext2::constants::root_inode_number - 1) * kstd::bytes{superblock.inode_size};
     write_bytes(device, root_inode_offset, &root_inode_data, kstd::size_of(root_inode_data));
   }
diff --git a/kernel/kernel/test_support/filesystems/ext2.hpp b/kernel/kernel/test_support/filesystems/ext2.hpp
index 7509f1e1..043071dc 100644
--- a/kernel/kernel/test_support/filesystems/ext2.hpp
+++ b/kernel/kernel/test_support/filesystems/ext2.hpp
@@ -13,7 +13,7 @@ namespace kernel::tests::filesystems::ext2
 {
   auto write_bytes(kernel::tests::devices::block_device & device, kstd::bytes offset, void const * source,
                    kstd::bytes size) -> void;
-  auto write_u32(kernel::tests::devices::block_device & device, kstd::bytes offset, uint32_t value) -> void;
+  auto write_u32(kernel::tests::devices::block_device & device, kstd::bytes offset, std::uint32_t value) -> void;
   auto setup_mock_ext2_layout(kernel::tests::devices::block_device & device) -> void;
   auto setup_mock_ext2_layout(kernel::tests::devices::block_device & device,
                               kernel::filesystems::ext2::superblock const & superblock) -> void;
diff --git a/kernel/kernel/test_support/vfs/storage_boot_module_fixture.cpp b/kernel/kernel/test_support/vfs/storage_boot_module_fixture.cpp
index 69dec962..8fa48257 100644
--- a/kernel/kernel/test_support/vfs/storage_boot_module_fixture.cpp
+++ b/kernel/kernel/test_support/vfs/storage_boot_module_fixture.cpp
@@ -122,7 +122,7 @@ namespace kernel::tests::vfs
       throw std::invalid_argument{"Module names and image paths vectors must have the same size."};
     }
 
-    for (size_t i = 0; i < module_names.size(); ++i)
+    for (std::size_t i = 0; i < module_names.size(); ++i)
     {
       setup_module_from_img(i, module_names[i], img_paths[i]);
     }
diff --git a/kernel/kernel/vfs/constants.hpp b/kernel/kernel/vfs/constants.hpp
index b5759d32..a30bb8e7 100644
--- a/kernel/kernel/vfs/constants.hpp
+++ b/kernel/kernel/vfs/constants.hpp
@@ -6,13 +6,13 @@
 namespace kernel::vfs::constants
 {
   //! The maximum allowed length for any path in the system.
-  constexpr size_t inline max_path_length = 4096;
+  constexpr std::size_t inline max_path_length = 4096;
 
   //! The maximum allowed path length for the target of a symlink.
-  constexpr size_t inline symlink_max_path_length = 4096;
+  constexpr std::size_t inline symlink_max_path_length = 4096;
 
   //! The maximum number of loops allowed in a path, via symlinks.
-  constexpr size_t inline symloop_max = 40;
+  constexpr std::size_t inline symloop_max = 40;
 }  // namespace kernel::vfs::constants
 
 #endif
\ No newline at end of file
diff --git a/kernel/kernel/vfs/dentry.cpp b/kernel/kernel/vfs/dentry.cpp
index c22dc0e2..d9cb835a 100644
--- a/kernel/kernel/vfs/dentry.cpp
+++ b/kernel/kernel/vfs/dentry.cpp
@@ -81,17 +81,17 @@ namespace kernel::vfs
 
   auto dentry::set_flag(dentry_flags flag) -> void
   {
-    m_flags |= static_cast<uint32_t>(flag);
+    m_flags |= static_cast<std::uint32_t>(flag);
   }
 
   auto dentry::unset_flag(dentry_flags flag) -> void
   {
-    m_flags &= ~static_cast<uint32_t>(flag);
+    m_flags &= ~static_cast<std::uint32_t>(flag);
   }
 
   auto dentry::has_flag(dentry_flags flag) const -> bool
   {
-    return (m_flags & static_cast<uint32_t>(flag)) != 0;
+    return (m_flags & static_cast<std::uint32_t>(flag)) != 0;
   }
 
   auto dentry::set_parent(dentry_ptr const & parent) -> void
diff --git a/kernel/kernel/vfs/dentry.hpp b/kernel/kernel/vfs/dentry.hpp
index 13dea2a3..0c669854 100644
--- a/kernel/kernel/vfs/dentry.hpp
+++ b/kernel/kernel/vfs/dentry.hpp
@@ -19,7 +19,7 @@ namespace kernel::vfs
     using inode_ptr = kstd::shared_ptr<kernel::vfs::inode>;
 
     //! Flags for the dentry.
-    enum class dentry_flags : uint32_t
+    enum class dentry_flags : std::uint32_t
     {
       is_mount_point = 1 << 0
     };
@@ -95,7 +95,7 @@ namespace kernel::vfs
     kstd::weak_ptr<dentry> m_parent;
     kstd::vector<dentry_ptr> m_children;
     inode_ptr m_inode;
-    uint32_t m_flags;
+    std::uint32_t m_flags;
   };
 }  // namespace kernel::vfs
 
diff --git a/kernel/kernel/vfs/device_inode.tests.cpp b/kernel/kernel/vfs/device_inode.tests.cpp
index 0f9b5881..44346426 100644
--- a/kernel/kernel/vfs/device_inode.tests.cpp
+++ b/kernel/kernel/vfs/device_inode.tests.cpp
@@ -106,7 +106,7 @@ SCENARIO("Device inode read/write", "[filesystem][device_inode]")
     WHEN("writing to the device inode")
     {
       kstd::vector<std::byte> write_buffer(1024);
-      for (size_t i = 0; i < write_buffer.size(); ++i)
+      for (std::size_t i = 0; i < write_buffer.size(); ++i)
       {
         write_buffer[i] = static_cast<std::byte>(i % 256);
       }
diff --git a/kernel/kernel/vfs/mount.cpp b/kernel/kernel/vfs/mount.cpp
index 76f72e22..3f99f733 100644
--- a/kernel/kernel/vfs/mount.cpp
+++ b/kernel/kernel/vfs/mount.cpp
@@ -134,7 +134,7 @@ namespace kernel::vfs
     return m_ref_count == 0;
   }
 
-  auto mount::ref_count() const -> size_t
+  auto mount::ref_count() const -> std::size_t
   {
     return m_ref_count;
   }
diff --git a/kernel/kernel/vfs/mount.hpp b/kernel/kernel/vfs/mount.hpp
index b0993dd3..dc49212c 100644
--- a/kernel/kernel/vfs/mount.hpp
+++ b/kernel/kernel/vfs/mount.hpp
@@ -83,7 +83,7 @@ namespace kernel::vfs
     //! Get the current reference count for this mount.
     //!
     //! @return The current reference count.
-    [[nodiscard]] auto ref_count() const -> size_t;
+    [[nodiscard]] auto ref_count() const -> std::size_t;
 
   private:
     friend struct mount_table;
@@ -112,7 +112,7 @@ namespace kernel::vfs
     mount_ptr m_parent_mount{};
     kstd::weak_ptr<mount> m_source_mount{};
     kstd::shared_ptr<vfs::driver_state> m_driver_state{};
-    std::atomic_size_t m_ref_count{0};
+    std::atomic<std::size_t> m_ref_count{0};
   };
 }  // namespace kernel::vfs
 
diff --git a/kernel/kernel/vfs/open_file_table.cpp b/kernel/kernel/vfs/open_file_table.cpp
index 286fa57b..108f4e11 100644
--- a/kernel/kernel/vfs/open_file_table.cpp
+++ b/kernel/kernel/vfs/open_file_table.cpp
@@ -59,7 +59,7 @@ namespace kernel::vfs
     return m_open_files.size() - 1;
   }
 
-  auto open_file_table::file(size_t fd) const -> kstd::result<kstd::shared_ptr<open_file_descriptor>>
+  auto open_file_table::file(std::size_t fd) const -> kstd::result<kstd::shared_ptr<open_file_descriptor>>
   {
     if (fd >= m_open_files.size() || m_open_files.at(fd) == nullptr)
     {
@@ -69,7 +69,7 @@ namespace kernel::vfs
     return kstd::success(m_open_files.at(fd));
   }
 
-  auto open_file_table::remove_file(size_t fd) -> kstd::result<void>
+  auto open_file_table::remove_file(std::size_t fd) -> kstd::result<void>
   {
     if (fd >= m_open_files.size() || m_open_files.at(fd) == nullptr)
     {
diff --git a/kernel/kernel/vfs/open_file_table.hpp b/kernel/kernel/vfs/open_file_table.hpp
index 10674ba7..8d6a2341 100644
--- a/kernel/kernel/vfs/open_file_table.hpp
+++ b/kernel/kernel/vfs/open_file_table.hpp
@@ -39,13 +39,13 @@ namespace kernel::vfs
     //!
     //! @param fd The file descriptor index to retrieve.
     //! @return The requested file descriptor on success, an error otherwise.
-    [[nodiscard]] auto file(size_t fd) const -> kstd::result<kstd::shared_ptr<open_file_descriptor>>;
+    [[nodiscard]] auto file(std::size_t fd) const -> kstd::result<kstd::shared_ptr<open_file_descriptor>>;
 
     //! Remove a file from the open file table.
     //!
     //! @param fd The file descriptor index to remove.
     //! @return Nothin on success, an error otherwise.
-    auto remove_file(size_t fd) -> kstd::result<void>;
+    auto remove_file(std::size_t fd) -> kstd::result<void>;
 
   private:
     open_file_table() = default;