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

Compare commits

base: drew:a98e66ac475aca632e61ab88238bfe74d8b91307
Branches Tags
drew:main
drew:0.1.0
..
compare: drew:fecaa387b0d2258ed24d14d87323f3ded9bf3b37
Branches Tags
drew:main
drew:0.1.0

No commits in common. "a98e66ac475aca632e61ab88238bfe74d8b91307" and "fecaa387b0d2258ed24d14d87323f3ded9bf3b37" have entirely different histories.
a98e66ac47 ... fecaa387b0

15 changed files with 6 additions and 657 deletions
Show Stats Expand all files Collapse all files

6
lib/glacier/string/string.cpp
View File

@ -32,7 +32,7 @@ String::String(const String& other) : String(other.cstr_, other.length_) {}
String& String::operator=(const String& other) { String& String::operator=(const String& other) {
if (cstr_) { if (cstr_) {
delete[] cstr_; delete cstr_;
} }
length_ = other.length_; length_ = other.length_;
cstr_ = new char[length_ + 1]; cstr_ = new char[length_ + 1];
@ -51,7 +51,7 @@ String::String(String&& other) : cstr_(other.cstr_), length_(other.length_) {
String& String::operator=(String&& other) { String& String::operator=(String&& other) {
if (cstr_) { if (cstr_) {
delete[] cstr_; delete cstr_;
} }
cstr_ = other.cstr_; cstr_ = other.cstr_;
length_ = other.length_; length_ = other.length_;
@ -64,7 +64,7 @@ String& String::operator=(String&& other) {
String::~String() { String::~String() {
if (cstr_) { if (cstr_) {
delete[] cstr_; delete cstr_;
} }
} }

6
lib/yunq/message_view.cpp
View File

@ -29,12 +29,6 @@ glcr::ErrorOr<uint64_t> MessageView::ReadField<uint64_t>(
return buffer_.At<uint64_t>(field_offset(field_index)); return buffer_.At<uint64_t>(field_offset(field_index));
} }
template <>
glcr::ErrorOr<int64_t> MessageView::ReadField<int64_t>(
uint64_t field_index) const {
return buffer_.At<int64_t>(field_offset(field_index));
}
template <> template <>
glcr::ErrorOr<glcr::String> MessageView::ReadField<glcr::String>( glcr::ErrorOr<glcr::String> MessageView::ReadField<glcr::String>(
uint64_t field_index) const { uint64_t field_index) const {

4
lib/yunq/message_view.h
View File

@ -49,10 +49,6 @@ template <>
glcr::ErrorOr<uint64_t> MessageView::ReadField<uint64_t>( glcr::ErrorOr<uint64_t> MessageView::ReadField<uint64_t>(
uint64_t field_index) const; uint64_t field_index) const;
template <>
glcr::ErrorOr<int64_t> MessageView::ReadField<int64_t>(
uint64_t field_index) const;
template <> template <>
glcr::ErrorOr<glcr::String> MessageView::ReadField<glcr::String>( glcr::ErrorOr<glcr::String> MessageView::ReadField<glcr::String>(
uint64_t field_index) const; uint64_t field_index) const;

6
lib/yunq/serialize.cpp
View File

@ -20,12 +20,6 @@ void Serializer::WriteField<uint64_t>(uint64_t field_index,
buffer_.WriteAt<uint64_t>(field_offset(field_index), value); buffer_.WriteAt<uint64_t>(field_offset(field_index), value);
} }
template <>
void Serializer::WriteField<int64_t>(uint64_t field_index,
const int64_t& value) {
buffer_.WriteAt<int64_t>(field_offset(field_index), value);
}
template <> template <>
void Serializer::WriteField<glcr::String>(uint64_t field_index, void Serializer::WriteField<glcr::String>(uint64_t field_index,
const glcr::String& value) { const glcr::String& value) {

5
lib/yunq/serialize.h
View File

@ -26,6 +26,7 @@ class Serializer {
next_extension_(kHeaderSize + (8 * num_fields)), next_extension_(kHeaderSize + (8 * num_fields)),
core_size_(next_extension_), core_size_(next_extension_),
caps_(caps) {} caps_(caps) {}
template <typename T> template <typename T>
void WriteField(uint64_t field_index, const T& value); void WriteField(uint64_t field_index, const T& value);
@ -64,10 +65,6 @@ template <>
void Serializer::WriteField<uint64_t>(uint64_t field_index, void Serializer::WriteField<uint64_t>(uint64_t field_index,
const uint64_t& value); const uint64_t& value);
template <>
void Serializer::WriteField<int64_t>(uint64_t field_index,
const int64_t& value);
template <> template <>
void Serializer::WriteField<glcr::String>(uint64_t field_index, void Serializer::WriteField<glcr::String>(uint64_t field_index,
const glcr::String& value); const glcr::String& value);

6
lib/yunq/test/CMakeLists.txt
View File

@ -15,7 +15,7 @@ add_dependencies(build_test
yunq_test) yunq_test)
# Build the yunq manually rather than using the generator # Build the yunq manualy rather than using the generator
# because we don't want to link against mammoth and overrite new. # because we don't want to link against mammoth and overrite new.
set(target example_yunq) set(target example_yunq)
add_library(example_yunq add_library(example_yunq
@ -36,9 +36,7 @@ set(PYTHON "${CMAKE_SOURCE_DIR}/yunq/venv/bin/python")
set(YUNQ "${CMAKE_SOURCE_DIR}/yunq/yunq.py") set(YUNQ "${CMAKE_SOURCE_DIR}/yunq/yunq.py")
add_custom_command( add_custom_command(
OUTPUT OUTPUT example/example.yunq.cpp
${CMAKE_CURRENT_SOURCE_DIR}/example/example.yunq.cpp
${CMAKE_CURRENT_SOURCE_DIR}/example/example.yunq.h
COMMAND ${PYTHON} ${YUNQ} ${CMAKE_CURRENT_SOURCE_DIR}/example/example.yunq COMMAND ${PYTHON} ${YUNQ} ${CMAKE_CURRENT_SOURCE_DIR}/example/example.yunq
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/example/example.yunq DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/example/example.yunq
) )

10
lib/yunq/test/example/example.yunq
View File

@ -3,13 +3,3 @@ package ex;
message Basic { message Basic {
u64 field; u64 field;
} }
message Types {
u64 unsigned_int;
i64 signed_int;
string str;
}
message Cap {
capability cap;
}

83
lib/yunq/test/example/example.yunq.cpp
View File

@ -53,89 +53,6 @@ uint64_t Basic::SerializeInternal(yunq::Serializer& serializer) const {
return serializer.size(); return serializer.size();
} }
glcr::Status Types::ParseFromBytes(const yunq::MessageView& message) {
RETURN_ERROR(ParseFromBytesInternal(message));
return glcr::Status::Ok();
}
glcr::Status Types::ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer& caps) {
RETURN_ERROR(ParseFromBytesInternal(message));
return glcr::Status::Ok();
}
glcr::Status Types::ParseFromBytesInternal(const yunq::MessageView& message) {
RETURN_ERROR(message.CheckHeader());
// Parse unsigned_int.
ASSIGN_OR_RETURN(unsigned_int_, message.ReadField<uint64_t>(0));
// Parse signed_int.
ASSIGN_OR_RETURN(signed_int_, message.ReadField<int64_t>(1));
// Parse str.
ASSIGN_OR_RETURN(str_, message.ReadField<glcr::String>(2));
return glcr::Status::Ok();
}
uint64_t Types::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t offset) const {
yunq::Serializer serializer(bytes, offset, 3);
return SerializeInternal(serializer);
}
uint64_t Types::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t offset, glcr::CapBuffer& caps) const {
yunq::Serializer serializer(bytes, offset, 3, caps);
return SerializeInternal(serializer);
}
uint64_t Types::SerializeInternal(yunq::Serializer& serializer) const {
// Write unsigned_int.
serializer.WriteField<uint64_t>(0, unsigned_int_);
// Write signed_int.
serializer.WriteField<int64_t>(1, signed_int_);
// Write str.
serializer.WriteField<glcr::String>(2, str_);
serializer.WriteHeader();
return serializer.size();
}
glcr::Status Cap::ParseFromBytes(const yunq::MessageView& message) {
RETURN_ERROR(ParseFromBytesInternal(message));
// Parse cap.
ASSIGN_OR_RETURN(cap_, message.ReadCapability(0));
return glcr::Status::Ok();
}
glcr::Status Cap::ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer& caps) {
RETURN_ERROR(ParseFromBytesInternal(message));
// Parse cap.
ASSIGN_OR_RETURN(cap_, message.ReadCapability(0, caps));
return glcr::Status::Ok();
}
glcr::Status Cap::ParseFromBytesInternal(const yunq::MessageView& message) {
RETURN_ERROR(message.CheckHeader());
// Parse cap.
return glcr::Status::Ok();
}
uint64_t Cap::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t offset) const {
yunq::Serializer serializer(bytes, offset, 1);
return SerializeInternal(serializer);
}
uint64_t Cap::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t offset, glcr::CapBuffer& caps) const {
yunq::Serializer serializer(bytes, offset, 1, caps);
return SerializeInternal(serializer);
}
uint64_t Cap::SerializeInternal(yunq::Serializer& serializer) const {
// Write cap.
serializer.WriteCapability(0, cap_);
serializer.WriteHeader();
return serializer.size();
}
} // namepace ex } // namepace ex

60
lib/yunq/test/example/example.yunq.h
View File

@ -38,66 +38,6 @@ class Basic {
uint64_t SerializeInternal(yunq::Serializer& serializer) const; uint64_t SerializeInternal(yunq::Serializer& serializer) const;
}; };
class Types {
public:
Types() {}
// Delete copy and move until implemented.
Types(const Types&) = delete;
Types(Types&&) = default;
Types& operator=(Types&&) = default;
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message);
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer&);
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const;
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const;
const uint64_t& unsigned_int() const { return unsigned_int_; }
uint64_t& mutable_unsigned_int() { return unsigned_int_; }
void set_unsigned_int(const uint64_t& value) { unsigned_int_ = value; }
const int64_t& signed_int() const { return signed_int_; }
int64_t& mutable_signed_int() { return signed_int_; }
void set_signed_int(const int64_t& value) { signed_int_ = value; }
const glcr::String& str() const { return str_; }
glcr::String& mutable_str() { return str_; }
void set_str(const glcr::String& value) { str_ = value; }
private:
uint64_t unsigned_int_;
int64_t signed_int_;
glcr::String str_;
// Parses everything except for caps.
glcr::Status ParseFromBytesInternal(const yunq::MessageView& message);
uint64_t SerializeInternal(yunq::Serializer& serializer) const;
};
class Cap {
public:
Cap() {}
// Delete copy and move until implemented.
Cap(const Cap&) = delete;
Cap(Cap&&) = default;
Cap& operator=(Cap&&) = default;
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message);
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer&);
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const;
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const;
const z_cap_t& cap() const { return cap_; }
z_cap_t& mutable_cap() { return cap_; }
void set_cap(const z_cap_t& value) { cap_ = value; }
private:
z_cap_t cap_;
// Parses everything except for caps.
glcr::Status ParseFromBytesInternal(const yunq::MessageView& message);
uint64_t SerializeInternal(yunq::Serializer& serializer) const;
};
} // namepace ex } // namepace ex

29
lib/yunq/test/yunq_test.cpp
View File

@ -21,32 +21,3 @@ TEST_CASE("Basic serialization", "[yunq]") {
REQUIRE(b.field() == 1); REQUIRE(b.field() == 1);
} }
TEST_CASE("Types Setter/Getter", "[yunq]") {
ex::Types t;
t.set_unsigned_int(1);
t.set_signed_int(-1);
t.set_str("test");
REQUIRE(t.unsigned_int() == 1);
REQUIRE(t.signed_int() == -1);
REQUIRE(t.str() == "test");
}
TEST_CASE("Types Serialization", "[yunq]") {
ex::Types a;
a.set_unsigned_int(1);
a.set_signed_int(-1);
a.set_str("test");
glcr::ByteBuffer buf(1024);
a.SerializeToBytes(buf, 0);
ex::Types b;
yunq::MessageView v(buf, 0);
REQUIRE(b.ParseFromBytes(v).ok() == true);
REQUIRE(b.unsigned_int() == 1);
REQUIRE(b.signed_int() == -1);
REQUIRE(b.str() == "test");
}

100
sys/denali/lib/denali/denali.yunq.client.cpp
View File

@ -1,100 +0,0 @@
// Generated file - DO NOT MODIFY
#include "denali.yunq.client.h"
#include <glacier/buffer/byte_buffer.h>
#include <glacier/buffer/cap_buffer.h>
#include <mammoth/util/debug.h>
#include <zcall.h>
DenaliClient::~DenaliClient() {
if (endpoint_ != 0) {
check(ZCapRelease(endpoint_));
}
}
glcr::Status DenaliClient::Read(const ReadRequest& request, ReadResponse& response) {
uint64_t buffer_size = kBufferSize;
uint64_t cap_size = kCapBufferSize;
const uint32_t kSentinel = 0xBEEFDEAD;
buffer_.WriteAt<uint32_t>(0, kSentinel);
buffer_.WriteAt<uint64_t>(8, 0);
cap_buffer_.Reset();
uint64_t length = request.SerializeToBytes(buffer_, /*offset=*/16, cap_buffer_);
buffer_.WriteAt<uint32_t>(4, 16 + length);
z_cap_t reply_port_cap;
RET_ERR(ZEndpointSend(endpoint_, 16 + length, buffer_.RawPtr(), cap_buffer_.UsedSlots(), cap_buffer_.RawPtr(), &reply_port_cap));
// FIXME: Add a way to zero out the first buffer.
RET_ERR(ZReplyPortRecv(reply_port_cap, &buffer_size, buffer_.RawPtr(), &cap_size, cap_buffer_.RawPtr()));
if (buffer_.At<uint32_t>(0) != kSentinel) {
return glcr::InvalidResponse("Got an invalid response from server.");
}
// Check Response Code.
RET_ERR(buffer_.At<uint64_t>(8));
yunq::MessageView resp_view(buffer_, 16);
RETURN_ERROR(response.ParseFromBytes(resp_view, cap_buffer_));
return glcr::OK;
}
glcr::Status DenaliClient::ReadMany(const ReadManyRequest& request, ReadResponse& response) {
uint64_t buffer_size = kBufferSize;
uint64_t cap_size = kCapBufferSize;
const uint32_t kSentinel = 0xBEEFDEAD;
buffer_.WriteAt<uint32_t>(0, kSentinel);
buffer_.WriteAt<uint64_t>(8, 1);
cap_buffer_.Reset();
uint64_t length = request.SerializeToBytes(buffer_, /*offset=*/16, cap_buffer_);
buffer_.WriteAt<uint32_t>(4, 16 + length);
z_cap_t reply_port_cap;
RET_ERR(ZEndpointSend(endpoint_, 16 + length, buffer_.RawPtr(), cap_buffer_.UsedSlots(), cap_buffer_.RawPtr(), &reply_port_cap));
// FIXME: Add a way to zero out the first buffer.
RET_ERR(ZReplyPortRecv(reply_port_cap, &buffer_size, buffer_.RawPtr(), &cap_size, cap_buffer_.RawPtr()));
if (buffer_.At<uint32_t>(0) != kSentinel) {
return glcr::InvalidResponse("Got an invalid response from server.");
}
// Check Response Code.
RET_ERR(buffer_.At<uint64_t>(8));
yunq::MessageView resp_view(buffer_, 16);
RETURN_ERROR(response.ParseFromBytes(resp_view, cap_buffer_));
return glcr::OK;
}

186
sys/denali/lib/denali/denali.yunq.cpp
View File

@ -1,186 +0,0 @@
// Generated file -- DO NOT MODIFY.
#include "denali.yunq.h"
#include <yunq/message_view.h>
#include <yunq/serialize.h>
namespace {
const uint64_t header_size = 24; // 4x uint32, 1x uint64
struct ExtPointer {
uint32_t offset;
uint32_t length;
};
} // namespace
glcr::Status DiskBlock::ParseFromBytes(const yunq::MessageView& message) {
RETURN_ERROR(ParseFromBytesInternal(message));
return glcr::Status::Ok();
}
glcr::Status DiskBlock::ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer& caps) {
RETURN_ERROR(ParseFromBytesInternal(message));
return glcr::Status::Ok();
}
glcr::Status DiskBlock::ParseFromBytesInternal(const yunq::MessageView& message) {
RETURN_ERROR(message.CheckHeader());
// Parse lba.
ASSIGN_OR_RETURN(lba_, message.ReadField<uint64_t>(0));
// Parse size.
ASSIGN_OR_RETURN(size_, message.ReadField<uint64_t>(1));
return glcr::Status::Ok();
}
uint64_t DiskBlock::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t offset) const {
yunq::Serializer serializer(bytes, offset, 2);
return SerializeInternal(serializer);
}
uint64_t DiskBlock::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t offset, glcr::CapBuffer& caps) const {
yunq::Serializer serializer(bytes, offset, 2, caps);
return SerializeInternal(serializer);
}
uint64_t DiskBlock::SerializeInternal(yunq::Serializer& serializer) const {
// Write lba.
serializer.WriteField<uint64_t>(0, lba_);
// Write size.
serializer.WriteField<uint64_t>(1, size_);
serializer.WriteHeader();
return serializer.size();
}
glcr::Status ReadRequest::ParseFromBytes(const yunq::MessageView& message) {
RETURN_ERROR(ParseFromBytesInternal(message));
return glcr::Status::Ok();
}
glcr::Status ReadRequest::ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer& caps) {
RETURN_ERROR(ParseFromBytesInternal(message));
return glcr::Status::Ok();
}
glcr::Status ReadRequest::ParseFromBytesInternal(const yunq::MessageView& message) {
RETURN_ERROR(message.CheckHeader());
// Parse device_id.
ASSIGN_OR_RETURN(device_id_, message.ReadField<uint64_t>(0));
// Parse block.
message.ReadMessage<DiskBlock>(1, block_);
return glcr::Status::Ok();
}
uint64_t ReadRequest::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t offset) const {
yunq::Serializer serializer(bytes, offset, 2);
return SerializeInternal(serializer);
}
uint64_t ReadRequest::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t offset, glcr::CapBuffer& caps) const {
yunq::Serializer serializer(bytes, offset, 2, caps);
return SerializeInternal(serializer);
}
uint64_t ReadRequest::SerializeInternal(yunq::Serializer& serializer) const {
// Write device_id.
serializer.WriteField<uint64_t>(0, device_id_);
// Write block.
serializer.WriteMessage<DiskBlock>(1, block_);
serializer.WriteHeader();
return serializer.size();
}
glcr::Status ReadManyRequest::ParseFromBytes(const yunq::MessageView& message) {
RETURN_ERROR(ParseFromBytesInternal(message));
return glcr::Status::Ok();
}
glcr::Status ReadManyRequest::ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer& caps) {
RETURN_ERROR(ParseFromBytesInternal(message));
return glcr::Status::Ok();
}
glcr::Status ReadManyRequest::ParseFromBytesInternal(const yunq::MessageView& message) {
RETURN_ERROR(message.CheckHeader());
// Parse device_id.
ASSIGN_OR_RETURN(device_id_, message.ReadField<uint64_t>(0));
// Parse blocks.
message.ReadRepeatedMessage<DiskBlock>(1, blocks_);
return glcr::Status::Ok();
}
uint64_t ReadManyRequest::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t offset) const {
yunq::Serializer serializer(bytes, offset, 2);
return SerializeInternal(serializer);
}
uint64_t ReadManyRequest::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t offset, glcr::CapBuffer& caps) const {
yunq::Serializer serializer(bytes, offset, 2, caps);
return SerializeInternal(serializer);
}
uint64_t ReadManyRequest::SerializeInternal(yunq::Serializer& serializer) const {
// Write device_id.
serializer.WriteField<uint64_t>(0, device_id_);
// Write blocks.
serializer.WriteRepeatedMessage<DiskBlock>(1, blocks_);
serializer.WriteHeader();
return serializer.size();
}
glcr::Status ReadResponse::ParseFromBytes(const yunq::MessageView& message) {
RETURN_ERROR(ParseFromBytesInternal(message));
// Parse memory.
ASSIGN_OR_RETURN(memory_, message.ReadCapability(2));
return glcr::Status::Ok();
}
glcr::Status ReadResponse::ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer& caps) {
RETURN_ERROR(ParseFromBytesInternal(message));
// Parse memory.
ASSIGN_OR_RETURN(memory_, message.ReadCapability(2, caps));
return glcr::Status::Ok();
}
glcr::Status ReadResponse::ParseFromBytesInternal(const yunq::MessageView& message) {
RETURN_ERROR(message.CheckHeader());
// Parse device_id.
ASSIGN_OR_RETURN(device_id_, message.ReadField<uint64_t>(0));
// Parse size.
ASSIGN_OR_RETURN(size_, message.ReadField<uint64_t>(1));
// Parse memory.
return glcr::Status::Ok();
}
uint64_t ReadResponse::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t offset) const {
yunq::Serializer serializer(bytes, offset, 3);
return SerializeInternal(serializer);
}
uint64_t ReadResponse::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t offset, glcr::CapBuffer& caps) const {
yunq::Serializer serializer(bytes, offset, 3, caps);
return SerializeInternal(serializer);
}
uint64_t ReadResponse::SerializeInternal(yunq::Serializer& serializer) const {
// Write device_id.
serializer.WriteField<uint64_t>(0, device_id_);
// Write size.
serializer.WriteField<uint64_t>(1, size_);
// Write memory.
serializer.WriteCapability(2, memory_);
serializer.WriteHeader();
return serializer.size();
}

152
sys/denali/lib/denali/denali.yunq.server.cpp
View File

@ -1,152 +0,0 @@
// Generated file -- DO NOT MODIFY.
#include "denali.yunq.server.h"
#include <mammoth/util/debug.h>
#include <zcall.h>
namespace {
const uint32_t kSentinel = 0xBEEFDEAD;
const uint32_t kHeaderSize = 0x10;
void WriteError(glcr::ByteBuffer& buffer, glcr::ErrorCode err) {
buffer.WriteAt<uint32_t>(0, kSentinel);
buffer.WriteAt<uint32_t>(4, kHeaderSize);
buffer.WriteAt<uint64_t>(8, err);
}
void WriteHeader(glcr::ByteBuffer& buffer, uint64_t message_length) {
buffer.WriteAt<uint32_t>(0, kSentinel);
buffer.WriteAt<uint32_t>(4, kHeaderSize + message_length);
buffer.WriteAt<uint64_t>(8, glcr::OK);
}
} // namespace
void DenaliServerBaseThreadBootstrap(void* server_base) {
((DenaliServerBase*)server_base)->ServerThread();
}
DenaliServerBase::~DenaliServerBase() {
if (endpoint_ != 0) {
check(ZCapRelease(endpoint_));
}
}
glcr::ErrorOr<z_cap_t> DenaliServerBase::CreateClientCap() {
uint64_t client_cap;
RET_ERR(ZCapDuplicate(endpoint_, ~(kZionPerm_Read), &client_cap));
return client_cap;
}
glcr::ErrorOr<DenaliClient> DenaliServerBase::CreateClient() {
uint64_t client_cap;
RET_ERR(ZCapDuplicate(endpoint_, ~(kZionPerm_Read), &client_cap));
return DenaliClient(client_cap);
}
Thread DenaliServerBase::RunServer() {
return Thread(DenaliServerBaseThreadBootstrap, this);
}
void DenaliServerBase::ServerThread() {
glcr::ByteBuffer recv_buffer(0x1000);
glcr::CapBuffer recv_cap(0x10);
glcr::ByteBuffer resp_buffer(0x1000);
glcr::CapBuffer resp_cap(0x10);
z_cap_t reply_port_cap;
while (true) {
uint64_t recv_cap_size = 0x10;
uint64_t recv_buf_size = 0x1000;
recv_cap.Reset();
glcr::ErrorCode recv_err = static_cast<glcr::ErrorCode>(ZEndpointRecv(endpoint_, &recv_buf_size, recv_buffer.RawPtr(), &recv_cap_size, recv_cap.RawPtr(), &reply_port_cap));
if (recv_err != glcr::OK) {
dbgln("Error in receive: {x}", recv_err);
continue;
}
uint64_t resp_length = 0;
glcr::ErrorCode reply_err = glcr::OK;
resp_cap.Reset();
glcr::Status err = HandleRequest(recv_buffer, recv_cap, resp_buffer, resp_length, resp_cap);
if (!err) {
WriteError(resp_buffer, err.code());
dbgln("Responding Error {}", err.message());
reply_err = static_cast<glcr::ErrorCode>(ZReplyPortSend(reply_port_cap, kHeaderSize, resp_buffer.RawPtr(), 0, nullptr));
} else {
WriteHeader(resp_buffer, resp_length);
reply_err = static_cast<glcr::ErrorCode>(ZReplyPortSend(reply_port_cap, kHeaderSize + resp_length, resp_buffer.RawPtr(), resp_cap.UsedSlots(), resp_cap.RawPtr()));
}
if (reply_err != glcr::OK) {
dbgln("Error in reply: {x}", reply_err);
}
}
}
glcr::Status DenaliServerBase::HandleRequest(const glcr::ByteBuffer& request,
const glcr::CapBuffer& req_caps,
glcr::ByteBuffer& response, uint64_t& resp_length,
glcr::CapBuffer& resp_caps) {
if (request.At<uint32_t>(0) != kSentinel) {
return glcr::InvalidArgument("Request Not Valid");
}
uint64_t method_select = request.At<uint64_t>(8);
switch(method_select) {
case 0: {
ReadRequest yunq_request;
yunq::MessageView request_view(request, kHeaderSize);
RETURN_ERROR(yunq_request.ParseFromBytes(request_view, req_caps));
ReadResponse yunq_response;
RETURN_ERROR(HandleRead(yunq_request, yunq_response));
resp_length = yunq_response.SerializeToBytes(response, kHeaderSize, resp_caps);
break;
}
case 1: {
ReadManyRequest yunq_request;
yunq::MessageView request_view(request, kHeaderSize);
RETURN_ERROR(yunq_request.ParseFromBytes(request_view, req_caps));
ReadResponse yunq_response;
RETURN_ERROR(HandleReadMany(yunq_request, yunq_response));
resp_length = yunq_response.SerializeToBytes(response, kHeaderSize, resp_caps);
break;
}
default: {
return glcr::Unimplemented("Method unimplemented by server.");
}
}
return glcr::Status::Ok();
}

3
yunq/yunq.py
View File

@ -45,9 +45,6 @@ def main():
message_impl = message_impl_tmpl.render(file=filebase, messages=messages, package=package) message_impl = message_impl_tmpl.render(file=filebase, messages=messages, package=package)
f.write(message_impl) f.write(message_impl)
if len(interfaces) == 0:
return
client_header_tmpl = jinja_env.get_template("client.h.jinja") client_header_tmpl = jinja_env.get_template("client.h.jinja")
with open(filename + '.client.h', mode='w') as f: with open(filename + '.client.h', mode='w') as f:
client_header = client_header_tmpl.render(file=filebase, interfaces=interfaces, package=package) client_header = client_header_tmpl.render(file=filebase, interfaces=interfaces, package=package)

7
zion/CMakeLists.txt
View File

@ -99,10 +99,3 @@ add_library(zion_stub STATIC
target_include_directories(zion_stub target_include_directories(zion_stub
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include) PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
set_target_properties(zion_stub
PROPERTIES
COMPILE_FLAGS "${BASE_COMPILE_FLAGS} -nostdlib -c"
LINK_FLAGS "${BASE_LINK_FLAGS} -nostartfiles -static -lgcc"
)