memory_classifier.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Jarosław Pelczar <jarek@jpelczar.com>
//
// SPDX-License-Identifier: BSD-2-Clause
 
#pragma once
 
#include "address_space.hpp"
#include <cstdint>
#include <type_traits>
 
namespace microfmt {
 
enum class memory_region_type : uint8_t {
  unknown = 0,
  kernel_code,    // Kernel text / executable code section
  kernel_data,    // Kernel initialized data (.data) and bss (.bss)
  kernel_stack,   // Kernel thread / exception stack
  process_stack,  // User-space thread stack
  direct_map,     // Physical-to-virtual direct mapping region (e.g., __va /
                  // PAGE_OFFSET)
  struct_pages,   // Array of page descriptors (e.g., Linux mem_map / page
                  // structs)
  kernel_heap,    // Kernel allocator pool (e.g., slab / slub / malloc)
  user_code,      // User-space text segment
  user_data,      // User-space data and heap
  device_mmio,    // Memory-Mapped I/O registers
  guard_page,     // Unmapped guard page for stack overflow detection
  ns_map,         // NonSecure Mapping on ARM TrustZone
  ns_device_mmio, // NonSecure Device mapping on ARM TrustZone
};
 
struct MICROFMT_API_CLASS memory_region_info {
  uintptr_t start_address{0};
 
  uintptr_t end_address{0};
 
  memory_region_type type{memory_region_type::unknown};
 
  uint32_t space_id{0};
 
  bool readable{false};
  bool writable{false};
  bool executable{false};
 
  [[nodiscard]] constexpr bool contains(uintptr_t addr) const noexcept {
    return addr >= start_address && addr < end_address;
  }
};
 
template <typename Tag> struct memory_classifier_traits;
 
class RELOCO_POINTER memory_classifier_ref {
public:
  struct vtable {
    bool (*classify_address)(const void *ctx, uintptr_t virt_addr, memory_region_info &out_info) noexcept = nullptr;
  };
 
  constexpr memory_classifier_ref() noexcept = default;
 
  template <typename Tag, typename Traits = memory_classifier_traits<Tag>,
            std::enable_if_t<std::is_void_v<typename Traits::context_type>, int> = 0>
  constexpr explicit memory_classifier_ref(Tag) noexcept : ctx_(nullptr), vtbl_(&s_vtbl<Tag>) {}
 
  template <typename Tag, typename Context, typename Traits = memory_classifier_traits<Tag>,
            std::enable_if_t<!std::is_void_v<typename Traits::context_type> &&
                                 std::is_convertible_v<const Context *, const typename Traits::context_type *>,
                             int> = 0>
  constexpr memory_classifier_ref(Tag, const Context &ctx RELOCO_LIFETIMEBOUND RELOCO_LIFETIME_CAPTURE_BY_THIS) noexcept
      : ctx_(&ctx), vtbl_(&s_vtbl<Tag>) {}
 
  template <typename Tag, typename Context, std::enable_if_t<!std::is_lvalue_reference_v<Context>, int> = 0>
  constexpr memory_classifier_ref(Tag, Context &&) = delete;
 
  template <typename Tag, typename Traits = memory_classifier_traits<Tag>,
            std::enable_if_t<std::is_void_v<typename Traits::context_type>, int> = 0>
  [[nodiscard]] static constexpr memory_classifier_ref make() noexcept {
    return memory_classifier_ref(Tag{});
  }
 
  template <typename Tag, typename Context, typename Traits = memory_classifier_traits<Tag>,
            std::enable_if_t<!std::is_void_v<typename Traits::context_type>, int> = 0>
  [[nodiscard]] static constexpr memory_classifier_ref make(const Context &ctx RELOCO_LIFETIMEBOUND) noexcept {
    return memory_classifier_ref(Tag{}, ctx);
  }
 
  template <typename Tag, typename Context, std::enable_if_t<!std::is_lvalue_reference_v<Context>, int> = 0>
  static memory_classifier_ref make(Context &&) = delete;
 
  [[nodiscard]] bool classify_address(uintptr_t virt_addr, memory_region_info &out_info) const noexcept {
    if (vtbl_ == nullptr || vtbl_->classify_address == nullptr)
      return false;
    return vtbl_->classify_address(ctx_.get(), virt_addr, out_info);
  }
 
  [[nodiscard]] constexpr explicit operator bool() const noexcept { return vtbl_ != nullptr; }
 
private:
  template <typename Tag>
  static bool classify_entry(const void *context, uintptr_t address, memory_region_info &info) noexcept {
    using context_type = typename memory_classifier_traits<Tag>::context_type;
    if constexpr (std::is_void_v<context_type>) {
      return memory_classifier_traits<Tag>::classify_address(address, info);
    } else {
      const auto &typed_context = *static_cast<const context_type *>(context);
      return memory_classifier_traits<Tag>::classify_address(value_ref<const context_type>(typed_context), address,
                                                             info);
    }
  }
 
  template <typename Tag> static constexpr vtable s_vtbl{&classify_entry<Tag>};
 
  value_ptr<const void> ctx_{};
  const vtable *vtbl_{nullptr};
};
 
template <typename Tag, bool Stateless = std::is_void_v<typename memory_classifier_traits<Tag>::context_type>>
class memory_classifier;
 
template <typename Tag> class RELOCO_OWNER memory_classifier<Tag, false> {
public:
  using traits_type = memory_classifier_traits<Tag>;
  using context_type = typename traits_type::context_type;
 
  constexpr explicit memory_classifier(context_type context) noexcept : context_(std::move(context)) {}
 
  [[nodiscard]] constexpr value_ref<context_type> context() & noexcept RELOCO_LIFETIMEBOUND {
    return value_ref<context_type>(context_);
  }
 
  [[nodiscard]] constexpr value_ref<const context_type> context() const & noexcept RELOCO_LIFETIMEBOUND {
    return value_ref<const context_type>(context_);
  }
 
  [[nodiscard]] constexpr memory_classifier_ref ref() const & noexcept RELOCO_LIFETIMEBOUND {
    return memory_classifier_ref(Tag{}, context_);
  }
 
  value_ref<context_type> context() && = delete;
  value_ref<const context_type> context() const && = delete;
  memory_classifier_ref ref() const && = delete;
 
private:
  context_type context_;
};
 
template <typename Tag> class memory_classifier<Tag, true> {
public:
  [[nodiscard]] static constexpr memory_classifier_ref ref() noexcept { return memory_classifier_ref(Tag{}); }
};
 
} // namespace microfmt