x86_64: replace raw pointers with observer_ptr

5 files changed, 27 insertions, 21 deletions

diff --git a/kernel/kapi/memory.cpp b/kernel/kapi/memory.cpp
index 1c6fa2c8..7a9f7249 100644
--- a/kernel/kapi/memory.cpp
+++ b/kernel/kapi/memory.cpp
@@ -5,6 +5,7 @@
 
 #include <kapi/system.hpp>
 
+#include <kstd/memory.hpp>
 #include <kstd/print.hpp>
 #include <kstd/units.hpp>
 
@@ -45,7 +46,7 @@ namespace kapi::memory
     {
       bad_page_mapper static instance;
 
-      auto map(page, frame, flags) -> std::byte * override
+      auto map(page, frame, flags) -> kstd::observer_ptr<std::byte> override
       {
         system::panic("[OS:MEM] Tried to map a page without an active mapper.");
       }
@@ -103,7 +104,7 @@ namespace kapi::memory
     return get_frame_allocator().allocate_many(count);
   }
 
-  auto map(page page, frame frame, page_mapper::flags flags) -> std::byte *
+  auto map(page page, frame frame, page_mapper::flags flags) -> kstd::observer_ptr<std::byte>
   {
     return active_page_mapper->map(page, frame, flags);
   }
@@ -135,7 +136,7 @@ namespace kapi::memory
       auto mapped = active_page_mapper->map(page, frame, flags);
       if (!bitmap_ptr)
       {
-        bitmap_ptr = reinterpret_cast<std::uint64_t *>(mapped);
+        bitmap_ptr = reinterpret_cast<std::uint64_t *>(mapped.get());
       }
     });
 
@@ -160,7 +161,8 @@ namespace kapi::memory
     return {region, page_count};
   }
 
-  auto map_mmio_region(mmio_region region, physical_address hw_base, page_mapper::flags flags) -> std::byte *
+  auto map_mmio_region(mmio_region region, physical_address hw_base, page_mapper::flags flags)
+      -> kstd::observer_ptr<std::byte>
   {
     auto start_page = page::containing(region.first);
     auto start_frame = frame::containing(hw_base);
diff --git a/kernel/kernel/test_support/page_mapper.cpp b/kernel/kernel/test_support/page_mapper.cpp
index 3a0072b4..808e0810 100644
--- a/kernel/kernel/test_support/page_mapper.cpp
+++ b/kernel/kernel/test_support/page_mapper.cpp
@@ -2,6 +2,7 @@
 
 #include <kapi/memory.hpp>
 
+#include <kstd/memory.hpp>
 #include <kstd/units.hpp>
 
 #include <cstddef>
@@ -15,7 +16,7 @@ namespace kernel::tests
       : memory{physical_size, virtual_size}
   {}
 
-  auto page_mapper::map(kapi::memory::page page, kapi::memory::frame frame, flags) -> std::byte *
+  auto page_mapper::map(kapi::memory::page page, kapi::memory::frame frame, flags) -> kstd::observer_ptr<std::byte>
   {
     auto result = page_mappings.insert({page.number(), frame});
     if (!result.second)
@@ -41,7 +42,7 @@ namespace kernel::tests
     else if (page_address >= kapi::memory::higher_half_direct_map_base)
     {
       auto offset = frame.number() * kapi::memory::frame::size;
-      return memory.physical_base() + offset;
+      return kstd::observer_ptr{memory.physical_base().get() + offset};
     }
 
     return nullptr;
diff --git a/kernel/kernel/test_support/page_mapper.hpp b/kernel/kernel/test_support/page_mapper.hpp
index 09c07f13..c38eeaf3 100644
--- a/kernel/kernel/test_support/page_mapper.hpp
+++ b/kernel/kernel/test_support/page_mapper.hpp
@@ -5,6 +5,7 @@
 
 #include <kapi/memory.hpp>
 
+#include <kstd/memory.hpp>
 #include <kstd/units.hpp>
 
 #include <cstddef>
@@ -27,7 +28,7 @@ namespace kernel::tests
     //! @throws std::invalid_argument if the page has already been mapped.
     //! @throws std::runtime_error if the page cannot be mapped.
     //! @throws std::runtime_error if the underlying simulated memory cannot map the page.
-    auto map(kapi::memory::page page, kapi::memory::frame frame, flags flags) -> std::byte * override;
+    auto map(kapi::memory::page page, kapi::memory::frame frame, flags flags) -> kstd::observer_ptr<std::byte> override;
 
     //! @copydoc kapi::memory::page_mapper::unmap
     //!
diff --git a/kernel/kernel/test_support/simulated_memory.cpp b/kernel/kernel/test_support/simulated_memory.cpp
index 7614816b..4255eed0 100644
--- a/kernel/kernel/test_support/simulated_memory.cpp
+++ b/kernel/kernel/test_support/simulated_memory.cpp
@@ -2,6 +2,7 @@
 
 #include <kapi/memory.hpp>
 
+#include <kstd/memory.hpp>
 #include <kstd/units.hpp>
 
 #include <cerrno>
@@ -48,30 +49,30 @@ namespace kernel::tests
       throw std::runtime_error(error);
     }
 
-    m_physical_base = static_cast<std::byte *>(physical_storage);
-    m_virtual_base = static_cast<std::byte *>(virtual_pointer);
+    m_physical_base = kstd::make_observer<std::byte>(static_cast<std::byte *>(physical_storage));
+    m_virtual_base = kstd::make_observer<std::byte>(static_cast<std::byte *>(virtual_pointer));
 
     clear();
   }
 
   simulated_memory::~simulated_memory()
   {
-    munmap(m_virtual_base, m_virtual_size.value);
-    munmap(m_physical_base, m_physical_size.value);
+    munmap(m_virtual_base.get(), m_virtual_size.value);
+    munmap(m_physical_base.get(), m_physical_size.value);
     close(m_descriptor);
   }
 
   auto simulated_memory::clear() -> void
   {
-    std::memset(m_physical_base, 0, m_physical_size.value);
+    std::memset(m_physical_base.get(), 0, m_physical_size.value);
   }
 
-  auto simulated_memory::physical_base() noexcept -> std::byte *
+  auto simulated_memory::physical_base() noexcept -> kstd::observer_ptr<std::byte>
   {
     return m_physical_base;
   }
 
-  auto simulated_memory::physical_base() const noexcept -> std::byte const *
+  auto simulated_memory::physical_base() const noexcept -> kstd::observer_ptr<std::byte const>
   {
     return m_physical_base;
   }
@@ -91,7 +92,7 @@ namespace kernel::tests
     return m_virtual_size;
   }
 
-  auto simulated_memory::map(kstd::bytes size, std::byte * to, off_t offset) -> std::byte *
+  auto simulated_memory::map(kstd::bytes size, std::byte * to, off_t offset) -> kstd::observer_ptr<std::byte>
   {
     auto mapped_ptr = mmap(to, size.value, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED, m_descriptor, offset);
     if (mapped_ptr == MAP_FAILED)
@@ -100,7 +101,7 @@ namespace kernel::tests
       throw std::runtime_error(error);
     }
 
-    return static_cast<std::byte *>(mapped_ptr);
+    return kstd::observer_ptr{static_cast<std::byte *>(mapped_ptr)};
   }
 
 }  // namespace kernel::tests
\ No newline at end of file
diff --git a/kernel/kernel/test_support/simulated_memory.hpp b/kernel/kernel/test_support/simulated_memory.hpp
index e1046ef4..e6161437 100644
--- a/kernel/kernel/test_support/simulated_memory.hpp
+++ b/kernel/kernel/test_support/simulated_memory.hpp
@@ -3,6 +3,7 @@
 
 #include <kapi/memory.hpp>
 
+#include <kstd/memory.hpp>
 #include <kstd/units.hpp>
 
 #include <cstddef>
@@ -32,10 +33,10 @@ namespace kernel::tests
     auto clear() -> void;
 
     //! Get the base address of the physical memory of this device.
-    [[nodiscard]] auto physical_base() noexcept -> std::byte *;
+    [[nodiscard]] auto physical_base() noexcept -> kstd::observer_ptr<std::byte>;
 
     //! Get the base address of the physical memory of this device.
-    [[nodiscard]] auto physical_base() const noexcept -> std::byte const *;
+    [[nodiscard]] auto physical_base() const noexcept -> kstd::observer_ptr<std::byte const>;
 
     //! Get the size of the physical memory of this device.
     [[nodiscard]] auto physical_size() const noexcept -> kstd::bytes;
@@ -52,14 +53,14 @@ namespace kernel::tests
     //! @param to The base address of the virtual region.
     //! @param offset The offset into the physical memory to map.
     //! @return A pointer to the first byte of the mapped region.
-    [[nodiscard]] auto map(kstd::bytes size, std::byte * to, off_t offset) -> std::byte *;
+    [[nodiscard]] auto map(kstd::bytes size, std::byte * to, off_t offset) -> kstd::observer_ptr<std::byte>;
 
   private:
     int m_descriptor{};
     kstd::bytes m_physical_size{0};
     kstd::bytes m_virtual_size{0};
-    std::byte * m_physical_base{nullptr};
-    std::byte * m_virtual_base{nullptr};
+    kstd::observer_ptr<std::byte> m_physical_base{nullptr};
+    kstd::observer_ptr<std::byte> m_virtual_base{nullptr};
   };
 
 }  // namespace kernel::tests