drew/acadia
1
0
Fork 0
Code Issues 6 Pull requests Projects Releases Packages Wiki Activity Actions

[zion] Dynamically check Capability type.

Browse source 
Instead of passing an enum with the capability when creating it, relying
on polymorphism and a template struct tag to determine the object type
at runtime.

This is cleaner and avoids errors where we pass the wrong capability
type with the cap and do a bad cast at runtime.
This commit is contained in:
Drew Galbraith 2023-06-16 14:53:57 -07:00
parent b4902a79ef
commit a47bac9966
13 changed files with 113 additions and 106 deletions
Download patch file Download diff file Expand all files Collapse all files

52
zion/capability/capability.cpp
View file

@ -1,52 +0,0 @@
#include "capability/capability.h"
#include "object/process.h"
#include "object/thread.h"
template <>
RefPtr<Process> Capability::obj<Process>() {
if (type_ != PROCESS) {
panic("Accessing %u cap as object.", type_);
}
return StaticCastRefPtr<Process>(obj_);
}
template <>
RefPtr<Thread> Capability::obj<Thread>() {
if (type_ != THREAD) {
panic("Accessing %u cap as object.", type_);
}
return StaticCastRefPtr<Thread>(obj_);
}
template <>
RefPtr<AddressSpace> Capability::obj<AddressSpace>() {
if (type_ != ADDRESS_SPACE) {
panic("Accessing %u cap as object.", type_);
}
return StaticCastRefPtr<AddressSpace>(obj_);
}
template <>
RefPtr<MemoryObject> Capability::obj<MemoryObject>() {
if (type_ != MEMORY_OBJECT) {
panic("Accessing %u cap as object.", type_);
}
return StaticCastRefPtr<MemoryObject>(obj_);
}
template <>
RefPtr<Channel> Capability::obj<Channel>() {
if (type_ != CHANNEL) {
panic("Accessing %u cap as object.", type_);
}
return StaticCastRefPtr<Channel>(obj_);
}
template <>
RefPtr<Port> Capability::obj<Port>() {
if (type_ != PORT) {
panic("Accessing %u cap as object.", type_);
}
return StaticCastRefPtr<Port>(obj_);
}

30
zion/capability/capability.h
View file

@ -10,23 +10,12 @@ class Thread;
class Capability : public RefCounted<Capability> {
public:
enum Type {
UNDEFINED,
PROCESS,
THREAD,
ADDRESS_SPACE,
MEMORY_OBJECT,
CHANNEL,
PORT,
};
Capability(const RefPtr<KernelObject>& obj, Type type, uint64_t id,
uint64_t permissions)
: obj_(obj), type_(type), id_(id), permissions_(permissions) {}
Capability(const RefPtr<KernelObject>& obj, uint64_t id, uint64_t permissions)
: obj_(obj), id_(id), permissions_(permissions) {}
template <typename T>
Capability(const RefPtr<T>& obj, Type type, uint64_t id, uint64_t permissions)
: Capability(StaticCastRefPtr<KernelObject>(obj), type, id, permissions) {
}
Capability(const RefPtr<T>& obj, uint64_t id, uint64_t permissions)
: Capability(StaticCastRefPtr<KernelObject>(obj), id, permissions) {}
template <typename T>
RefPtr<T> obj();
@ -34,8 +23,6 @@ class Capability : public RefCounted<Capability> {
uint64_t id() { return id_; }
void set_id(uint64_t id) { id_ = id; }
bool CheckType(Type type) { return type_ == type; }
uint64_t permissions() { return permissions_; }
bool HasPermissions(uint64_t requested) {
return (permissions_ & requested) == requested;
@ -43,7 +30,14 @@ class Capability : public RefCounted<Capability> {
private:
RefPtr<KernelObject> obj_;
Type type_;
uint64_t id_;
uint64_t permissions_;
};
template <typename T>
RefPtr<T> Capability::obj() {
if (obj_->TypeTag() != KernelObjectTag<T>::type) {
return nullptr;
}
return StaticCastRefPtr<T>(obj_);
}

13
zion/capability/capability_table.h
View file

@ -13,14 +13,13 @@ class CapabilityTable {
CapabilityTable& operator=(CapabilityTable&) = delete;
template <typename T>
uint64_t AddNewCapability(const RefPtr<T>& object, Capability::Type type,
uint64_t permissions);
uint64_t AddNewCapability(const RefPtr<T>& object, 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);
uint64_t permissions);
RefPtr<Capability> GetCapability(uint64_t id);
RefPtr<Capability> ReleaseCapability(uint64_t id);
@ -35,20 +34,16 @@ class CapabilityTable {
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));
capabilities_.PushBack(MakeRefCounted<Capability>(object, 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));
capabilities_.PushBack(MakeRefCounted<Capability>(object, id, permissions));
}