list.h

Go to the documentation of this file.

 
#pragma once
 
#include <type_traits>
 
#include <rex/assert.h>
#include <rex/kernel/heap.h>
#include <rex/types.h>
 
namespace rex::kernel {
 
struct X_LIST_ENTRY {
  be_u32 flink_ptr; 
  be_u32 blink_ptr; 
};
REX_STATIC_ASSERT_SIZE(X_LIST_ENTRY, 8);
 
struct X_SINGLE_LIST_ENTRY {
  be_u32 next;
};
REX_STATIC_ASSERT_SIZE(X_SINGLE_LIST_ENTRY, 4);
 
struct X_SLIST_HEADER {
  X_SINGLE_LIST_ENTRY next; 
  be_u16 depth;             
  be_u16 sequence;          
};
REX_STATIC_ASSERT_SIZE(X_SLIST_HEADER, 8);
 
struct X_KSPINLOCK {
  be_u32 owner_pcr; 
};
REX_STATIC_ASSERT_SIZE(X_KSPINLOCK, 4);
 
}  // namespace rex::kernel
 
namespace rex::kernel {

template <typename VirtualTranslator>
X_LIST_ENTRY* HostListEntry(u32 ptr, VirtualTranslator context) {
  return context->template TranslateVirtual<X_LIST_ENTRY*>(ptr);
}
 
template <typename VirtualTranslator>
u32 GuestListAddress(X_LIST_ENTRY* ptr, VirtualTranslator context) {
  return context->HostToGuestVirtual(ptr);
}

template <typename VirtualTranslator>
void InitializeListHead(X_LIST_ENTRY* entry, VirtualTranslator context) {
  if constexpr (std::is_unsigned_v<VirtualTranslator>) {
    entry->blink_ptr = context;
    entry->flink_ptr = context;
  } else {
    u32 orig_ptr = GuestListAddress(entry, context);
    entry->blink_ptr = orig_ptr;
    entry->flink_ptr = orig_ptr;
  }
}

template <typename VirtualTranslator>
bool IsListEmpty(X_LIST_ENTRY* entry, VirtualTranslator context) {
  return HostListEntry(entry->flink_ptr, context) == entry;
}
 
template <typename VirtualTranslator>
void RemoveEntryList(X_LIST_ENTRY* entry, VirtualTranslator context) {
  u32 front = entry->flink_ptr;
  u32 back = entry->blink_ptr;
  HostListEntry(back, context)->flink_ptr = front;
  HostListEntry(front, context)->blink_ptr = back;
}

template <typename VirtualTranslator>
void RemoveEntryList(u32 entry, VirtualTranslator context) {
  RemoveEntryList(HostListEntry(entry, context), context);
}

template <typename VirtualTranslator>
u32 RemoveHeadList(X_LIST_ENTRY* entry, VirtualTranslator context) {
  u32 result = entry->flink_ptr;
  RemoveEntryList(result, context);
  return result;
}

template <typename VirtualTranslator>
void InsertTailList(X_LIST_ENTRY* list_head, u32 list_head_guest, X_LIST_ENTRY* host_entry,
                    u32 entry, VirtualTranslator context) {
  u32 old_tail = list_head->blink_ptr;
  host_entry->flink_ptr = list_head_guest;
  host_entry->blink_ptr = old_tail;
  HostListEntry(old_tail, context)->flink_ptr = entry;
  list_head->blink_ptr = entry;
}

template <typename VirtualTranslator>
void InsertTailList(u32 list_head, u32 entry, VirtualTranslator context) {
  InsertTailList(HostListEntry(list_head, context), list_head, HostListEntry(entry, context), entry,
                 context);
}
 
template <typename VirtualTranslator>
void InsertTailList(X_LIST_ENTRY* list_head, X_LIST_ENTRY* entry, VirtualTranslator context) {
  InsertTailList(list_head, GuestListAddress(list_head, context), entry,
                 GuestListAddress(entry, context), context);
}

template <typename VirtualTranslator>
void InsertHeadList(X_LIST_ENTRY* list_head, u32 list_head_guest, X_LIST_ENTRY* host_entry,
                    u32 entry, VirtualTranslator context) {
  u32 old_list_head_flink = list_head->flink_ptr;
  host_entry->flink_ptr = old_list_head_flink;
  host_entry->blink_ptr = list_head_guest;
  HostListEntry(old_list_head_flink, context)->blink_ptr = entry;
  list_head->flink_ptr = entry;
}

template <typename VirtualTranslator>
void InsertHeadList(u32 list_head, X_LIST_ENTRY* entry, VirtualTranslator context) {
  InsertHeadList(HostListEntry(list_head, context), list_head, entry,
                 GuestListAddress(entry, context), context);
}
 
template <typename VirtualTranslator>
void InsertHeadList(X_LIST_ENTRY* list_head, X_LIST_ENTRY* entry, VirtualTranslator context) {
  InsertHeadList(list_head, GuestListAddress(list_head, context), entry,
                 GuestListAddress(entry, context), context);
}

template <typename TObject, size_t EntryListOffset>
struct X_TYPED_LIST : public X_LIST_ENTRY {
  using ThisType = X_TYPED_LIST<TObject, EntryListOffset>;
 
  static X_LIST_ENTRY* ObjectListEntry(TObject* obj) {
    return reinterpret_cast<X_LIST_ENTRY*>(
        &reinterpret_cast<char*>(obj)[static_cast<ptrdiff_t>(EntryListOffset)]);
  }
 
  static TObject* ListEntryObject(X_LIST_ENTRY* entry) {
    return reinterpret_cast<TObject*>(
        &reinterpret_cast<char*>(entry)[-static_cast<ptrdiff_t>(EntryListOffset)]);
  }

  template <typename VirtualTranslator>
  struct ForwardIterator {
    VirtualTranslator vt;
    u32 current_entry;
 
    ForwardIterator& operator++() {
      current_entry = vt->template TranslateVirtual<X_LIST_ENTRY*>(current_entry)->flink_ptr;
      return *this;
    }
 
    bool operator!=(u32 other_ptr) const { return current_entry != other_ptr; }
 
    TObject& operator*() {
      return *ListEntryObject(vt->template TranslateVirtual<X_LIST_ENTRY*>(current_entry));
    }
  };

  template <typename VirtualTranslator>
  struct ForwardIteratorBegin {
    VirtualTranslator vt;
    ThisType* const list_head;
 
    ForwardIterator<VirtualTranslator> begin() {
      return ForwardIterator<VirtualTranslator>{vt, list_head->flink_ptr};
    }
 
    u32 end() { return vt->HostToGuestVirtual(list_head); }
  };
 
  template <typename VirtualTranslator>
  ForwardIteratorBegin<VirtualTranslator> IterateForward(VirtualTranslator vt) {
    return ForwardIteratorBegin<VirtualTranslator>{vt, this};
  }

  template <typename VirtualTranslator>
  void Initialize(VirtualTranslator translator) {
    InitializeListHead(this, translator);
  }
 
  template <typename VirtualTranslator>
  void InsertHead(TObject* entry, VirtualTranslator translator) {
    InsertHeadList(static_cast<X_LIST_ENTRY*>(this), ObjectListEntry(entry), translator);
  }
 
  template <typename VirtualTranslator>
  void InsertTail(TObject* entry, VirtualTranslator translator) {
    InsertTailList(this, ObjectListEntry(entry), translator);
  }
 
  template <typename VirtualTranslator>
  bool empty(VirtualTranslator vt) const {
    return vt->template TranslateVirtual<X_LIST_ENTRY*>(flink_ptr) == this;
  }

  template <typename VirtualTranslator>
  TObject* HeadObject(VirtualTranslator vt) {
    return ListEntryObject(vt->template TranslateVirtual<X_LIST_ENTRY*>(flink_ptr));
  }
};
 
}  // namespace rex::kernel