[zion] Add per-process CapabilityTable object

Store this information in it's own object to make the API clearer.

zion/CMakeLists.txt

@@ -2,6 +2,7 @@ add_executable(zion
   boot/acpi.cpp
   boot/boot_info.cpp
   capability/capability.cpp
+  capability/capability_table.cpp
   common/gdt.cpp
   common/load_gdt.s
   common/msr.cpp

zion/capability/capability_table.cpp

@@ -0,0 +1,41 @@
+#include "capability/capability_table.h"
+
+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();
+}
+
+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;
+    }
+    ++iter;
+  }
+  dbgln("Bad cap access %u", id);
+  dbgln("Num caps: %u", capabilities_.size());
+  return {};
+}
+
+RefPtr<Capability> CapabilityTable::ReleaseCapability(uint64_t id) {
+  MutexHolder h(lock_);
+  auto iter = capabilities_.begin();
+  while (iter != capabilities_.end()) {
+    if (*iter && iter->id() == id) {
+      // FIXME: Do an actual release here.
+      auto cap = *iter;
+      *iter = {nullptr};
+      return cap;
+    }
+    ++iter;
+  }
+  dbgln("Bad cap release: %u", id);
+  dbgln("Num caps: %u", capabilities_.size());
+  return {};
+}

zion/capability/capability_table.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include "capability/capability.h"
+#include "lib/linked_list.h"
+#include "lib/mutex.h"
+#include "lib/ref_ptr.h"
+
+class CapabilityTable {
+ public:
+  CapabilityTable();
+
+  CapabilityTable(CapabilityTable&) = delete;
+  CapabilityTable& operator=(CapabilityTable&) = delete;
+
+  template <typename T>
+  uint64_t AddNewCapability(const RefPtr<T>& object, Capability::Type type,
+                            uint64_t permissions);
+  uint64_t AddExistingCapability(const RefPtr<Capability>& cap);
+
+  // FIXME: Remove reliance on this.
+  template <typename T>
+  void AddNewCapabilityWithId(uint64_t id, const RefPtr<T>& object,
+                              Capability::Type type, uint64_t permissions);
+
+  RefPtr<Capability> GetCapability(uint64_t id);
+  RefPtr<Capability> ReleaseCapability(uint64_t id);
+
+ private:
+  Mutex lock_{"cap table"};
+  // 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_;
+};
+
+template <typename T>
+uint64_t CapabilityTable::AddNewCapability(const RefPtr<T>& object,
+                                           Capability::Type type,
+                                           uint64_t permissions) {
+  MutexHolder h(lock_);
+  uint64_t id = next_cap_id_++;
+  capabilities_.PushBack(
+      MakeRefCounted<Capability>(object, type, id, permissions));
+  return id;
+}
+
+template <typename T>
+void CapabilityTable::AddNewCapabilityWithId(uint64_t id,
+                                             const RefPtr<T>& object,
+                                             Capability::Type type,
+                                             uint64_t permissions) {
+  capabilities_.PushBack(
+      MakeRefCounted<Capability>(object, type, id, permissions));
+}

zion/object/process.cpp

@@ -22,11 +22,11 @@ RefPtr<Process> Process::RootProcess() {
 }
 RefPtr<Process> Process::Create() {
   auto proc = MakeRefCounted<Process>();
-  proc->caps_.PushBack(
-      MakeRefCounted<Capability>(proc, Capability::PROCESS, Z_INIT_PROC_SELF,
-                                 ZC_PROC_SPAWN_PROC | ZC_PROC_SPAWN_THREAD));
-  proc->caps_.PushBack(MakeRefCounted<Capability>(
-      proc->vmas(), Capability::ADDRESS_SPACE, Z_INIT_VMAS_SELF, ZC_WRITE));
+  proc->caps_.AddNewCapabilityWithId(Z_INIT_PROC_SELF, proc,
+                                     Capability::PROCESS,
+                                     ZC_PROC_SPAWN_PROC | ZC_PROC_SPAWN_THREAD);
+  proc->caps_.AddNewCapabilityWithId(Z_INIT_VMAS_SELF, proc->vmas(),
+                                     Capability::ADDRESS_SPACE, ZC_WRITE);
   return proc;
 }
 
@@ -66,88 +66,42 @@ void Process::CheckState() {
 }
 
 RefPtr<Capability> Process::ReleaseCapability(uint64_t cid) {
-  MutexHolder lock(mutex_);
-  auto iter = caps_.begin();
-  while (iter != caps_.end()) {
-    if (*iter && iter->id() == cid) {
-      auto cap = *iter;
-      *iter = {nullptr};
-      return cap;
-    }
-    ++iter;
-  }
-  dbgln("Bad cap release: %u", cid);
-  dbgln("Num caps: %u", caps_.size());
-  return {};
+  return caps_.ReleaseCapability(cid);
 }
 
 RefPtr<Capability> Process::GetCapability(uint64_t cid) {
-  MutexHolder lock(mutex_);
-  auto iter = caps_.begin();
-  while (iter != caps_.end()) {
-    if (*iter && iter->id() == cid) {
-      return *iter;
-    }
-    ++iter;
-  }
-  dbgln("Bad cap access %u", cid);
-  dbgln("Num caps: %u", caps_.size());
-  return {};
+  return caps_.GetCapability(cid);
 }
 
 uint64_t Process::AddCapability(const RefPtr<Capability>& cap) {
-  MutexHolder lock(mutex_);
-  cap->set_id(next_cap_id_++);
-  caps_.PushBack(cap);
-  return cap->id();
+  return caps_.AddExistingCapability(cap);
 }
 uint64_t Process::AddCapability(const RefPtr<Thread>& thread) {
-  MutexHolder lock(mutex_);
-  uint64_t cap_id = next_cap_id_++;
-  caps_.PushBack(
-      MakeRefCounted<Capability>(thread, Capability::THREAD, cap_id, ZC_WRITE));
-  return cap_id;
+  return caps_.AddNewCapability(thread, Capability::THREAD, ZC_WRITE);
 }
 
-uint64_t Process::AddCapability(const RefPtr<Process>& p) {
-  MutexHolder lock(mutex_);
-  uint64_t cap_id = next_cap_id_++;
-  caps_.PushBack(MakeRefCounted<Capability>(p, Capability::PROCESS, cap_id,
-                                            ZC_WRITE | ZC_PROC_SPAWN_THREAD));
-  return cap_id;
+uint64_t Process::AddCapability(const RefPtr<Process>& proc) {
+  return caps_.AddNewCapability(proc, Capability::PROCESS,
+                                ZC_WRITE | ZC_PROC_SPAWN_THREAD);
 }
+
 uint64_t Process::AddCapability(const RefPtr<AddressSpace>& vmas) {
-  MutexHolder lock(mutex_);
-  uint64_t cap_id = next_cap_id_++;
-  caps_.PushBack(MakeRefCounted<Capability>(vmas, Capability::ADDRESS_SPACE,
-                                            cap_id, ZC_WRITE));
-  return cap_id;
+  return caps_.AddNewCapability(vmas, Capability::ADDRESS_SPACE, ZC_WRITE);
 }
+
 uint64_t Process::AddCapability(const RefPtr<MemoryObject>& vmmo) {
-  MutexHolder lock(mutex_);
-  uint64_t cap_id = next_cap_id_++;
-  caps_.PushBack(MakeRefCounted<Capability>(vmmo, Capability::MEMORY_OBJECT,
-                                            cap_id, ZC_WRITE));
-  return cap_id;
+  return caps_.AddNewCapability(vmmo, Capability::MEMORY_OBJECT, ZC_WRITE);
 }
+
 uint64_t Process::AddCapability(const RefPtr<Channel>& chan) {
-  MutexHolder lock(mutex_);
-  uint64_t cap_id = next_cap_id_++;
-  caps_.PushBack(MakeRefCounted<Capability>(chan, Capability::CHANNEL, cap_id,
-                                            ZC_WRITE | ZC_READ));
-  return cap_id;
+  return caps_.AddNewCapability(chan, Capability::CHANNEL, ZC_WRITE | ZC_READ);
 }
 
 uint64_t Process::AddCapability(const RefPtr<Port>& port) {
-  MutexHolder lock(mutex_);
-  uint64_t cap_id = next_cap_id_++;
-  caps_.PushBack(MakeRefCounted<Capability>(port, Capability::PORT, cap_id,
-                                            ZC_WRITE | ZC_READ));
-  return cap_id;
+  return caps_.AddNewCapability(port, Capability::PORT, ZC_WRITE | ZC_READ);
 }
 
 void Process::AddCapability(uint64_t cap_id, const RefPtr<MemoryObject>& vmmo) {
-  MutexHolder lock(mutex_);
-  caps_.PushBack(MakeRefCounted<Capability>(vmmo, Capability::MEMORY_OBJECT,
-                                            cap_id, ZC_WRITE));
+  caps_.AddNewCapabilityWithId(cap_id, vmmo, Capability::MEMORY_OBJECT,
+                               ZC_WRITE);
 }

zion/object/process.h

@@ -3,6 +3,7 @@
 #include <stdint.h>
 
 #include "capability/capability.h"
+#include "capability/capability_table.h"
 #include "lib/linked_list.h"
 #include "lib/mutex.h"
 #include "lib/ref_ptr.h"
@@ -63,5 +64,5 @@ class Process : public KernelObject {
   uint64_t next_cap_id_ = 0x100;
 
   LinkedList<RefPtr<Thread>> threads_;
-  LinkedList<RefPtr<Capability>> caps_;
+  CapabilityTable caps_;
 };