kstd: introduce strong type for memory amounts

6 files changed, 42 insertions, 32 deletions

diff --git a/kernel/include/kernel/memory/block_list_allocator.hpp b/kernel/include/kernel/memory/block_list_allocator.hpp
index 5e81c44..f319097 100644
--- a/kernel/include/kernel/memory/block_list_allocator.hpp
+++ b/kernel/include/kernel/memory/block_list_allocator.hpp
@@ -6,6 +6,7 @@
 #include "kernel/memory/heap_allocator.hpp"
 
 #include <kstd/mutex>
+#include <kstd/units>
 
 #include <cstddef>
 #include <new>
@@ -32,7 +33,7 @@ namespace kernel::memory
     //! @param size The size of the block to allocate
     //! @param alignment The desired alignment of the allocated block
     //! @return A pointer to the beginning of the block on success, @p nullptr otherwise.
-    [[nodiscard]] auto allocate(std::size_t size, std::align_val_t alignment) noexcept -> void * override;
+    [[nodiscard]] auto allocate(kstd::units::bytes size, kstd::units::bytes alignment) noexcept -> void * override;
 
     //! Deallocate a block of memory previously allocated.
     //!
@@ -42,7 +43,7 @@ namespace kernel::memory
   private:
     struct block_header final
     {
-      std::size_t usable_size;
+      kstd::units::bytes usable_size;
       bool free;
       block_header * next;
       block_header * prev;
@@ -52,16 +53,16 @@ namespace kernel::memory
     //!
     //! Each allocated block carries a block header, like any unallocated one, but in addition also has a back-pointer
     //! to the block header to support padding due to alignment.
-    constexpr auto static allocated_metadata_size = sizeof(block_header) + sizeof(block_header *);
+    constexpr auto static allocated_metadata_size = kstd::units::bytes{sizeof(block_header) + sizeof(block_header *)};
 
     //! The minimum number of bytes for an allocation.
-    constexpr auto static minimum_allocation_size = 16uz;
+    constexpr auto static minimum_allocation_size = kstd::units::bytes{16uz};
 
     //! Try to expand the heap to accommodate the given size.
     //!
     //! @param delta The size to expand the heap by.
     //! @return @p true if the heap was expanded, @p false otherwise.
-    auto expand(std::size_t delta) noexcept -> bool;
+    auto expand(kstd::units::bytes delta) noexcept -> bool;
 
     //! Split a given free block to accommodate and allocation.
     //!
@@ -70,7 +71,7 @@ namespace kernel::memory
     //! @param block The block to split.
     //! @param size The size of the allocation.
     //! @param padding The amount of padding to apply.
-    auto split(block_header * block, std::size_t size, std::size_t padding) noexcept -> void;
+    auto split(block_header * block, kstd::units::bytes size, kstd::units::bytes padding) noexcept -> void;
 
     //! Try to coalesce a given block with it's preceding and/or following block.
     //!
diff --git a/kernel/include/kernel/memory/heap_allocator.hpp b/kernel/include/kernel/memory/heap_allocator.hpp
index bc771e3..55de7e4 100644
--- a/kernel/include/kernel/memory/heap_allocator.hpp
+++ b/kernel/include/kernel/memory/heap_allocator.hpp
@@ -1,9 +1,8 @@
 #ifndef TEACHOS_KERNEL_MEMORY_HEAP_ALLOCATOR_HPP
 #define TEACHOS_KERNEL_MEMORY_HEAP_ALLOCATOR_HPP
 
-#include <kstd/mutex>
+#include <kstd/units>
 
-#include <cstddef>
 #include <new>
 
 namespace kernel::memory
@@ -19,7 +18,7 @@ namespace kernel::memory
     //! @param size The size of the block to allocate
     //! @param alignment The desired alignment of the allocated block
     //! @return A pointer to the beginning of the block on success, @p nullptr otherwise.
-    [[nodiscard]] virtual auto allocate(std::size_t size, std::align_val_t alignment) noexcept -> void * = 0;
+    [[nodiscard]] virtual auto allocate(kstd::units::bytes size, kstd::units::bytes alignment) noexcept -> void * = 0;
 
     //! Deallocate a block of memory previously allocated.
     //!
diff --git a/kernel/kapi/memory.cpp b/kernel/kapi/memory.cpp
index d8065d4..2803d76 100644
--- a/kernel/kapi/memory.cpp
+++ b/kernel/kapi/memory.cpp
@@ -5,6 +5,7 @@
 #include "kernel/memory/bitmap_allocator.hpp"
 
 #include <kstd/print>
+#include <kstd/units>
 
 #include <algorithm>
 #include <cstddef>
@@ -112,8 +113,10 @@ namespace kapi::memory
 
   auto init_pmm(std::size_t frame_count, void (&handoff_handler)(frame_allocator &)) -> void
   {
-    auto const bitmap_bytes = (frame_count + 7uz) / 8uz;
-    auto const bitmap_pages = (bitmap_bytes + page::size - 1uz) / page::size;
+    using namespace kstd::units_literals;
+
+    auto const bitmap_bytes = kstd::units::bytes{(frame_count + 7uz) / 8uz};
+    auto const bitmap_pages = (bitmap_bytes + page::size - 1_B) / page::size;
 
     auto const bitmap_frames = allocate_many_frames(bitmap_pages);
     if (!bitmap_frames)
@@ -130,7 +133,8 @@ namespace kapi::memory
     });
 
     auto bitmap_ptr = static_cast<std::uint64_t *>(pmm_metadata_base);
-    auto bitmap = std::span{bitmap_ptr, (bitmap_bytes + sizeof(std::uint64_t) - 1uz) / sizeof(std::uint64_t)};
+    auto bitmap =
+        std::span{bitmap_ptr, (bitmap_bytes + kstd::type_size<std::uint64_t> - 1_B) / kstd::type_size<std::uint64_t>};
 
     allocator.emplace(bitmap, frame_count);
 
diff --git a/kernel/src/memory.cpp b/kernel/src/memory.cpp
index 0f614f0..4a8e203 100644
--- a/kernel/src/memory.cpp
+++ b/kernel/src/memory.cpp
@@ -7,10 +7,9 @@
 #include "kernel/memory/heap_allocator.hpp"
 
 #include <kstd/print>
+#include <kstd/units>
 
 #include <atomic>
-#include <cstddef>
-#include <new>
 #include <optional>
 
 namespace kernel::memory
@@ -22,7 +21,7 @@ namespace kernel::memory
     {
       null_allocator static instance;
 
-      [[nodiscard]] auto allocate(std::size_t, std::align_val_t) noexcept -> void * override
+      [[nodiscard]] auto allocate(kstd::units::bytes, kstd::units::bytes) noexcept -> void * override
       {
         kstd::print(kstd::print_sink::stderr, "Tried to allocate memory without an active heap!");
         return nullptr;
diff --git a/kernel/src/memory/block_list_allocator.cpp b/kernel/src/memory/block_list_allocator.cpp
index 5d870d8..fbc5945 100644
--- a/kernel/src/memory/block_list_allocator.cpp
+++ b/kernel/src/memory/block_list_allocator.cpp
@@ -6,19 +6,21 @@
 #include "kernel/memory/heap_allocator.hpp"
 
 #include <kstd/mutex>
+#include <kstd/units>
 
 #include <bit>
 #include <cstddef>
 #include <cstdint>
 #include <memory>
-#include <new>
+
+using namespace kstd::units_literals;
 
 namespace kernel::memory
 {
 
   namespace
   {
-    [[nodiscard]] constexpr auto align_up(std::byte * pointer, std::align_val_t alignment) noexcept -> std::byte *
+    [[nodiscard]] constexpr auto align_up(std::byte * pointer, kstd::units::bytes alignment) noexcept -> std::byte *
     {
       auto const remainder = std::bit_cast<std::uintptr_t>(pointer) % static_cast<std::size_t>(alignment);
       return remainder == 0 ? pointer : pointer + static_cast<std::size_t>(alignment) - remainder;
@@ -33,7 +35,7 @@ namespace kernel::memory
       , m_lock{}
   {}
 
-  auto block_list_allocator::allocate(std::size_t size, std::align_val_t alignment) noexcept -> void *
+  auto block_list_allocator::allocate(kstd::units::bytes size, kstd::units::bytes alignment) noexcept -> void *
   {
     kstd::lock_guard guard{m_lock};
 
@@ -47,13 +49,13 @@ namespace kernel::memory
           auto const raw_block = reinterpret_cast<std::byte *>(current);
           auto const unaligned_payload = raw_block + allocated_metadata_size;
           auto const aligned_payload = align_up(unaligned_payload, alignment);
-          auto const required_padding = static_cast<std::size_t>(aligned_payload - unaligned_payload);
+          auto const required_padding = static_cast<kstd::units::bytes>(aligned_payload - unaligned_payload);
           auto const total_required_size = required_padding + allocated_metadata_size + size;
 
           if (current->usable_size >= total_required_size)
           {
             auto const payload_header = aligned_payload - sizeof(block_header *) - sizeof(block_header);
-            auto const front_padding = static_cast<std::size_t>(payload_header - raw_block);
+            auto const front_padding = static_cast<kstd::units::bytes>(payload_header - raw_block);
 
             auto payload_block = current;
 
@@ -72,9 +74,10 @@ namespace kernel::memory
               payload_block->prev = current;
             }
 
-            auto const payload_size =
-                aligned_payload - reinterpret_cast<std::byte *>(payload_block) - allocated_metadata_size + size;
-            split(payload_block, payload_size, 0uz);
+            auto const header_size =
+                static_cast<kstd::units::bytes>(aligned_payload - reinterpret_cast<std::byte *>(payload_block));
+            auto const payload_size = header_size - allocated_metadata_size + size;
+            split(payload_block, payload_size, 0_B);
 
             payload_block->free = false;
 
@@ -87,7 +90,7 @@ namespace kernel::memory
         current = current->next;
       }
 
-      auto const search_size = size + static_cast<std::size_t>(alignment);
+      auto const search_size = size + alignment;
       if (attempt == 0uz && !expand(search_size))
       {
         return nullptr;
@@ -114,10 +117,10 @@ namespace kernel::memory
     coalesce(block);
   }
 
-  auto block_list_allocator::expand(std::size_t size) noexcept -> bool
+  auto block_list_allocator::expand(kstd::units::bytes size) noexcept -> bool
   {
     auto const total_required_size = size + allocated_metadata_size;
-    auto const frames_needed = (total_required_size + kapi::memory::frame::size - 1) / kapi::memory::frame::size;
+    auto const frames_needed = (total_required_size + kapi::memory::frame::size - 1_B) / kapi::memory::frame::size;
 
     auto const flags = kapi::memory::page_mapper::flags::writable | kapi::memory::page_mapper::flags::supervisor_only |
                        kapi::memory::page_mapper::flags::global;
@@ -187,7 +190,8 @@ namespace kernel::memory
     }
   }
 
-  auto block_list_allocator::split(block_header * block, std::size_t size, std::size_t padding) noexcept -> void
+  auto block_list_allocator::split(block_header * block, kstd::units::bytes size, kstd::units::bytes padding) noexcept
+      -> void
   {
     auto const new_block_size = size + padding;
 
diff --git a/kernel/src/memory/operators.cpp b/kernel/src/memory/operators.cpp
index 57e31e6..c786b53 100644
--- a/kernel/src/memory/operators.cpp
+++ b/kernel/src/memory/operators.cpp
@@ -2,13 +2,16 @@
 
 #include "kernel/memory.hpp"
 
+#include <kstd/units>
+
 #include <cstddef>
 #include <new>
 
 [[nodiscard]] auto operator new(std::size_t size, std::align_val_t alignment, std::nothrow_t const &) noexcept -> void *
 {
   auto & allocator = kernel::memory::get_heap_allocator();
-  return allocator.allocate(size, alignment);
+  return allocator.allocate(static_cast<kstd::units::bytes>(size),
+                            static_cast<kstd::units::bytes>(static_cast<std::size_t>(alignment)));
 }
 
 [[nodiscard]] auto operator new(std::size_t size, std::align_val_t alignment) -> void *
@@ -83,9 +86,9 @@ auto operator delete[](void * pointer) noexcept -> void
   ::operator delete(pointer);
 }
 
-auto operator delete[](void * pointer, std::size_t) noexcept -> void
+auto operator delete[](void * pointer, std::size_t size) noexcept -> void
 {
-  ::operator delete(pointer);
+  ::operator delete(pointer, size);
 }
 
 auto operator delete[](void * pointer, std::align_val_t) noexcept -> void
@@ -93,7 +96,7 @@ auto operator delete[](void * pointer, std::align_val_t) noexcept -> void
   ::operator delete(pointer);
 }
 
-auto operator delete[](void * pointer, std::size_t, std::align_val_t) noexcept -> void
+auto operator delete[](void * pointer, std::size_t size, std::align_val_t) noexcept -> void
 {
-  ::operator delete(pointer);
+  ::operator delete(pointer, size);
 }