kernel: replace some more plain pointers

14 files changed, 45 insertions, 39 deletions

diff --git a/kapi/kapi/devices/bus.hpp b/kapi/kapi/devices/bus.hpp
index 476216c7..018cf2ae 100644
--- a/kapi/kapi/devices/bus.hpp
+++ b/kapi/kapi/devices/bus.hpp
@@ -66,7 +66,7 @@ namespace kapi::devices
 
     mutable tracked_mutex m_lock{};
 
-    bus_protocol * m_protocol{};
+    kstd::observer_ptr<bus_protocol> m_protocol{};
     kstd::vector<kstd::shared_ptr<device>> m_devices{};
   };
 
diff --git a/kapi/kapi/devices/facet_registry.hpp b/kapi/kapi/devices/facet_registry.hpp
index 4fa6186a..5fb4795a 100644
--- a/kapi/kapi/devices/facet_registry.hpp
+++ b/kapi/kapi/devices/facet_registry.hpp
@@ -274,7 +274,7 @@ namespace kapi::devices
 
     kstd::vector<entry> m_entries;
     kstd::vector<kstd::weak_ptr<facet_registry_observer>> m_observers;
-    kstd::vector<facet_registry_observer *> m_static_observers;
+    kstd::vector<kstd::observer_ptr<facet_registry_observer>> m_static_observers;
   };
 
   //! @}
diff --git a/kapi/kapi/memory/address.hpp b/kapi/kapi/memory/address.hpp
index 0fab06e0..79806ce4 100644
--- a/kapi/kapi/memory/address.hpp
+++ b/kapi/kapi/memory/address.hpp
@@ -76,7 +76,7 @@ namespace kapi::memory
     template<typename ObjectType>
     explicit operator kstd::observer_ptr<ObjectType>() const noexcept
     {
-      return kstd::make_observer(reinterpret_cast<ObjectType *>(m_value));
+      return kstd::make_observer(std::bit_cast<ObjectType *>(m_value));
     }
 
     //! Create a new address n beyond this one.
diff --git a/kapi/kapi/memory/page_mapper.hpp b/kapi/kapi/memory/page_mapper.hpp
index a310e209..5ac0210f 100644
--- a/kapi/kapi/memory/page_mapper.hpp
+++ b/kapi/kapi/memory/page_mapper.hpp
@@ -73,7 +73,7 @@ namespace kapi::memory
     template<typename T>
     [[nodiscard]] auto map_as(page page, frame frame, flags flags) -> kstd::observer_ptr<T>
     {
-      return std::bit_cast<T *>(map(page, frame, flags));
+      return reinterpret_pointer_cast<T>(map(page, frame, flags));
     }
 
   protected:
diff --git a/kernel/kapi/devices/facet_registry.cpp b/kernel/kapi/devices/facet_registry.cpp
index f2f5d03b..a988a6a4 100644
--- a/kernel/kapi/devices/facet_registry.cpp
+++ b/kernel/kapi/devices/facet_registry.cpp
@@ -79,7 +79,7 @@ namespace kapi::devices
   auto facet_registry::do_notify_published(kapi::capabilities::facet_id id, entry const & published) -> void
   {
     auto observers = kstd::vector<kstd::weak_ptr<facet_registry_observer>>{};
-    auto static_observers = kstd::vector<facet_registry_observer *>{};
+    auto static_observers = kstd::vector<kstd::observer_ptr<facet_registry_observer>>{};
     {
       auto guard = kstd::lock_guard{m_lock};
       observers = m_observers;
@@ -99,7 +99,7 @@ namespace kapi::devices
   auto facet_registry::do_notify_withdrawn(kapi::capabilities::facet_id id, device const & device) -> void
   {
     auto observers = kstd::vector<kstd::weak_ptr<facet_registry_observer>>{};
-    auto static_observers = kstd::vector<facet_registry_observer *>{};
+    auto static_observers = kstd::vector<kstd::observer_ptr<facet_registry_observer>>{};
     {
       auto guard = kstd::lock_guard{m_lock};
       observers = m_observers;
@@ -227,7 +227,7 @@ namespace kapi::devices
   {
     auto guard = kstd::lock_guard{m_lock};
 
-    m_static_observers.push_back(&observer);
+    m_static_observers.push_back(kstd::make_observer(&observer));
   }
 
   auto facet_registry::unsubscribe(facet_registry_observer & observer) -> void
@@ -235,7 +235,7 @@ namespace kapi::devices
     auto guard = kstd::lock_guard{m_lock};
 
     erase_if(m_observers, [&](auto const & subscribed) { return subscribed.lock().get() == &observer; });
-    erase(m_static_observers, &observer);
+    erase(m_static_observers, kstd::make_observer(&observer));
   }
 
 }  // namespace kapi::devices
diff --git a/kernel/kapi/interrupts.cpp b/kernel/kapi/interrupts.cpp
index c5925058..a1bcba93 100644
--- a/kernel/kapi/interrupts.cpp
+++ b/kernel/kapi/interrupts.cpp
@@ -14,7 +14,8 @@ namespace kapi::interrupts
 
   namespace
   {
-    auto constinit handlers = kstd::flat_map<std::uint32_t, kstd::vector<std::pair<handler *, kstd::weak_ptr<void>>>>{};
+    auto constinit handlers =
+        kstd::flat_map<std::uint32_t, kstd::vector<std::pair<kstd::observer_ptr<handler>, kstd::weak_ptr<void>>>>{};
   }  // namespace
 
   auto register_handler(std::uint32_t irq_number, handler & handler, kstd::weak_ptr<void> context) -> void
@@ -22,12 +23,12 @@ namespace kapi::interrupts
     if (handlers.contains(irq_number))
     {
       auto & handler_list = handlers.at(irq_number);
-      handler_list.push_back(std::pair{&handler, context});
+      handler_list.push_back(std::pair{kstd::make_observer(&handler), context});
     }
     else
     {
       handlers.emplace(irq_number, kstd::vector{
-                                     std::pair{&handler, context}
+                                     std::pair{kstd::make_observer(&handler), context}
       });
     }
   }
@@ -35,8 +36,8 @@ namespace kapi::interrupts
   auto unregister_handler(std::uint32_t irq_number, handler & handler) -> void
   {
     auto & handler_list = handlers.at(irq_number);
-    auto [first, last] =
-        std::ranges::remove_if(handler_list, [&](auto const & entry) { return entry.first == &handler; });
+    auto [first, last] = std::ranges::remove_if(
+        handler_list, [&](auto const & entry) { return entry.first == kstd::make_observer(&handler); });
     handler_list.erase(first, last);
   }
 
diff --git a/kernel/kapi/memory.cpp b/kernel/kapi/memory.cpp
index 7a9f7249..666910ba 100644
--- a/kernel/kapi/memory.cpp
+++ b/kernel/kapi/memory.cpp
@@ -128,7 +128,7 @@ namespace kapi::memory
     }
 
     auto const flags = page_mapper::flags::writable | page_mapper::flags::supervisor_only | page_mapper::flags::global;
-    auto bitmap_ptr = static_cast<std::uint64_t *>(nullptr);
+    auto bitmap_ptr = kstd::observer_ptr<std::uint64_t>{nullptr};
 
     std::ranges::for_each(std::views::iota(0uz, bitmap_pages), [&](auto index) {
       auto page = page::containing(pmm_metadata_base + index * page::size);
@@ -136,12 +136,12 @@ namespace kapi::memory
       auto mapped = active_page_mapper->map(page, frame, flags);
       if (!bitmap_ptr)
       {
-        bitmap_ptr = reinterpret_cast<std::uint64_t *>(mapped.get());
+        bitmap_ptr = reinterpret_pointer_cast<std::uint64_t>(mapped);
       }
     });
 
-    auto bitmap =
-        std::span{bitmap_ptr, (bitmap_bytes + kstd::size_of<std::uint64_t>() - 1_B) / kstd::size_of<std::uint64_t>()};
+    auto bitmap = std::span{bitmap_ptr.get(),
+                            (bitmap_bytes + kstd::size_of<std::uint64_t>() - 1_B) / kstd::size_of<std::uint64_t>()};
 
     allocator.emplace(bitmap, frame_count);
 
diff --git a/kernel/kernel/acpi/manager.cpp b/kernel/kernel/acpi/manager.cpp
index e99baed8..2ba6d558 100644
--- a/kernel/kernel/acpi/manager.cpp
+++ b/kernel/kernel/acpi/manager.cpp
@@ -29,7 +29,7 @@ namespace kernel::acpi
 
     if (m_extended)
     {
-      if (!static_cast<::acpi::xsdp const *>(m_sdp)->validate())
+      if (!static_pointer_cast<::acpi::xsdp const>(m_sdp)->validate())
       {
         kapi::system::panic("[OS:ACPI] Invalid XSDP signature!");
       }
@@ -44,12 +44,12 @@ namespace kernel::acpi
 
     auto physical_address = kapi::memory::physical_address{m_sdp->table_address()};
     auto linear_address = kapi::memory::hhdm_to_linear(physical_address);
-    m_rsdt = static_cast<::acpi::table_header const *>(linear_address);
+    m_rsdt = static_cast<kstd::observer_ptr<::acpi::table_header const>>(linear_address);
   }
 
   auto manager::load_tables() -> bool
   {
-    if (!::acpi::validate_checksum({reinterpret_cast<std::byte const *>(m_rsdt), m_rsdt->length().value}))
+    if (!::acpi::validate_checksum({reinterpret_pointer_cast<std::byte const>(m_rsdt).get(), m_rsdt->length().value}))
     {
       kapi::system::panic("[OS:ACPI] Invalid RSDT checksum!");
     }
@@ -57,7 +57,7 @@ namespace kernel::acpi
     auto check_and_register_table = [&](auto table_address) -> void {
       auto physical_table_address = kapi::memory::physical_address{reinterpret_cast<std::uintptr_t>(table_address)};
       auto mapped_table = kapi::memory::hhdm_to_linear(physical_table_address);
-      auto table = static_cast<::acpi::table_header const *>(mapped_table);
+      auto table = static_cast<kstd::observer_ptr<::acpi::table_header const>>(mapped_table);
 
       if (!::acpi::validate_checksum({static_cast<std::byte const *>(mapped_table), table->length().value}))
       {
@@ -72,13 +72,13 @@ namespace kernel::acpi
 
     if (m_extended)
     {
-      auto xsdt = static_cast<::acpi::xsdt const *>(m_rsdt);
+      auto xsdt = static_pointer_cast<::acpi::xsdt const>(m_rsdt);
       std::ranges::for_each(*xsdt | std::views::transform([](auto const & entry) { return entry.address(); }),
                             check_and_register_table);
     }
     else
     {
-      auto rsdt = static_cast<::acpi::rsdt const *>(m_rsdt);
+      auto rsdt = static_pointer_cast<::acpi::rsdt const>(m_rsdt);
       std::ranges::for_each(*rsdt | std::views::transform([](auto const & entry) { return entry.address(); }),
                             check_and_register_table);
     }
@@ -90,7 +90,7 @@ namespace kernel::acpi
   {
     if (m_tables.contains(signature))
     {
-      return kstd::make_observer(m_tables.at(signature));
+      return m_tables.at(signature);
     }
     return nullptr;
   }
diff --git a/kernel/kernel/acpi/manager.hpp b/kernel/kernel/acpi/manager.hpp
index ba05c682..de344dd8 100644
--- a/kernel/kernel/acpi/manager.hpp
+++ b/kernel/kernel/acpi/manager.hpp
@@ -21,9 +21,9 @@ namespace kernel::acpi
     auto get_table(std::string_view signature) -> kstd::observer_ptr<::acpi::table_header const>;
 
   private:
-    ::acpi::rsdp const * m_sdp{};
-    ::acpi::table_header const * m_rsdt{};
-    kstd::flat_map<std::string_view, ::acpi::table_header const *> m_tables{};
+    kstd::observer_ptr<::acpi::rsdp const> m_sdp{};
+    kstd::observer_ptr<::acpi::table_header const> m_rsdt{};
+    kstd::flat_map<std::string_view, kstd::observer_ptr<::acpi::table_header const>> m_tables{};
     bool m_extended{};
   };
 
diff --git a/kernel/kernel/filesystems/ext2/directory_iterator.cpp b/kernel/kernel/filesystems/ext2/directory_iterator.cpp
index b1bb8b4f..9c396d33 100644
--- a/kernel/kernel/filesystems/ext2/directory_iterator.cpp
+++ b/kernel/kernel/filesystems/ext2/directory_iterator.cpp
@@ -6,6 +6,7 @@
 
 #include <kapi/system.hpp>
 
+#include <kstd/memory.hpp>
 #include <kstd/units.hpp>
 #include <kstd/vector.hpp>
 
@@ -40,12 +41,12 @@ namespace kernel::filesystems::ext2
 
   auto directory_iterator::operator*() const -> reference
   {
-    return *reinterpret_cast<pointer>(m_buffer.data());
+    return *reinterpret_cast<pointer::element_type *>(m_buffer.data());
   }
 
   auto directory_iterator::operator->() const -> pointer
   {
-    return reinterpret_cast<pointer>(m_buffer.data());
+    return kstd::observer_ptr{reinterpret_cast<pointer::element_type *>(m_buffer.data())};
   }
 
   auto directory_iterator::operator++() -> directory_iterator &
@@ -87,7 +88,7 @@ namespace kernel::filesystems::ext2
       kapi::system::panic("[FS:EXT2] failed to read directory entry", result.error());
     }
 
-    auto entry = reinterpret_cast<pointer>(m_buffer.data());
+    auto entry = kstd::observer_ptr{reinterpret_cast<pointer::element_type *>(m_buffer.data())};
 
     auto const remainder = entry->name_len - 1;
 
@@ -100,7 +101,7 @@ namespace kernel::filesystems::ext2
         kapi::system::panic("[FS:EXT2] failed to read directory entry", result.error());
       }
 
-      entry = reinterpret_cast<pointer>(m_buffer.data());
+      entry = kstd::observer_ptr{reinterpret_cast<pointer::element_type *>(m_buffer.data())};
     }
 
     m_file_offset = m_file_offset + static_cast<kstd::bytes>(entry->rec_len);
diff --git a/kernel/kernel/filesystems/ext2/directory_iterator.hpp b/kernel/kernel/filesystems/ext2/directory_iterator.hpp
index 5ddcbec3..09194a43 100644
--- a/kernel/kernel/filesystems/ext2/directory_iterator.hpp
+++ b/kernel/kernel/filesystems/ext2/directory_iterator.hpp
@@ -20,7 +20,7 @@ namespace kernel::filesystems::ext2
     using iterator_category = std::forward_iterator_tag;
     using iterator_concept = std::forward_iterator_tag;
     using value_type = linked_directory_entry;
-    using pointer = linked_directory_entry const *;
+    using pointer = kstd::observer_ptr<linked_directory_entry const>;
     using reference = linked_directory_entry const &;
     using difference_type = std::ptrdiff_t;
 
diff --git a/kernel/kernel/filesystems/ext2/filesystem.cpp b/kernel/kernel/filesystems/ext2/filesystem.cpp
index eefd658c..eb77ee81 100644
--- a/kernel/kernel/filesystems/ext2/filesystem.cpp
+++ b/kernel/kernel/filesystems/ext2/filesystem.cpp
@@ -208,7 +208,7 @@ namespace kernel::filesystems::ext2
     //! @return A pointer to the written entry on success, an error otherwise.
     auto write_directory_entry_to_buffer(std::span<std::byte> buffer, kstd::bytes offset, inode & target,
                                          std::string_view name, kapi::filesystem::file_type type)
-        -> kstd::result<linked_directory_entry *>
+        -> kstd::result<kstd::observer_ptr<linked_directory_entry>>
     {
       auto const name_length = static_cast<std::uint8_t>(name.size());
       auto const record_size = (sizeof(linked_directory_entry) - 1 + name_length + 3u) & ~3u;
@@ -218,7 +218,7 @@ namespace kernel::filesystems::ext2
         return kstd::failure(vfs::errc::invalid_argument);
       }
 
-      auto * entry = reinterpret_cast<linked_directory_entry *>(buffer.data() + offset);
+      auto entry = kstd::observer_ptr{reinterpret_cast<linked_directory_entry *>(buffer.data() + offset)};
       entry->inode = target.number();
       entry->rec_len = record_size;
       entry->name_len = name_length;
@@ -366,7 +366,7 @@ namespace kernel::filesystems::ext2
       auto offset = 0_B;
       while (true)
       {
-        auto const * entry = reinterpret_cast<linked_directory_entry const *>(buffer.data() + offset);
+        auto entry = kstd::observer_ptr{reinterpret_cast<linked_directory_entry const *>(buffer.data() + offset)};
         if (offset + kstd::bytes{entry->rec_len} >= block_size(state))
         {
           break;
@@ -378,7 +378,7 @@ namespace kernel::filesystems::ext2
       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);
+      auto last_entry = kstd::observer_ptr{reinterpret_cast<linked_directory_entry *>(buffer.data() + offset)};
       auto const last_entry_actual_len = static_cast<kstd::bytes>((8u + last_entry->name_len + 3u) & ~3u);
 
       if (kstd::bytes{last_entry->rec_len} - last_entry_actual_len >= needed_rec_len)
diff --git a/kernel/kernel/filesystems/ext2/write_batch.cpp b/kernel/kernel/filesystems/ext2/write_batch.cpp
index 76865a47..b151f28b 100644
--- a/kernel/kernel/filesystems/ext2/write_batch.cpp
+++ b/kernel/kernel/filesystems/ext2/write_batch.cpp
@@ -6,6 +6,8 @@
 
 #include <kapi/system.hpp>
 
+#include <kstd/memory.hpp>
+
 #include <algorithm>
 #include <cstddef>
 #include <ranges>
@@ -57,9 +59,10 @@ namespace kernel::filesystems::ext2
 
   auto write_batch::mark_inode(inode & inode) -> void
   {
-    if (std::ranges::find(m_dirty_inodes, &inode) == std::ranges::end(m_dirty_inodes))
+    auto inode_pointer = kstd::make_observer(&inode);
+    if (std::ranges::find(m_dirty_inodes, inode_pointer) == std::ranges::end(m_dirty_inodes))
     {
-      m_dirty_inodes.push_back(&inode);
+      m_dirty_inodes.push_back(inode_pointer);
     }
   }
 
diff --git a/kernel/kernel/filesystems/ext2/write_batch.hpp b/kernel/kernel/filesystems/ext2/write_batch.hpp
index dc4502b3..52204193 100644
--- a/kernel/kernel/filesystems/ext2/write_batch.hpp
+++ b/kernel/kernel/filesystems/ext2/write_batch.hpp
@@ -3,6 +3,7 @@
 
 #include <kernel/filesystems/ext2/driver_state.hpp>
 
+#include <kstd/memory.hpp>
 #include <kstd/vector.hpp>
 
 #include <cstddef>
@@ -43,7 +44,7 @@ namespace kernel::filesystems::ext2
   private:
     driver_state & m_state;
     kstd::vector<std::size_t> m_dirty_groups{};
-    kstd::vector<inode *> m_dirty_inodes{};
+    kstd::vector<kstd::observer_ptr<inode>> m_dirty_inodes{};
   };
 
 }  // namespace kernel::filesystems::ext2