Endpoint syscalls implemented

This commit is contained in:
Drew Galbraith 2023-06-21 23:14:42 -07:00
parent 69501bfe01
commit c064af5fa7
27 changed files with 391 additions and 42 deletions

View File

@ -41,6 +41,6 @@ class ErrorOr {
if (!AOR_VAR(__LINE__).ok()) { \
return AOR_VAR(__LINE__).error(); \
} \
lhs = rhs.value();
lhs = AOR_VAR(__LINE__).value();
} // namespace glcr

View File

@ -15,6 +15,9 @@ class EndpointServer {
// FIXME: Release Cap here.
z_cap_t GetCap() { return endpoint_cap_; }
glcr::ErrorCode Recieve(uint64_t* num_bytes, void* data,
z_cap_t* reply_port_cap);
private:
z_cap_t endpoint_cap_;

View File

@ -6,9 +6,18 @@ glcr::ErrorOr<EndpointServer> EndpointServer::Create() {
return EndpointServer(cap);
}
EndpointServer EndpointServer::Adopt(z_cap_t endpoint_cap) {
return EndpointServer(endpoint_cap);
}
glcr::ErrorOr<EndpointClient> EndpointServer::CreateClient() {
uint64_t client_cap;
// FIXME: Restrict permissions to send-only here.
RET_ERR(ZCapDuplicate(endpoint_cap_, &client_cap));
return EndpointClient::AdoptEndpoint(client_cap);
}
glcr::ErrorCode EndpointServer::Recieve(uint64_t* num_bytes, void* data,
z_cap_t* reply_port_cap) {
return ZEndpointRecv(endpoint_cap_, num_bytes, data, reply_port_cap);
}

View File

@ -9,7 +9,7 @@
uint64_t gSelfProcCap = 0;
uint64_t gSelfVmasCap = 0;
uint64_t gInitChannelCap = 0;
uint64_t gInitEndpointCap = 0;
uint64_t gBootDenaliVmmoCap = 0;
@ -28,8 +28,8 @@ z_err_t ParseInitPort(uint64_t init_port_cap) {
dbgln("received vmas");
gSelfVmasCap = init_cap;
break;
case Z_INIT_CHANNEL:
gInitChannelCap = init_cap;
case Z_INIT_ENDPOINT:
gInitEndpointCap = init_cap;
break;
case Z_BOOT_DENALI_VMMO:
dbgln("received denali");

View File

@ -128,7 +128,7 @@ glcr::ErrorOr<EndpointClient> SpawnProcessFromElfRegion(uint64_t program) {
Port p(port_cap);
check(p.WriteMessage<uint64_t>(Z_INIT_SELF_PROC, proc_cap));
check(p.WriteMessage<uint64_t>(Z_INIT_SELF_VMAS, as_cap));
check(p.WriteMessage<uint64_t>(Z_INIT_CHANNEL, server.GetCap()));
check(p.WriteMessage<uint64_t>(Z_INIT_ENDPOINT, server.GetCap()));
#if MAM_PROC_DEBUG
dbgln("Thread start");

View File

@ -7,8 +7,11 @@
Command::~Command() {}
DmaReadCommand::DmaReadCommand(uint64_t lba, uint64_t sector_cnt,
DmaCallback callback)
: lba_(lba), sector_cnt_(sector_cnt), callback_(callback) {
DmaCallback callback, z_cap_t reply_port)
: reply_port_(reply_port),
lba_(lba),
sector_cnt_(sector_cnt),
callback_(callback) {
region_ = MappedMemoryRegion::ContiguousPhysical(sector_cnt * 512);
}
@ -46,4 +49,6 @@ void DmaReadCommand::PopulatePrdt(PhysicalRegionDescriptor* prdt) {
prdt[0].region_address = region_.paddr();
prdt[0].byte_count = region_.size();
}
void DmaReadCommand::Callback() { callback_(lba_, sector_cnt_, region_.cap()); }
void DmaReadCommand::Callback() {
callback_(reply_port_, lba_, sector_cnt_, region_.cap());
}

View File

@ -15,8 +15,9 @@ class Command {
class DmaReadCommand : public Command {
public:
typedef void (*DmaCallback)(uint64_t, uint64_t, uint64_t);
DmaReadCommand(uint64_t lba, uint64_t sector_cnt, DmaCallback callback);
typedef void (*DmaCallback)(z_cap_t, uint64_t, uint64_t, z_cap_t);
DmaReadCommand(uint64_t lba, uint64_t sector_cnt, DmaCallback callback,
z_cap_t reply_port);
virtual ~DmaReadCommand() override;
@ -26,6 +27,7 @@ class DmaReadCommand : public Command {
void Callback() override;
private:
z_cap_t reply_port_;
uint64_t lba_;
uint64_t sector_cnt_;
DmaCallback callback_;

View File

@ -1,5 +1,6 @@
#include <mammoth/channel.h>
#include <mammoth/debug.h>
#include <mammoth/endpoint_server.h>
#include <mammoth/init.h>
#include <stdint.h>
@ -11,7 +12,8 @@ uint64_t main(uint64_t init_port_cap) {
AhciDriver driver;
RET_ERR(driver.Init());
DenaliServer server(gInitChannelCap, driver);
EndpointServer endpoint = EndpointServer::Adopt(gInitEndpointCap);
DenaliServer server(endpoint, driver);
RET_ERR(server.RunServer());
// FIXME: Add thread join.
return 0;

View File

@ -6,22 +6,22 @@
namespace {
DenaliServer* gServer = nullptr;
void HandleResponse(uint64_t lba, uint64_t size, uint64_t cap) {
gServer->HandleResponse(lba, size, cap);
void HandleResponse(z_cap_t reply_port, uint64_t lba, uint64_t size,
z_cap_t mem) {
gServer->HandleResponse(reply_port, lba, size, mem);
}
} // namespace
DenaliServer::DenaliServer(uint64_t channel_cap, AhciDriver& driver)
: channel_cap_(channel_cap), driver_(driver) {
DenaliServer::DenaliServer(EndpointServer server, AhciDriver& driver)
: server_(server), driver_(driver) {
gServer = this;
}
glcr::ErrorCode DenaliServer::RunServer() {
while (true) {
uint64_t buff_size = kBuffSize;
uint64_t cap_size = 0;
RET_ERR(ZChannelRecv(channel_cap_, &buff_size, read_buffer_, &cap_size,
nullptr));
z_cap_t reply_port;
RET_ERR(server_.Recieve(&buff_size, read_buffer_, &reply_port));
if (buff_size < sizeof(uint64_t)) {
dbgln("Skipping invalid message");
continue;
@ -34,7 +34,7 @@ glcr::ErrorCode DenaliServer::RunServer() {
case DENALI_READ: {
DenaliRead* read_req = reinterpret_cast<DenaliRead*>(read_buffer_);
uint64_t memcap = 0;
RET_ERR(HandleRead(*read_req));
RET_ERR(HandleRead(*read_req, reply_port));
break;
}
default:
@ -44,21 +44,22 @@ glcr::ErrorCode DenaliServer::RunServer() {
}
}
glcr::ErrorCode DenaliServer::HandleRead(const DenaliRead& read) {
glcr::ErrorCode DenaliServer::HandleRead(const DenaliRead& read,
z_cap_t reply_port) {
ASSIGN_OR_RETURN(AhciDevice * device, driver_.GetDevice(read.device_id));
device->IssueCommand(
new DmaReadCommand(read.lba, read.size, ::HandleResponse));
new DmaReadCommand(read.lba, read.size, ::HandleResponse, reply_port));
return glcr::OK;
}
void DenaliServer::HandleResponse(uint64_t lba, uint64_t size, uint64_t cap) {
void DenaliServer::HandleResponse(z_cap_t reply_port, uint64_t lba,
uint64_t size, z_cap_t mem) {
DenaliReadResponse resp{
.device_id = 0,
.lba = lba,
.size = size,
};
check(ZChannelSend(channel_cap_, sizeof(resp),
reinterpret_cast<uint8_t*>(&resp), 1, &cap));
check(ZReplyPortSend(reply_port, sizeof(resp), &resp, 1, &mem));
}

View File

@ -1,24 +1,26 @@
#pragma once
#include <glacier/status/error.h>
#include <mammoth/endpoint_server.h>
#include "ahci/ahci_driver.h"
#include "denali/denali.h"
class DenaliServer {
public:
DenaliServer(uint64_t channel_cap, AhciDriver& driver);
DenaliServer(EndpointServer server, AhciDriver& driver);
glcr::ErrorCode RunServer();
void HandleResponse(uint64_t lba, uint64_t size, uint64_t cap);
void HandleResponse(z_cap_t reply_port, uint64_t lba, uint64_t size,
z_cap_t cap);
private:
static const uint64_t kBuffSize = 1024;
uint64_t channel_cap_;
EndpointServer server_;
uint8_t read_buffer_[kBuffSize];
AhciDriver& driver_;
glcr::ErrorCode HandleRead(const DenaliRead& read);
glcr::ErrorCode HandleRead(const DenaliRead& read, z_cap_t reply_port);
};

View File

@ -20,9 +20,11 @@ add_executable(zion
memory/user_stack_manager.cpp
object/address_space.cpp
object/channel.cpp
object/endpoint.cpp
object/memory_object.cpp
object/port.cpp
object/process.cpp
object/reply_port.cpp
object/thread.cpp
scheduler/context_switch.s
scheduler/jump_user_space.s
@ -32,9 +34,11 @@ add_executable(zion
syscall/capability.cpp
syscall/channel.cpp
syscall/debug.cpp
syscall/endpoint.cpp
syscall/memory_object.cpp
syscall/port.cpp
syscall/process.cpp
syscall/reply_port.cpp
syscall/syscall.cpp
syscall/syscall_enter.s
syscall/thread.cpp

View File

@ -130,8 +130,8 @@ SYS4(EndpointRecv, z_cap_t, endpoint_cap, uint64_t*, num_bytes, void*, data,
z_cap_t*, reply_port_cap);
SYS5(ReplyPortSend, z_cap_t, reply_port_cap, uint64_t, num_bytes, const void*,
data, uint64_t, num_caps, z_cap_t*, caps);
SYS5(ReplyPortRecv, z_cap_t, reply_port_cap, uint64_t*, num_bytes, const void*,
data, uint64_t*, num_caps, z_cap_t*, caps);
SYS5(ReplyPortRecv, z_cap_t, reply_port_cap, uint64_t*, num_bytes, void*, data,
uint64_t*, num_caps, z_cap_t*, caps);
SYS2(CapDuplicate, z_cap_t, cap_in, z_cap_t*, cap_out);

View File

@ -5,6 +5,6 @@
extern uint64_t gSelfProcCap;
extern uint64_t gSelfVmasCap;
extern uint64_t gInitChannelCap;
extern uint64_t gInitEndpointCap;
extern uint64_t gBootDenaliVmmoCap;

View File

@ -85,6 +85,6 @@ typedef uint64_t z_cap_t;
#define Z_INIT_SELF_PROC 0x4000'0000
#define Z_INIT_SELF_VMAS 0x4000'0001
#define Z_INIT_CHANNEL 0x4100'0000
#define Z_INIT_ENDPOINT 0x4100'0000
#define Z_BOOT_DENALI_VMMO 0x4200'0000

View File

@ -70,3 +70,59 @@ void UnboundedMessageQueue::WriteKernel(uint64_t init,
pending_messages_.PushBack(msg);
}
glcr::ErrorCode SingleMessageQueue::PushBack(uint64_t num_bytes,
const void* bytes,
uint64_t num_caps,
const z_cap_t* caps) {
if (has_written_) {
return glcr::FAILED_PRECONDITION;
}
num_bytes_ = num_bytes;
bytes_ = new uint8_t[num_bytes];
for (uint64_t i = 0; i < num_bytes; i++) {
bytes_[i] = reinterpret_cast<const uint8_t*>(bytes)[i];
}
for (uint64_t i = 0; i < num_caps; i++) {
// FIXME: This would feel safer closer to the relevant syscall.
auto cap = gScheduler->CurrentProcess().ReleaseCapability(caps[i]);
if (!cap) {
return glcr::CAP_NOT_FOUND;
}
caps_.PushBack(cap);
}
has_written_ = true;
return glcr::OK;
}
glcr::ErrorCode SingleMessageQueue::PopFront(uint64_t* num_bytes, void* bytes,
uint64_t* num_caps,
z_cap_t* caps) {
if (!has_written_ || has_read_) {
return glcr::FAILED_PRECONDITION;
}
if (num_bytes_ > *num_bytes) {
return glcr::BUFFER_SIZE;
}
if (caps_.size() > *num_caps) {
return glcr::BUFFER_SIZE;
}
*num_bytes = num_bytes_;
for (uint64_t i = 0; i < num_bytes_; i++) {
reinterpret_cast<uint8_t*>(bytes)[i] = bytes_[i];
}
*num_caps = caps_.size();
auto& proc = gScheduler->CurrentProcess();
for (uint64_t i = 0; i < *num_caps; i++) {
caps[i] = proc.AddExistingCapability(caps_.PopFront());
}
has_read_ = true;
return glcr::OK;
}

View File

@ -2,6 +2,7 @@
#include <glacier/memory/ref_ptr.h>
#include <glacier/memory/shared_ptr.h>
#include <glacier/status/error.h>
#include "capability/capability.h"
#include "include/ztypes.h"
@ -11,10 +12,10 @@ class MessageQueue {
public:
virtual ~MessageQueue() {}
virtual z_err_t PushBack(uint64_t num_bytes, const void* bytes,
uint64_t num_caps, const z_cap_t* caps) = 0;
virtual z_err_t PopFront(uint64_t* num_bytes, void* bytes, uint64_t* num_caps,
z_cap_t* caps) = 0;
virtual glcr::ErrorCode PushBack(uint64_t num_bytes, const void* bytes,
uint64_t num_caps, const z_cap_t* caps) = 0;
virtual glcr::ErrorCode PopFront(uint64_t* num_bytes, void* bytes,
uint64_t* num_caps, z_cap_t* caps) = 0;
};
class UnboundedMessageQueue : public MessageQueue {
@ -24,10 +25,10 @@ class UnboundedMessageQueue : public MessageQueue {
UnboundedMessageQueue& operator=(const UnboundedMessageQueue&) = delete;
virtual ~UnboundedMessageQueue() override {}
z_err_t PushBack(uint64_t num_bytes, const void* bytes, uint64_t num_caps,
const z_cap_t* caps) override;
z_err_t PopFront(uint64_t* num_bytes, void* bytes, uint64_t* num_caps,
z_cap_t* caps) override;
glcr::ErrorCode PushBack(uint64_t num_bytes, const void* bytes,
uint64_t num_caps, const z_cap_t* caps) override;
glcr::ErrorCode PopFront(uint64_t* num_bytes, void* bytes, uint64_t* num_caps,
z_cap_t* caps) override;
void WriteKernel(uint64_t init, glcr::RefPtr<Capability> cap);
@ -44,3 +45,25 @@ class UnboundedMessageQueue : public MessageQueue {
LinkedList<glcr::SharedPtr<Message>> pending_messages_;
};
class SingleMessageQueue : public MessageQueue {
public:
SingleMessageQueue() {}
SingleMessageQueue(const SingleMessageQueue&) = delete;
SingleMessageQueue(SingleMessageQueue&&) = delete;
virtual ~SingleMessageQueue() override {}
glcr::ErrorCode PushBack(uint64_t num_bytes, const void* bytes,
uint64_t num_caps, const z_cap_t* caps) override;
glcr::ErrorCode PopFront(uint64_t* num_bytes, void* bytes, uint64_t* num_caps,
z_cap_t* caps) override;
bool empty() { return has_written_ == false; };
private:
bool has_written_ = false;
bool has_read_ = false;
uint64_t num_bytes_;
uint8_t* bytes_;
LinkedList<glcr::RefPtr<Capability>> caps_;
};

View File

@ -5,7 +5,7 @@
void Mutex::Lock() {
while (__atomic_fetch_or(&lock_, 0x1, __ATOMIC_SEQ_CST) == 0x1) {
dbgln("Lock sleep: %s", name_);
// dbgln("Lock sleep: %s", name_);
gScheduler->Preempt();
}
}

43
zion/object/endpoint.cpp Normal file
View File

@ -0,0 +1,43 @@
#include "object/endpoint.h"
#include "scheduler/scheduler.h"
glcr::RefPtr<Endpoint> Endpoint::Create() {
return glcr::AdoptPtr(new Endpoint);
}
glcr::ErrorCode Endpoint::Write(uint64_t num_bytes, const void* data,
z_cap_t reply_port_cap) {
MutexHolder h(mutex_);
RET_ERR(message_queue_.PushBack(num_bytes, data, 1, &reply_port_cap));
if (blocked_threads_.size() > 0) {
auto thread = blocked_threads_.PopFront();
thread->SetState(Thread::RUNNABLE);
gScheduler->Enqueue(thread);
}
return glcr::OK;
}
glcr::ErrorCode Endpoint::Read(uint64_t* num_bytes, void* data,
z_cap_t* reply_port_cap) {
mutex_.Lock();
while (message_queue_.empty()) {
auto thread = gScheduler->CurrentThread();
thread->SetState(Thread::BLOCKED);
mutex_.Unlock();
gScheduler->Yield();
mutex_.Lock();
}
mutex_.Unlock();
MutexHolder h(mutex_);
uint64_t num_caps = 1;
RET_ERR(message_queue_.PopFront(num_bytes, data, &num_caps, reply_port_cap));
if (num_caps != 1) {
return glcr::INTERNAL;
}
return glcr::OK;
}

37
zion/object/endpoint.h Normal file
View File

@ -0,0 +1,37 @@
#pragma once
#include <glacier/container/intrusive_list.h>
#include <glacier/memory/ref_ptr.h>
#include <glacier/status/error.h>
#include "lib/message_queue.h"
#include "lib/mutex.h"
#include "object/kernel_object.h"
class Endpoint;
class ReplyPort;
template <>
struct KernelObjectTag<Endpoint> {
static const uint64_t type = KernelObject::ENDPOINT;
};
class Endpoint : public KernelObject {
public:
uint64_t TypeTag() override { return KernelObject::ENDPOINT; }
static glcr::RefPtr<Endpoint> Create();
glcr::ErrorCode Write(uint64_t num_bytes, const void* data,
z_cap_t reply_port_cap);
glcr::ErrorCode Read(uint64_t* num_bytes, void* data,
z_cap_t* reply_port_cap);
private:
Mutex mutex_{"endpoint"};
UnboundedMessageQueue message_queue_;
glcr::IntrusiveList<Thread> blocked_threads_;
Endpoint() {}
};

View File

@ -12,6 +12,8 @@ class KernelObject : public glcr::RefCounted<KernelObject> {
MEMORY_OBJECT = 0x4,
CHANNEL = 0x5,
PORT = 0x6,
ENDPOINT = 0x7,
REPLY_PORT = 0x8,
};
virtual uint64_t TypeTag() = 0;

View File

@ -0,0 +1,41 @@
#include "object/reply_port.h"
#include "scheduler/scheduler.h"
glcr::RefPtr<ReplyPort> ReplyPort::Create() {
return glcr::AdoptPtr(new ReplyPort);
}
uint64_t ReplyPort::Write(uint64_t num_bytes, const void* data,
uint64_t num_caps, uint64_t* caps) {
MutexHolder h(mutex_);
RET_ERR(message_holder_.PushBack(num_bytes, data, num_caps, caps));
if (blocked_thread_) {
// FIXME: We need to handle the case where the blocked thread has died I
// think.
blocked_thread_->SetState(Thread::RUNNABLE);
gScheduler->Enqueue(blocked_thread_);
blocked_thread_ = nullptr;
}
return glcr::OK;
}
uint64_t ReplyPort::Read(uint64_t* num_bytes, void* data, uint64_t* num_caps,
uint64_t* caps) {
mutex_.Lock();
if (message_holder_.empty()) {
// Multiple threads can't block on a reply port.
if (blocked_thread_) {
mutex_.Unlock();
return glcr::FAILED_PRECONDITION;
}
blocked_thread_ = gScheduler->CurrentThread();
blocked_thread_->SetState(Thread::BLOCKED);
mutex_.Unlock();
gScheduler->Yield();
mutex_.Lock();
}
return message_holder_.PopFront(num_bytes, data, num_caps, caps);
}

33
zion/object/reply_port.h Normal file
View File

@ -0,0 +1,33 @@
#pragma once
#include <glacier/memory/ref_ptr.h>
#include "lib/message_queue.h"
#include "lib/mutex.h"
#include "object/kernel_object.h"
class ReplyPort;
template <>
struct KernelObjectTag<ReplyPort> {
static const uint64_t type = KernelObject::REPLY_PORT;
};
class ReplyPort : public KernelObject {
public:
uint64_t TypeTag() override { return KernelObject::REPLY_PORT; }
static glcr::RefPtr<ReplyPort> Create();
uint64_t Write(uint64_t num_bytes, const void* data, uint64_t num_caps,
uint64_t* caps);
uint64_t Read(uint64_t* num_bytes, void* data, uint64_t* num_caps,
uint64_t* caps);
private:
Mutex mutex_{"reply_port"};
SingleMessageQueue message_holder_;
glcr::RefPtr<Thread> blocked_thread_;
ReplyPort() {}
};

35
zion/syscall/endpoint.cpp Normal file
View File

@ -0,0 +1,35 @@
#include "syscall/endpoint.h"
#include "object/endpoint.h"
#include "object/reply_port.h"
#include "scheduler/scheduler.h"
glcr::ErrorCode EndpointCreate(ZEndpointCreateReq* req) {
auto& proc = gScheduler->CurrentProcess();
*req->endpoint_cap =
proc.AddNewCapability(Endpoint::Create(), ZC_READ | ZC_WRITE);
return glcr::OK;
}
glcr::ErrorCode EndpointSend(ZEndpointSendReq* req) {
auto& proc = gScheduler->CurrentProcess();
auto endpoint_cap = proc.GetCapability(req->endpoint_cap);
ValidateCapability<Endpoint>(endpoint_cap, ZC_WRITE);
auto endpoint = endpoint_cap->obj<Endpoint>();
auto reply_port = ReplyPort::Create();
*req->reply_port_cap = proc.AddNewCapability(reply_port, ZC_READ);
uint64_t reply_port_cap_to_send = proc.AddNewCapability(reply_port, ZC_WRITE);
return endpoint->Write(req->num_bytes, req->data, reply_port_cap_to_send);
}
glcr::ErrorCode EndpointRecv(ZEndpointRecvReq* req) {
auto& proc = gScheduler->CurrentProcess();
auto endpoint_cap = proc.GetCapability(req->endpoint_cap);
ValidateCapability<Endpoint>(endpoint_cap, ZC_READ);
auto endpoint = endpoint_cap->obj<Endpoint>();
return endpoint->Read(req->num_bytes, req->data, req->reply_port_cap);
}

11
zion/syscall/endpoint.h Normal file
View File

@ -0,0 +1,11 @@
#pragma once
#include <glacier/status/error.h>
#include "include/zcall.h"
glcr::ErrorCode EndpointCreate(ZEndpointCreateReq* req);
glcr::ErrorCode EndpointSend(ZEndpointSendReq* req);
glcr::ErrorCode EndpointRecv(ZEndpointRecvReq* req);

View File

@ -0,0 +1,22 @@
#include "syscall/reply_port.h"
#include "object/reply_port.h"
#include "scheduler/scheduler.h"
glcr::ErrorCode ReplyPortSend(ZReplyPortSendReq* req) {
auto& proc = gScheduler->CurrentProcess();
auto reply_port_cap = proc.GetCapability(req->reply_port_cap);
ValidateCapability<ReplyPort>(reply_port_cap, ZC_WRITE);
auto reply_port = reply_port_cap->obj<ReplyPort>();
return reply_port->Write(req->num_bytes, req->data, req->num_caps, req->caps);
}
glcr::ErrorCode ReplyPortRecv(ZReplyPortRecvReq* req) {
auto& proc = gScheduler->CurrentProcess();
auto reply_port_cap = proc.GetCapability(req->reply_port_cap);
ValidateCapability<ReplyPort>(reply_port_cap, ZC_READ);
auto reply_port = reply_port_cap->obj<ReplyPort>();
return reply_port->Read(req->num_bytes, req->data, req->num_caps, req->caps);
}

View File

@ -0,0 +1,9 @@
#pragma once
#include <glacier/status/error.h>
#include "include/zcall.h"
glcr::ErrorCode ReplyPortSend(ZReplyPortSendReq* req);
glcr::ErrorCode ReplyPortRecv(ZReplyPortRecvReq* req);

View File

@ -8,9 +8,11 @@
#include "syscall/capability.h"
#include "syscall/channel.h"
#include "syscall/debug.h"
#include "syscall/endpoint.h"
#include "syscall/memory_object.h"
#include "syscall/port.h"
#include "syscall/process.h"
#include "syscall/reply_port.h"
#include "syscall/thread.h"
#define EFER 0xC0000080
@ -73,6 +75,13 @@ extern "C" z_err_t SyscallHandler(uint64_t call_id, void* req) {
CASE(PortRecv);
CASE(PortPoll);
CASE(IrqRegister);
// syscall/endpoint.h
CASE(EndpointCreate);
CASE(EndpointSend);
CASE(EndpointRecv);
// syscall/reply_port.h
CASE(ReplyPortSend);
CASE(ReplyPortRecv);
// syscall/capability.h
CASE(CapDuplicate);
// syscall/debug.h