Rcu.h

/* Copyright (c) 2026, Pedigree Developers. SPDX-License-Identifier: ISC */
#ifndef PEDIGREE_KERNEL_PROCESS_RCU_H
#define PEDIGREE_KERNEL_PROCESS_RCU_H
 
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/process/Mutex.h"
#include "pedigree/kernel/process/RcuReadState.h"
 
class EXPORTED_PUBLIC RcuReadGuard {
 public:
  RcuReadGuard();
  ~RcuReadGuard();
 
 private:
  NOT_COPYABLE_OR_ASSIGNABLE(RcuReadGuard);
  RcuReadState* m_State;
  bool m_Interrupts;
};
 
template <typename T>
class RcuPointer {
 public:
  RcuPointer() = default;
  NOT_COPYABLE_OR_ASSIGNABLE(RcuPointer);
 
  T* load(const RcuReadGuard&) const {
    return __atomic_load_n(&m_Pointer, __ATOMIC_SEQ_CST);
  }
 
  T* loadForUpdate() const {
    return __atomic_load_n(&m_Pointer, __ATOMIC_SEQ_CST);
  }
 
  T* exchange(T* replacement) {
    return __atomic_exchange_n(&m_Pointer, replacement, __ATOMIC_SEQ_CST);
  }
 
 private:
  T* m_Pointer = nullptr;
};
 
namespace Rcu {
EXPORTED_PUBLIC void synchronize();
}  // namespace Rcu
 
class EXPORTED_PUBLIC RcuRetireQueue {
 public:
  static constexpr size_t Capacity = 32;
  using Reclaim = void (*)(void*);
 
  RcuRetireQueue() = default;
  ~RcuRetireQueue();
  void retire(void* object, Reclaim reclaim);
  void drain();
 
 private:
  NOT_COPYABLE_OR_ASSIGNABLE(RcuRetireQueue);
  void drainLocked();
  Mutex m_Lock;
  struct Entry {
    void* object;
    Reclaim reclaim;
  } m_Entries[Capacity];
  size_t m_Count = 0;
};
 
#endif