drew
/
acadia
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

[Zion] Return the IpcMessage up to the syscall level.

This commit is contained in:
Drew Galbraith 2023-11-03 00:12:28 -07:00
parent d2c77e1d18
commit d7af2e3f4f
5 changed files with 73 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
zion/lib/message_queue.cpp
View File

@ -48,10 +48,8 @@ glcr::ErrorCode UnboundedMessageQueue::PushBack(
return glcr::OK;
}
glcr::ErrorCode UnboundedMessageQueue::PopFront(uint64_t* num_bytes,
void* bytes, uint64_t* num_caps,
z_cap_t* caps,
z_cap_t* reply_cap) {
glcr::ErrorOr<IpcMessage> UnboundedMessageQueue::PopFront(
uint64_t data_buf_size, uint64_t cap_buf_size) {
mutex_->Lock();
while (pending_messages_.empty()) {
auto thread = gScheduler->CurrentThread();
@ -65,35 +63,14 @@ glcr::ErrorCode UnboundedMessageQueue::PopFront(uint64_t* num_bytes,
MutexHolder lock(mutex_);
auto& next_msg = pending_messages_.PeekFront();
if (next_msg.data.size() > *num_bytes) {
if (next_msg.data.size() > data_buf_size) {
return glcr::BUFFER_SIZE;
}
if (next_msg.caps.size() > *num_caps) {
if (next_msg.caps.size() > cap_buf_size) {
return glcr::BUFFER_SIZE;
}
next_msg = pending_messages_.PopFront();
*num_bytes = next_msg.data.size();
for (uint64_t i = 0; i < *num_bytes; i++) {
static_cast<uint8_t*>(bytes)[i] = next_msg.data[i];
}
auto& proc = gScheduler->CurrentProcess();
if (reply_cap != nullptr) {
if (!next_msg.reply_cap) {
dbgln("Tried to read reply capability off of a message without one");
return glcr::INTERNAL;
}
*reply_cap = proc.AddExistingCapability(next_msg.reply_cap);
}
*num_caps = next_msg.caps.size();
for (uint64_t i = 0; i < *num_caps; i++) {
caps[i] = proc.AddExistingCapability(next_msg.caps[i]);
}
return glcr::OK;
return pending_messages_.PopFront();
}
void UnboundedMessageQueue::WriteKernel(uint64_t init,
@ -150,9 +127,8 @@ glcr::ErrorCode SingleMessageQueue::PushBack(
return glcr::OK;
}
glcr::ErrorCode SingleMessageQueue::PopFront(uint64_t* num_bytes, void* bytes,
uint64_t* num_caps, z_cap_t* caps,
z_cap_t* reply_port) {
glcr::ErrorOr<IpcMessage> SingleMessageQueue::PopFront(uint64_t data_buf_size,
uint64_t cap_buf_size) {
mutex_->Lock();
while (!has_written_) {
auto thread = gScheduler->CurrentThread();
@ -169,29 +145,14 @@ glcr::ErrorCode SingleMessageQueue::PopFront(uint64_t* num_bytes, void* bytes,
return glcr::FAILED_PRECONDITION;
}
if (message_.data.size() > *num_bytes) {
if (message_.data.size() > data_buf_size) {
return glcr::BUFFER_SIZE;
}
if (message_.caps.size() > *num_caps) {
if (message_.caps.size() > cap_buf_size) {
return glcr::BUFFER_SIZE;
}
*num_bytes = message_.data.size();
for (uint64_t i = 0; i < message_.data.size(); i++) {
reinterpret_cast<uint8_t*>(bytes)[i] = message_.data[i];
}
if (reply_port != nullptr) {
dbgln("Tried to read a reply port a single message queue");
return glcr::INTERNAL;
}
*num_caps = message_.caps.size();
auto& proc = gScheduler->CurrentProcess();
for (uint64_t i = 0; i < *num_caps; i++) {
caps[i] = proc.AddExistingCapability(message_.caps[i]);
}
has_read_ = true;
return glcr::OK;
return glcr::Move(message_);
}

14
zion/lib/message_queue.h
View File

@ -8,6 +8,7 @@
#include <glacier/memory/ref_ptr.h>
#include <glacier/memory/shared_ptr.h>
#include <glacier/status/error.h>
#include <glacier/status/error_or.h>
#include "capability/capability.h"
#include "include/ztypes.h"
@ -28,9 +29,8 @@ class MessageQueue {
virtual glcr::ErrorCode PushBack(const glcr::ArrayView<uint8_t>& message,
const glcr::ArrayView<z_cap_t>& caps,
z_cap_t reply_cap) = 0;
virtual glcr::ErrorCode PopFront(uint64_t* num_bytes, void* bytes,
uint64_t* num_caps, z_cap_t* caps,
z_cap_t* reply_cap) = 0;
virtual glcr::ErrorOr<IpcMessage> PopFront(uint64_t data_buf_size,
uint64_t cap_buf_size) = 0;
virtual bool empty() = 0;
protected:
@ -50,8 +50,8 @@ class UnboundedMessageQueue : public MessageQueue {
glcr::ErrorCode PushBack(const glcr::ArrayView<uint8_t>& message,
const glcr::ArrayView<z_cap_t>& caps,
z_cap_t reply_cap) override;
glcr::ErrorCode PopFront(uint64_t* num_bytes, void* bytes, uint64_t* num_caps,
z_cap_t* caps, z_cap_t* reply_cap) override;
glcr::ErrorOr<IpcMessage> PopFront(uint64_t data_buf_size,
uint64_t cap_buf_size) override;
void WriteKernel(uint64_t init, glcr::RefPtr<Capability> cap);
@ -74,8 +74,8 @@ class SingleMessageQueue : public MessageQueue {
glcr::ErrorCode PushBack(const glcr::ArrayView<uint8_t>& message,
const glcr::ArrayView<z_cap_t>& caps,
z_cap_t reply_cap) override;
glcr::ErrorCode PopFront(uint64_t* num_bytes, void* bytes, uint64_t* num_caps,
z_cap_t* caps, z_cap_t* reply_cap) override;
glcr::ErrorOr<IpcMessage> PopFront(uint64_t data_buf_size,
uint64_t cap_buf_size) override;
bool empty() override {
MutexHolder h(mutex_);

13
zion/object/ipc_object.cpp
View File

@ -14,14 +14,7 @@ glcr::ErrorCode IpcObject::Send(const glcr::ArrayView<uint8_t>& message,
return message_queue.PushBack(message, caps, reply_port);
}
glcr::ErrorCode IpcObject::Recv(uint64_t* num_bytes, void* bytes,
uint64_t* num_caps, z_cap_t* caps) {
return Recv(num_bytes, bytes, num_caps, caps, nullptr);
}
glcr::ErrorCode IpcObject::Recv(uint64_t* num_bytes, void* bytes,
uint64_t* num_caps, z_cap_t* caps,
z_cap_t* reply_port) {
auto& message_queue = GetRecvMessageQueue();
return message_queue.PopFront(num_bytes, bytes, num_caps, caps, reply_port);
glcr::ErrorOr<IpcMessage> IpcObject::Recv(uint64_t data_buf_size,
uint64_t cap_buf_size) {
return GetRecvMessageQueue().PopFront(data_buf_size, cap_buf_size);
}

7
zion/object/ipc_object.h
View File

@ -17,11 +17,8 @@ class IpcObject : public KernelObject {
const glcr::ArrayView<z_cap_t>& caps,
const z_cap_t reply_port) final;
virtual glcr::ErrorCode Recv(uint64_t* num_bytes, void* bytes,
uint64_t* num_caps, z_cap_t* caps) final;
virtual glcr::ErrorCode Recv(uint64_t* num_bytes, void* bytes,
uint64_t* num_caps, z_cap_t* caps,
z_cap_t* reply_port) final;
virtual glcr::ErrorOr<IpcMessage> Recv(uint64_t data_buf_size,
uint64_t cap_buf_size) final;
bool HasMessages() { return !GetRecvMessageQueue().empty(); }

62
zion/syscall/ipc.cpp
View File

@ -1,6 +1,7 @@
#include "syscall/ipc.h"
#include "capability/capability.h"
#include "debug/debug.h"
#include "interrupt/interrupt.h"
#include "object/endpoint.h"
#include "object/reply_port.h"
@ -12,6 +13,44 @@ glcr::ArrayView<uint8_t> Buffer(const void* bytes, uint64_t num_bytes) {
return glcr::ArrayView(reinterpret_cast<uint8_t*>(const_cast<void*>(bytes)),
num_bytes);
}
template <typename T>
glcr::ErrorCode TranslateIpcMessageToResponse(const IpcMessage& message,
T* resp) {
if (message.data.size() > *resp->num_bytes) {
return glcr::BUFFER_SIZE;
}
if (message.caps.size() > *resp->num_caps) {
return glcr::BUFFER_SIZE;
}
*resp->num_bytes = message.data.size();
for (uint64_t i = 0; i < message.data.size(); i++) {
reinterpret_cast<uint8_t*>(resp->data)[i] = message.data[i];
}
*resp->num_caps = message.caps.size();
auto& proc = gScheduler->CurrentProcess();
for (uint64_t i = 0; i < *resp->num_caps; i++) {
resp->caps[i] = proc.AddExistingCapability(message.caps[i]);
}
return glcr::OK;
}
template <typename T>
glcr::ErrorCode TranslateIpcMessageToResponseWithReplyPort(
const IpcMessage& message, T* resp) {
TranslateIpcMessageToResponse(message, resp);
if (!message.reply_cap) {
dbgln("Tried to read reply capability off of a message without one");
return glcr::INTERNAL;
}
auto& proc = gScheduler->CurrentProcess();
*resp->reply_port_cap = proc.AddExistingCapability(message.reply_cap);
return glcr::OK;
}
} // namespace
glcr::ErrorCode ChannelCreate(ZChannelCreateReq* req) {
@ -38,7 +77,8 @@ glcr::ErrorCode ChannelRecv(ZChannelRecvReq* req) {
RET_ERR(ValidateCapability<Channel>(chan_cap, kZionPerm_Read));
auto chan = chan_cap->obj<Channel>();
return chan->Recv(req->num_bytes, req->data, req->num_caps, req->caps);
ASSIGN_OR_RETURN(IpcMessage msg, chan->Recv(*req->num_bytes, *req->num_caps));
return TranslateIpcMessageToResponse(msg, req);
}
glcr::ErrorCode PortCreate(ZPortCreateReq* req) {
@ -64,7 +104,8 @@ glcr::ErrorCode PortRecv(ZPortRecvReq* req) {
RET_ERR(ValidateCapability<Port>(port_cap, kZionPerm_Read));
auto port = port_cap->obj<Port>();
return port->Recv(req->num_bytes, req->data, req->num_caps, req->caps);
ASSIGN_OR_RETURN(IpcMessage msg, port->Recv(*req->num_bytes, *req->num_caps));
return TranslateIpcMessageToResponse(msg, req);
}
glcr::ErrorCode PortPoll(ZPortPollReq* req) {
@ -78,7 +119,8 @@ glcr::ErrorCode PortPoll(ZPortPollReq* req) {
if (!port->HasMessages()) {
return glcr::EMPTY;
}
return port->Recv(req->num_bytes, req->data, req->num_caps, req->caps);
ASSIGN_OR_RETURN(IpcMessage msg, port->Recv(*req->num_bytes, *req->num_caps));
return TranslateIpcMessageToResponse(msg, req);
}
glcr::ErrorCode IrqRegister(ZIrqRegisterReq* req) {
@ -123,13 +165,9 @@ glcr::ErrorCode EndpointRecv(ZEndpointRecvReq* req) {
ValidateCapability<Endpoint>(endpoint_cap, kZionPerm_Read);
auto endpoint = endpoint_cap->obj<Endpoint>();
uint64_t num_caps = 1;
RET_ERR(endpoint->Recv(req->num_bytes, req->data, req->num_caps, req->caps,
req->reply_port_cap));
if (num_caps != 1) {
return glcr::INTERNAL;
}
return glcr::OK;
ASSIGN_OR_RETURN(IpcMessage msg,
endpoint->Recv(*req->num_bytes, *req->num_caps));
return TranslateIpcMessageToResponseWithReplyPort(msg, req);
}
glcr::ErrorCode ReplyPortSend(ZReplyPortSendReq* req) {
@ -148,5 +186,7 @@ glcr::ErrorCode ReplyPortRecv(ZReplyPortRecvReq* req) {
ValidateCapability<ReplyPort>(reply_port_cap, kZionPerm_Read);
auto reply_port = reply_port_cap->obj<ReplyPort>();
return reply_port->Recv(req->num_bytes, req->data, req->num_caps, req->caps);
ASSIGN_OR_RETURN(IpcMessage msg,
reply_port->Recv(*req->num_bytes, *req->num_caps));
return TranslateIpcMessageToResponse(msg, req);
}