[zion] Store capability ids on the CapabilityTable.

This is preferable to storing it in the capability itself since the id
is really just an index for the containing process.

zion/capability/capability.h

@@ -10,19 +10,16 @@ class Thread;
 
 class Capability : public RefCounted<Capability> {
  public:
-  Capability(const RefPtr<KernelObject>& obj, uint64_t id, uint64_t permissions)
-      : obj_(obj), id_(id), permissions_(permissions) {}
+  Capability(const RefPtr<KernelObject>& obj, uint64_t permissions)
+      : obj_(obj), permissions_(permissions) {}
 
   template <typename T>
-  Capability(const RefPtr<T>& obj, uint64_t id, uint64_t permissions)
-      : Capability(StaticCastRefPtr<KernelObject>(obj), id, permissions) {}
+  Capability(const RefPtr<T>& obj, uint64_t permissions)
+      : Capability(StaticCastRefPtr<KernelObject>(obj), permissions) {}
 
   template <typename T>
   RefPtr<T> obj();
 
-  uint64_t id() { return id_; }
-  void set_id(uint64_t id) { id_ = id; }
-
   uint64_t permissions() { return permissions_; }
   bool HasPermissions(uint64_t requested) {
     return (permissions_ & requested) == requested;
@@ -30,7 +27,6 @@ class Capability : public RefCounted<Capability> {
 
  private:
   RefPtr<KernelObject> obj_;
-  uint64_t id_;
   uint64_t permissions_;
 };
 

zion/capability/capability_table.cpp

@@ -4,17 +4,17 @@ CapabilityTable::CapabilityTable() {}
 
 uint64_t CapabilityTable::AddExistingCapability(const RefPtr<Capability>& cap) {
   MutexHolder h(lock_);
-  cap->set_id(next_cap_id_++);
-  capabilities_.PushBack(cap);
-  return cap->id();
+  uint64_t id = next_cap_id_++;
+  capabilities_.PushBack({.id = id, .cap = cap});
+  return id;
 }
 
 RefPtr<Capability> CapabilityTable::GetCapability(uint64_t id) {
   MutexHolder h(lock_);
   auto iter = capabilities_.begin();
   while (iter != capabilities_.end()) {
-    if (*iter && iter->id() == id) {
-      return *iter;
+    if (iter->cap && iter->id == id) {
+      return iter->cap;
     }
     ++iter;
   }
@@ -27,10 +27,10 @@ RefPtr<Capability> CapabilityTable::ReleaseCapability(uint64_t id) {
   MutexHolder h(lock_);
   auto iter = capabilities_.begin();
   while (iter != capabilities_.end()) {
-    if (*iter && iter->id() == id) {
+    if (iter->cap && iter->id == id) {
       // FIXME: Do an actual release here.
-      auto cap = *iter;
-      *iter = {nullptr};
+      auto cap = iter->cap;
+      iter->cap = {nullptr};
       return cap;
     }
     ++iter;

zion/capability/capability_table.h

@@ -29,7 +29,11 @@ class CapabilityTable {
   // FIXME: store this id here rather than in the capability.
   uint64_t next_cap_id_ = 0x100;
   // FIXME: use a map data structure.
-  LinkedList<RefPtr<Capability>> capabilities_;
+  struct CapEntry {
+    uint64_t id;
+    RefPtr<Capability> cap;
+  };
+  LinkedList<CapEntry> capabilities_;
 };
 
 template <typename T>
@@ -37,7 +41,8 @@ uint64_t CapabilityTable::AddNewCapability(const RefPtr<T>& object,
                                            uint64_t permissions) {
   MutexHolder h(lock_);
   uint64_t id = next_cap_id_++;
-  capabilities_.PushBack(MakeRefCounted<Capability>(object, id, permissions));
+  capabilities_.PushBack(
+      {.id = id, .cap = MakeRefCounted<Capability>(object, permissions)});
   return id;
 }
 
@@ -45,5 +50,6 @@ template <typename T>
 void CapabilityTable::AddNewCapabilityWithId(uint64_t id,
                                              const RefPtr<T>& object,
                                              uint64_t permissions) {
-  capabilities_.PushBack(MakeRefCounted<Capability>(object, id, permissions));
+  capabilities_.PushBack(
+      {.id = id, .cap = MakeRefCounted<Capability>(object, permissions)});
 }

zion/lib/linked_list.h

@@ -88,7 +88,7 @@ class LinkedList {
     }
 
     T& operator*() { return item_->item; }
-    T& operator->() { return item_->item; }
+    T* operator->() { return &item_->item; }
     bool operator==(const Iterator& other) { return item_ == other.item_; }
     bool operator!=(const Iterator& other) { return item_ != other.item_; }
 

zion/object/process.cpp

@@ -42,7 +42,7 @@ RefPtr<Thread> Process::GetThread(uint64_t tid) {
   MutexHolder lock(mutex_);
   auto iter = threads_.begin();
   while (iter != threads_.end()) {
-    if (iter->tid() == tid) {
+    if ((*iter)->tid() == tid) {
       return *iter;
     }
     ++iter;
@@ -55,7 +55,7 @@ void Process::CheckState() {
   MutexHolder lock(mutex_);
   auto iter = threads_.begin();
   while (iter != threads_.end()) {
-    if (iter->GetState() != Thread::FINISHED) {
+    if ((*iter)->GetState() != Thread::FINISHED) {
       return;
     }
     ++iter;

zion/scheduler/process_manager.cpp

@@ -14,7 +14,7 @@ void ProcessManager::InsertProcess(const RefPtr<Process>& proc) {
 Process& ProcessManager::FromId(uint64_t pid) {
   auto iter = proc_list_.begin();
   while (iter != proc_list_.end()) {
-    if (iter->id() == pid) {
+    if ((*iter)->id() == pid) {
       return **iter;
     }
     ++iter;
@@ -28,7 +28,7 @@ void ProcessManager::DumpProcessStates() {
   dbgln("Process States: %u", proc_list_.size());
   auto iter = proc_list_.begin();
   while (iter != proc_list_.end()) {
-    dbgln("%u: %u", iter->id(), iter->GetState());
+    dbgln("%u: %u", (*iter)->id(), (*iter)->GetState());
     ++iter;
   }
 }