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

Compare commits

base: drew:0135d8d844f92ba5fc9b13a62f9356131b5904ca
Branches Tags
drew:main
drew:0.1.0
..
compare: drew:5eb72da9c8bc565c847d78ec4eccfb29dcb04587
Branches Tags
drew:main
drew:0.1.0

No commits in common. "0135d8d844f92ba5fc9b13a62f9356131b5904ca" and "5eb72da9c8bc565c847d78ec4eccfb29dcb04587" have entirely different histories.
0135d8d844 ... 5eb72da9c8

30 changed files with 325 additions and 434 deletions
Show Stats Expand all files Collapse all files

23
lib/glacier/container/hash_map.h
View File

@ -18,8 +18,9 @@ class HashMap {
HashMap() = default; HashMap() = default;
HashMap(const HashMap&) = delete; HashMap(const HashMap&) = delete;
HashMap& operator=(const HashMap&) = delete; HashMap& operator=(const HashMap&) = delete;
HashMap(HashMap&&); // TODO: Implement Move.
HashMap& operator=(HashMap&&); HashMap(HashMap&&) = delete;
HashMap& operator=(HashMap&&) = delete;
// Accessors. // Accessors.
uint64_t size() { return size_; } uint64_t size() { return size_; }
@ -62,21 +63,6 @@ class HashMap {
void ResizeIfNecessary(); void ResizeIfNecessary();
}; };
template <typename K, typename V, class H>
HashMap<K, V, H>::HashMap(HashMap&& other) {
data_ = glcr::Move(other.data_);
size_ = other.size_;
other.size_ = 0;
}
template <typename K, typename V, class H>
HashMap<K, V, H>& HashMap<K, V, H>::operator=(HashMap&& other) {
data_ = glcr::Move(other.data_);
size_ = other.size_;
other.size_ = 0;
return *this;
}
template <typename K, typename V, class H> template <typename K, typename V, class H>
V& HashMap<K, V, H>::at(const K& key) { V& HashMap<K, V, H>::at(const K& key) {
uint64_t hc = H()(key); uint64_t hc = H()(key);
@ -88,8 +74,7 @@ V& HashMap<K, V, H>::at(const K& key) {
} }
} }
// TODO: Add a failure mode here instead of constructing an object. // TODO: Add a failure mode here instead of constructing an object.
K k2 = key; ll.PushFront({key, {}});
ll.PushFront({glcr::Move(k2), {}});
return ll.PeekFront().second(); return ll.PeekFront().second();
} }

4
lib/mammoth/util/memory_region.cpp
View File

@ -71,8 +71,4 @@ z_cap_t OwnedMemoryRegion::DuplicateCap() {
return cap; return cap;
} }
OwnedMemoryRegion OwnedMemoryRegion::Duplicate() {
return OwnedMemoryRegion::FromCapability(DuplicateCap());
}
} // namespace mmth } // namespace mmth

1
lib/mammoth/util/memory_region.h
View File

@ -30,7 +30,6 @@ class OwnedMemoryRegion {
z_cap_t cap() const { return vmmo_cap_; } z_cap_t cap() const { return vmmo_cap_; }
z_cap_t DuplicateCap(); z_cap_t DuplicateCap();
OwnedMemoryRegion Duplicate();
bool empty() const { return vmmo_cap_ == 0; } bool empty() const { return vmmo_cap_ == 0; }
explicit operator bool() const { return vmmo_cap_ != 0; } explicit operator bool() const { return vmmo_cap_ != 0; }

1
lib/yunq/CMakeLists.txt
View File

@ -1,5 +1,4 @@
set(yunq_files set(yunq_files
message_view.cpp
serialize.cpp serialize.cpp
) )

62
lib/yunq/message_view.cpp
View File

@ -1,62 +0,0 @@
#include "message_view.h"
namespace yunq {
namespace {
const uint64_t kIdentByte = 0x33441122;
} // namespace
glcr::Status MessageView::CheckHeader() const {
if (buffer_.At<uint32_t>(offset_ + 0) != kIdentByte) {
return glcr::InvalidArgument("Trying to parse an invalid yunq message.");
}
// TODO: Parse core size.
// TODO: Parse extension size.
// TODO: Check CRC32
// TODO: Parse options.
return glcr::Status::Ok();
}
template <>
glcr::ErrorOr<uint64_t> MessageView::ReadField<uint64_t>(
uint64_t field_index) const {
return buffer_.At<uint64_t>(field_offset(field_index));
}
template <>
glcr::ErrorOr<glcr::String> MessageView::ReadField<glcr::String>(
uint64_t field_index) const {
ExtensionPointer ptr =
buffer_.At<ExtensionPointer>(field_offset(field_index));
return buffer_.StringAt(offset_ + ptr.offset, ptr.length);
}
template <>
glcr::ErrorOr<glcr::Vector<uint64_t>> MessageView::ReadRepeated<uint64_t>(
uint64_t field_index) const {
ExtensionPointer pointer =
buffer_.At<ExtensionPointer>(field_offset(field_index));
glcr::Vector<uint64_t> v;
v.Resize(pointer.length / sizeof(uint64_t));
for (uint64_t i = offset_ + pointer.offset;
i < offset_ + pointer.offset + pointer.length; i += sizeof(uint64_t)) {
v.PushBack(buffer_.At<uint64_t>(i));
}
return v;
}
glcr::ErrorOr<uint64_t> MessageView::ReadCapability(
uint64_t field_index) const {
return buffer_.At<uint64_t>(field_offset(field_index));
}
glcr::ErrorOr<uint64_t> MessageView::ReadCapability(
uint64_t field_index, const glcr::CapBuffer& caps) const {
uint64_t offset = buffer_.At<uint64_t>(field_offset(field_index));
return caps.At(offset);
}
} // namespace yunq

65
lib/yunq/message_view.h
View File

@ -1,65 +0,0 @@
#pragma once
#include <glacier/buffer/byte_buffer.h>
#include <glacier/buffer/cap_buffer.h>
#include <glacier/container/vector.h>
#include <glacier/status/error_or.h>
#include <glacier/status/status.h>
namespace yunq {
const uint64_t kHeaderSize = 24; // 4x uint32, 1x uint64
struct MessageHeader {
uint32_t ident;
uint32_t core_length;
uint32_t length;
uint32_t crc32;
uint64_t options;
} __attribute__((packed));
struct ExtensionPointer {
uint32_t offset;
uint32_t length;
};
class MessageView {
public:
MessageView(const glcr::ByteBuffer& buffer, uint64_t offset)
: buffer_(buffer), offset_(offset) {}
[[nodiscard]] glcr::Status CheckHeader() const;
// TODO: Implement glcr::StatusOr
template <typename T>
glcr::ErrorOr<T> ReadField(uint64_t field_index) const;
template <typename T>
glcr::ErrorOr<glcr::Vector<T>> ReadRepeated(uint64_t field_index) const;
glcr::ErrorOr<uint64_t> ReadCapability(uint64_t field_index) const;
glcr::ErrorOr<uint64_t> ReadCapability(uint64_t field_index,
const glcr::CapBuffer& caps) const;
private:
const glcr::ByteBuffer& buffer_;
uint64_t offset_;
uint64_t field_offset(uint64_t field_index) const {
return offset_ + kHeaderSize + (8 * field_index);
}
};
template <>
glcr::ErrorOr<uint64_t> MessageView::ReadField<uint64_t>(
uint64_t field_index) const;
template <>
glcr::ErrorOr<glcr::String> MessageView::ReadField<glcr::String>(
uint64_t field_index) const;
template <>
glcr::ErrorOr<glcr::Vector<uint64_t>> MessageView::ReadRepeated<uint64_t>(
uint64_t field_index) const;
} // namespace yunq

11
lib/yunq/serialize.cpp
View File

@ -7,6 +7,17 @@ const uint64_t kIdentByte = 0x33441122;
} // namespace } // namespace
glcr::Status CheckHeader(const glcr::ByteBuffer& buffer, uint64_t offset) {
if (buffer.At<uint32_t>(offset + 0) != kIdentByte) {
return glcr::InvalidArgument("Trying to parse an invalid yunq message.");
}
// TODO: Parse core size.
// TODO: Parse extension size.
// TODO: Check CRC32
// TODO: Parse options.
return glcr::Status::Ok();
}
void WriteHeader(glcr::ByteBuffer& bytes, uint64_t offset, uint32_t core_size, void WriteHeader(glcr::ByteBuffer& bytes, uint64_t offset, uint32_t core_size,
uint32_t extension_size) { uint32_t extension_size) {
bytes.WriteAt<uint32_t>(offset + 0, kIdentByte); bytes.WriteAt<uint32_t>(offset + 0, kIdentByte);

3
lib/yunq/serialize.h
View File

@ -5,6 +5,9 @@
namespace yunq { namespace yunq {
[[nodiscard]] glcr::Status CheckHeader(const glcr::ByteBuffer& buffer,
uint64_t offset);
void WriteHeader(glcr::ByteBuffer& bytes, uint64_t offset, uint32_t core_size, void WriteHeader(glcr::ByteBuffer& bytes, uint64_t offset, uint32_t core_size,
uint32_t extension_size); uint32_t extension_size);

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

@ -48,8 +48,7 @@ glcr::Status DenaliClient::Read(const ReadRequest& request, ReadResponse& respon
RET_ERR(buffer_.At<uint64_t>(8)); RET_ERR(buffer_.At<uint64_t>(8));
yunq::MessageView resp_view(buffer_, 16); RETURN_ERROR(response.ParseFromBytes(buffer_, 16, cap_buffer_));
RETURN_ERROR(response.ParseFromBytes(resp_view, cap_buffer_));
return glcr::OK; return glcr::OK;
@ -88,8 +87,7 @@ glcr::Status DenaliClient::ReadMany(const ReadManyRequest& request, ReadResponse
RET_ERR(buffer_.At<uint64_t>(8)); RET_ERR(buffer_.At<uint64_t>(8));
yunq::MessageView resp_view(buffer_, 16); RETURN_ERROR(response.ParseFromBytes(buffer_, 16, cap_buffer_));
RETURN_ERROR(response.ParseFromBytes(resp_view, cap_buffer_));
return glcr::OK; return glcr::OK;

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

@ -1,7 +1,6 @@
// Generated file -- DO NOT MODIFY. // Generated file -- DO NOT MODIFY.
#include "denali.yunq.h" #include "denali.yunq.h"
#include <yunq/message_view.h>
#include <yunq/serialize.h> #include <yunq/serialize.h>
@ -15,24 +14,24 @@ struct ExtPointer {
}; };
} // namespace } // namespace
glcr::Status ReadRequest::ParseFromBytes(const yunq::MessageView& message) { glcr::Status ReadRequest::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset) {
RETURN_ERROR(ParseFromBytesInternal(message)); RETURN_ERROR(ParseFromBytesInternal(bytes, offset));
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
glcr::Status ReadRequest::ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer& caps) { glcr::Status ReadRequest::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset, const glcr::CapBuffer& caps) {
RETURN_ERROR(ParseFromBytesInternal(message)); RETURN_ERROR(ParseFromBytesInternal(bytes, offset));
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
glcr::Status ReadRequest::ParseFromBytesInternal(const yunq::MessageView& message) { glcr::Status ReadRequest::ParseFromBytesInternal(const glcr::ByteBuffer& bytes, uint64_t offset) {
RETURN_ERROR(message.CheckHeader()); RETURN_ERROR(yunq::CheckHeader(bytes, offset));
// Parse device_id. // Parse device_id.
ASSIGN_OR_RETURN(device_id_, message.ReadField<uint64_t>(0)); set_device_id(bytes.At<uint64_t>(offset + header_size + (8 * 0)));
// Parse lba. // Parse lba.
ASSIGN_OR_RETURN(lba_, message.ReadField<uint64_t>(1)); set_lba(bytes.At<uint64_t>(offset + header_size + (8 * 1)));
// Parse size. // Parse size.
ASSIGN_OR_RETURN(size_, message.ReadField<uint64_t>(2)); set_size(bytes.At<uint64_t>(offset + header_size + (8 * 2)));
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
@ -69,25 +68,39 @@ uint64_t ReadRequest::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t offset,
return next_extension; return next_extension;
} }
glcr::Status ReadManyRequest::ParseFromBytes(const yunq::MessageView& message) { glcr::Status ReadManyRequest::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset) {
RETURN_ERROR(ParseFromBytesInternal(message)); RETURN_ERROR(ParseFromBytesInternal(bytes, offset));
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
glcr::Status ReadManyRequest::ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer& caps) { glcr::Status ReadManyRequest::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset, const glcr::CapBuffer& caps) {
RETURN_ERROR(ParseFromBytesInternal(message)); RETURN_ERROR(ParseFromBytesInternal(bytes, offset));
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
glcr::Status ReadManyRequest::ParseFromBytesInternal(const yunq::MessageView& message) { glcr::Status ReadManyRequest::ParseFromBytesInternal(const glcr::ByteBuffer& bytes, uint64_t offset) {
RETURN_ERROR(message.CheckHeader()); RETURN_ERROR(yunq::CheckHeader(bytes, offset));
// Parse device_id. // Parse device_id.
ASSIGN_OR_RETURN(device_id_, message.ReadField<uint64_t>(0)); set_device_id(bytes.At<uint64_t>(offset + header_size + (8 * 0)));
// Parse lba. // Parse lba.
ASSIGN_OR_RETURN(lba_, message.ReadRepeated<uint64_t>(1)); auto lba_pointer = bytes.At<ExtPointer>(offset + header_size + (8 * 1));
lba_.Resize(lba_pointer.length / sizeof(uint64_t));
for (uint64_t i = offset + lba_pointer.offset;
i < offset + lba_pointer.offset + lba_pointer.length;
i += sizeof(uint64_t)) {
lba_.PushBack(bytes.At<uint64_t>(i));
}
// Parse sector_cnt. // Parse sector_cnt.
ASSIGN_OR_RETURN(sector_cnt_, message.ReadRepeated<uint64_t>(2)); auto sector_cnt_pointer = bytes.At<ExtPointer>(offset + header_size + (8 * 2));
sector_cnt_.Resize(sector_cnt_pointer.length / sizeof(uint64_t));
for (uint64_t i = offset + sector_cnt_pointer.offset;
i < offset + sector_cnt_pointer.offset + sector_cnt_pointer.length;
i += sizeof(uint64_t)) {
sector_cnt_.PushBack(bytes.At<uint64_t>(i));
}
return glcr::Status::Ok(); return glcr::Status::Ok();
@ -169,27 +182,31 @@ uint64_t ReadManyRequest::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t off
return next_extension; return next_extension;
} }
glcr::Status ReadResponse::ParseFromBytes(const yunq::MessageView& message) { glcr::Status ReadResponse::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset) {
RETURN_ERROR(ParseFromBytesInternal(message)); RETURN_ERROR(ParseFromBytesInternal(bytes, offset));
// Parse memory. // Parse memory.
ASSIGN_OR_RETURN(memory_, message.ReadCapability(2)); // FIXME: Implement in-buffer capabilities for inprocess serialization.
set_memory(0);
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
glcr::Status ReadResponse::ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer& caps) { glcr::Status ReadResponse::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset, const glcr::CapBuffer& caps) {
RETURN_ERROR(ParseFromBytesInternal(message)); RETURN_ERROR(ParseFromBytesInternal(bytes, offset));
// Parse memory. // Parse memory.
ASSIGN_OR_RETURN(memory_, message.ReadCapability(2, caps)); uint64_t memory_ptr = bytes.At<uint64_t>(offset + header_size + (8 * 2));
set_memory(caps.At(memory_ptr));
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
glcr::Status ReadResponse::ParseFromBytesInternal(const yunq::MessageView& message) { glcr::Status ReadResponse::ParseFromBytesInternal(const glcr::ByteBuffer& bytes, uint64_t offset) {
RETURN_ERROR(message.CheckHeader()); RETURN_ERROR(yunq::CheckHeader(bytes, offset));
// Parse device_id. // Parse device_id.
ASSIGN_OR_RETURN(device_id_, message.ReadField<uint64_t>(0)); set_device_id(bytes.At<uint64_t>(offset + header_size + (8 * 0)));
// Parse size. // Parse size.
ASSIGN_OR_RETURN(size_, message.ReadField<uint64_t>(1)); set_size(bytes.At<uint64_t>(offset + header_size + (8 * 1)));
// Parse memory. // Parse memory.
// Skip Cap.
return glcr::Status::Ok(); return glcr::Status::Ok();
} }

19
sys/denali/lib/denali/denali.yunq.h
View File

@ -6,7 +6,6 @@
#include <glacier/status/status.h> #include <glacier/status/status.h>
#include <glacier/container/vector.h> #include <glacier/container/vector.h>
#include <glacier/string/string.h> #include <glacier/string/string.h>
#include <yunq/message_view.h>
#include <ztypes.h> #include <ztypes.h>
@ -17,8 +16,8 @@ class ReadRequest {
ReadRequest(const ReadRequest&) = delete; ReadRequest(const ReadRequest&) = delete;
ReadRequest(ReadRequest&&) = delete; ReadRequest(ReadRequest&&) = delete;
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message); [[nodiscard]] glcr::Status ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset);
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer&); [[nodiscard]] glcr::Status ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset, const glcr::CapBuffer&);
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const; uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const;
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const; uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const;
const uint64_t& device_id() const { return device_id_; } const uint64_t& device_id() const { return device_id_; }
@ -34,7 +33,7 @@ class ReadRequest {
uint64_t size_; uint64_t size_;
// Parses everything except for caps. // Parses everything except for caps.
glcr::Status ParseFromBytesInternal(const yunq::MessageView& message); glcr::Status ParseFromBytesInternal(const glcr::ByteBuffer&, uint64_t offset);
}; };
class ReadManyRequest { class ReadManyRequest {
public: public:
@ -43,8 +42,8 @@ class ReadManyRequest {
ReadManyRequest(const ReadManyRequest&) = delete; ReadManyRequest(const ReadManyRequest&) = delete;
ReadManyRequest(ReadManyRequest&&) = delete; ReadManyRequest(ReadManyRequest&&) = delete;
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message); [[nodiscard]] glcr::Status ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset);
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer&); [[nodiscard]] glcr::Status ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset, const glcr::CapBuffer&);
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const; uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const;
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const; uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const;
const uint64_t& device_id() const { return device_id_; } const uint64_t& device_id() const { return device_id_; }
@ -60,7 +59,7 @@ class ReadManyRequest {
glcr::Vector<uint64_t> sector_cnt_; glcr::Vector<uint64_t> sector_cnt_;
// Parses everything except for caps. // Parses everything except for caps.
glcr::Status ParseFromBytesInternal(const yunq::MessageView& message); glcr::Status ParseFromBytesInternal(const glcr::ByteBuffer&, uint64_t offset);
}; };
class ReadResponse { class ReadResponse {
public: public:
@ -69,8 +68,8 @@ class ReadResponse {
ReadResponse(const ReadResponse&) = delete; ReadResponse(const ReadResponse&) = delete;
ReadResponse(ReadResponse&&) = delete; ReadResponse(ReadResponse&&) = delete;
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message); [[nodiscard]] glcr::Status ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset);
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer&); [[nodiscard]] glcr::Status ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset, const glcr::CapBuffer&);
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const; uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const;
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const; uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const;
const uint64_t& device_id() const { return device_id_; } const uint64_t& device_id() const { return device_id_; }
@ -86,6 +85,6 @@ class ReadResponse {
z_cap_t memory_; z_cap_t memory_;
// Parses everything except for caps. // Parses everything except for caps.
glcr::Status ParseFromBytesInternal(const yunq::MessageView& message); glcr::Status ParseFromBytesInternal(const glcr::ByteBuffer&, uint64_t offset);
}; };

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

@ -104,8 +104,7 @@ glcr::Status DenaliServerBase::HandleRequest(const glcr::ByteBuffer& request,
ReadRequest yunq_request; ReadRequest yunq_request;
yunq::MessageView request_view(request, kHeaderSize); RETURN_ERROR(yunq_request.ParseFromBytes(request, kHeaderSize, req_caps));
RETURN_ERROR(yunq_request.ParseFromBytes(request_view, req_caps));
@ -125,8 +124,7 @@ glcr::Status DenaliServerBase::HandleRequest(const glcr::ByteBuffer& request,
ReadManyRequest yunq_request; ReadManyRequest yunq_request;
yunq::MessageView request_view(request, kHeaderSize); RETURN_ERROR(yunq_request.ParseFromBytes(request, kHeaderSize, req_caps));
RETURN_ERROR(yunq_request.ParseFromBytes(request_view, req_caps));

30
sys/victoriafalls/fs/ext2/ext2_driver.cpp
View File

@ -56,12 +56,22 @@ glcr::ErrorOr<glcr::Vector<DirEntry>> Ext2Driver::ReadDirectory(
dbgln("Reading non directory."); dbgln("Reading non directory.");
return glcr::INVALID_ARGUMENT; return glcr::INVALID_ARGUMENT;
} }
ASSIGN_OR_RETURN(mmth::OwnedMemoryRegion dir, ReadInode(inode_number, inode));
// This calculation is cursed.
uint64_t real_block_cnt =
(inode->blocks - 1) / (ext2_reader_->BlockSize() / 512) + 1;
if (real_block_cnt > 12) {
dbgln("Cant handle indirect blocks yet");
return glcr::FAILED_PRECONDITION;
}
glcr::Vector<DirEntry> directory; glcr::Vector<DirEntry> directory;
for (uint64_t i = 0; i < real_block_cnt; i++) {
uint64_t addr = dir.vaddr(); ASSIGN_OR_RETURN(mmth::OwnedMemoryRegion block,
while (addr < dir.vaddr() + ext2_reader_->BlockSize()) { ext2_reader_->ReadBlock(inode->block[i]));
uint64_t addr = block.vaddr();
while (addr < block.vaddr() + ext2_reader_->BlockSize()) {
DirEntry* entry = reinterpret_cast<DirEntry*>(addr); DirEntry* entry = reinterpret_cast<DirEntry*>(addr);
directory.PushBack(*entry); directory.PushBack(*entry);
glcr::StringView name(entry->name, entry->name_len); glcr::StringView name(entry->name, entry->name_len);
@ -79,6 +89,7 @@ glcr::ErrorOr<glcr::Vector<DirEntry>> Ext2Driver::ReadDirectory(
#endif #endif
addr += entry->record_length; addr += entry->record_length;
} }
}
return directory; return directory;
} }
@ -90,14 +101,7 @@ glcr::ErrorOr<mmth::OwnedMemoryRegion> Ext2Driver::ReadFile(
dbgln("Reading non file."); dbgln("Reading non file.");
return glcr::INVALID_ARGUMENT; return glcr::INVALID_ARGUMENT;
} }
return ReadInode(inode_number, inode);
}
glcr::ErrorOr<mmth::OwnedMemoryRegion> Ext2Driver::ReadInode(uint64_t inode_num,
Inode* inode) {
if (inode_cache_.Contains(inode_num)) {
return inode_cache_.at(inode_num).Duplicate();
}
// This calculation is cursed. // This calculation is cursed.
uint64_t real_block_cnt = uint64_t real_block_cnt =
(inode->blocks - 1) / (ext2_reader_->BlockSize() / 512) + 1; (inode->blocks - 1) / (ext2_reader_->BlockSize() / 512) + 1;
@ -154,7 +158,5 @@ glcr::ErrorOr<mmth::OwnedMemoryRegion> Ext2Driver::ReadInode(uint64_t inode_num,
} }
} }
ASSIGN_OR_RETURN(auto inode_mem, ext2_reader_->ReadBlocks(blocks_to_read)); return ext2_reader_->ReadBlocks(blocks_to_read);
RET_ERR(inode_cache_.Insert(glcr::Move(inode_num), inode_mem.Duplicate()));
return inode_mem;
} }

5
sys/victoriafalls/fs/ext2/ext2_driver.h
View File

@ -1,6 +1,5 @@
#pragma once #pragma once
#include <glacier/container/hash_map.h>
#include <glacier/memory/move.h> #include <glacier/memory/move.h>
#include <glacier/memory/unique_ptr.h> #include <glacier/memory/unique_ptr.h>
#include <yellowstone/yellowstone.yunq.h> #include <yellowstone/yellowstone.yunq.h>
@ -25,12 +24,8 @@ class Ext2Driver {
private: private:
glcr::SharedPtr<Ext2BlockReader> ext2_reader_; glcr::SharedPtr<Ext2BlockReader> ext2_reader_;
glcr::UniquePtr<InodeTable> inode_table_; glcr::UniquePtr<InodeTable> inode_table_;
glcr::HashMap<uint64_t, mmth::OwnedMemoryRegion> inode_cache_;
Ext2Driver(const glcr::SharedPtr<Ext2BlockReader>& reader, Ext2Driver(const glcr::SharedPtr<Ext2BlockReader>& reader,
glcr::UniquePtr<InodeTable> inode_table) glcr::UniquePtr<InodeTable> inode_table)
: ext2_reader_(reader), inode_table_(glcr::Move(inode_table)) {} : ext2_reader_(reader), inode_table_(glcr::Move(inode_table)) {}
glcr::ErrorOr<mmth::OwnedMemoryRegion> ReadInode(uint64_t inode_num,
Inode* inode);
}; };

6
sys/victoriafalls/lib/victoriafalls/victoriafalls.yunq.client.cpp
View File

@ -48,8 +48,7 @@ glcr::Status VFSClient::OpenFile(const OpenFileRequest& request, OpenFileRespons
RET_ERR(buffer_.At<uint64_t>(8)); RET_ERR(buffer_.At<uint64_t>(8));
yunq::MessageView resp_view(buffer_, 16); RETURN_ERROR(response.ParseFromBytes(buffer_, 16, cap_buffer_));
RETURN_ERROR(response.ParseFromBytes(resp_view, cap_buffer_));
return glcr::OK; return glcr::OK;
@ -88,8 +87,7 @@ glcr::Status VFSClient::GetDirectory(const GetDirectoryRequest& request, Directo
RET_ERR(buffer_.At<uint64_t>(8)); RET_ERR(buffer_.At<uint64_t>(8));
yunq::MessageView resp_view(buffer_, 16); RETURN_ERROR(response.ParseFromBytes(buffer_, 16, cap_buffer_));
RETURN_ERROR(response.ParseFromBytes(resp_view, cap_buffer_));
return glcr::OK; return glcr::OK;

75
sys/victoriafalls/lib/victoriafalls/victoriafalls.yunq.cpp
View File

@ -1,7 +1,6 @@
// Generated file -- DO NOT MODIFY. // Generated file -- DO NOT MODIFY.
#include "victoriafalls.yunq.h" #include "victoriafalls.yunq.h"
#include <yunq/message_view.h>
#include <yunq/serialize.h> #include <yunq/serialize.h>
@ -15,20 +14,22 @@ struct ExtPointer {
}; };
} // namespace } // namespace
glcr::Status OpenFileRequest::ParseFromBytes(const yunq::MessageView& message) { glcr::Status OpenFileRequest::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset) {
RETURN_ERROR(ParseFromBytesInternal(message)); RETURN_ERROR(ParseFromBytesInternal(bytes, offset));
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
glcr::Status OpenFileRequest::ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer& caps) { glcr::Status OpenFileRequest::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset, const glcr::CapBuffer& caps) {
RETURN_ERROR(ParseFromBytesInternal(message)); RETURN_ERROR(ParseFromBytesInternal(bytes, offset));
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
glcr::Status OpenFileRequest::ParseFromBytesInternal(const yunq::MessageView& message) { glcr::Status OpenFileRequest::ParseFromBytesInternal(const glcr::ByteBuffer& bytes, uint64_t offset) {
RETURN_ERROR(message.CheckHeader()); RETURN_ERROR(yunq::CheckHeader(bytes, offset));
// Parse path. // Parse path.
ASSIGN_OR_RETURN(path_, message.ReadField<glcr::String>(0)); auto path_pointer = bytes.At<ExtPointer>(offset + header_size + (8 * 0));
set_path(bytes.StringAt(offset + path_pointer.offset, path_pointer.length));
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
@ -75,27 +76,33 @@ uint64_t OpenFileRequest::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t off
return next_extension; return next_extension;
} }
glcr::Status OpenFileResponse::ParseFromBytes(const yunq::MessageView& message) { glcr::Status OpenFileResponse::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset) {
RETURN_ERROR(ParseFromBytesInternal(message)); RETURN_ERROR(ParseFromBytesInternal(bytes, offset));
// Parse memory. // Parse memory.
ASSIGN_OR_RETURN(memory_, message.ReadCapability(2)); // FIXME: Implement in-buffer capabilities for inprocess serialization.
set_memory(0);
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
glcr::Status OpenFileResponse::ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer& caps) { glcr::Status OpenFileResponse::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset, const glcr::CapBuffer& caps) {
RETURN_ERROR(ParseFromBytesInternal(message)); RETURN_ERROR(ParseFromBytesInternal(bytes, offset));
// Parse memory. // Parse memory.
ASSIGN_OR_RETURN(memory_, message.ReadCapability(2, caps)); uint64_t memory_ptr = bytes.At<uint64_t>(offset + header_size + (8 * 2));
set_memory(caps.At(memory_ptr));
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
glcr::Status OpenFileResponse::ParseFromBytesInternal(const yunq::MessageView& message) { glcr::Status OpenFileResponse::ParseFromBytesInternal(const glcr::ByteBuffer& bytes, uint64_t offset) {
RETURN_ERROR(message.CheckHeader()); RETURN_ERROR(yunq::CheckHeader(bytes, offset));
// Parse path. // Parse path.
ASSIGN_OR_RETURN(path_, message.ReadField<glcr::String>(0)); auto path_pointer = bytes.At<ExtPointer>(offset + header_size + (8 * 0));
set_path(bytes.StringAt(offset + path_pointer.offset, path_pointer.length));
// Parse size. // Parse size.
ASSIGN_OR_RETURN(size_, message.ReadField<uint64_t>(1)); set_size(bytes.At<uint64_t>(offset + header_size + (8 * 1)));
// Parse memory. // Parse memory.
// Skip Cap.
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
@ -152,20 +159,22 @@ uint64_t OpenFileResponse::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t of
return next_extension; return next_extension;
} }
glcr::Status GetDirectoryRequest::ParseFromBytes(const yunq::MessageView& message) { glcr::Status GetDirectoryRequest::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset) {
RETURN_ERROR(ParseFromBytesInternal(message)); RETURN_ERROR(ParseFromBytesInternal(bytes, offset));
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
glcr::Status GetDirectoryRequest::ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer& caps) { glcr::Status GetDirectoryRequest::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset, const glcr::CapBuffer& caps) {
RETURN_ERROR(ParseFromBytesInternal(message)); RETURN_ERROR(ParseFromBytesInternal(bytes, offset));
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
glcr::Status GetDirectoryRequest::ParseFromBytesInternal(const yunq::MessageView& message) { glcr::Status GetDirectoryRequest::ParseFromBytesInternal(const glcr::ByteBuffer& bytes, uint64_t offset) {
RETURN_ERROR(message.CheckHeader()); RETURN_ERROR(yunq::CheckHeader(bytes, offset));
// Parse path. // Parse path.
ASSIGN_OR_RETURN(path_, message.ReadField<glcr::String>(0)); auto path_pointer = bytes.At<ExtPointer>(offset + header_size + (8 * 0));
set_path(bytes.StringAt(offset + path_pointer.offset, path_pointer.length));
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
@ -212,20 +221,22 @@ uint64_t GetDirectoryRequest::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t
return next_extension; return next_extension;
} }
glcr::Status Directory::ParseFromBytes(const yunq::MessageView& message) { glcr::Status Directory::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset) {
RETURN_ERROR(ParseFromBytesInternal(message)); RETURN_ERROR(ParseFromBytesInternal(bytes, offset));
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
glcr::Status Directory::ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer& caps) { glcr::Status Directory::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset, const glcr::CapBuffer& caps) {
RETURN_ERROR(ParseFromBytesInternal(message)); RETURN_ERROR(ParseFromBytesInternal(bytes, offset));
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
glcr::Status Directory::ParseFromBytesInternal(const yunq::MessageView& message) { glcr::Status Directory::ParseFromBytesInternal(const glcr::ByteBuffer& bytes, uint64_t offset) {
RETURN_ERROR(message.CheckHeader()); RETURN_ERROR(yunq::CheckHeader(bytes, offset));
// Parse filenames. // Parse filenames.
ASSIGN_OR_RETURN(filenames_, message.ReadField<glcr::String>(0)); auto filenames_pointer = bytes.At<ExtPointer>(offset + header_size + (8 * 0));
set_filenames(bytes.StringAt(offset + filenames_pointer.offset, filenames_pointer.length));
return glcr::Status::Ok(); return glcr::Status::Ok();
} }

25
sys/victoriafalls/lib/victoriafalls/victoriafalls.yunq.h
View File

@ -6,7 +6,6 @@
#include <glacier/status/status.h> #include <glacier/status/status.h>
#include <glacier/container/vector.h> #include <glacier/container/vector.h>
#include <glacier/string/string.h> #include <glacier/string/string.h>
#include <yunq/message_view.h>
#include <ztypes.h> #include <ztypes.h>
@ -17,8 +16,8 @@ class OpenFileRequest {
OpenFileRequest(const OpenFileRequest&) = delete; OpenFileRequest(const OpenFileRequest&) = delete;
OpenFileRequest(OpenFileRequest&&) = delete; OpenFileRequest(OpenFileRequest&&) = delete;
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message); [[nodiscard]] glcr::Status ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset);
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer&); [[nodiscard]] glcr::Status ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset, const glcr::CapBuffer&);
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const; uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const;
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const; uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const;
const glcr::String& path() const { return path_; } const glcr::String& path() const { return path_; }
@ -28,7 +27,7 @@ class OpenFileRequest {
glcr::String path_; glcr::String path_;
// Parses everything except for caps. // Parses everything except for caps.
glcr::Status ParseFromBytesInternal(const yunq::MessageView& message); glcr::Status ParseFromBytesInternal(const glcr::ByteBuffer&, uint64_t offset);
}; };
class OpenFileResponse { class OpenFileResponse {
public: public:
@ -37,8 +36,8 @@ class OpenFileResponse {
OpenFileResponse(const OpenFileResponse&) = delete; OpenFileResponse(const OpenFileResponse&) = delete;
OpenFileResponse(OpenFileResponse&&) = delete; OpenFileResponse(OpenFileResponse&&) = delete;
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message); [[nodiscard]] glcr::Status ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset);
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer&); [[nodiscard]] glcr::Status ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset, const glcr::CapBuffer&);
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const; uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const;
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const; uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const;
const glcr::String& path() const { return path_; } const glcr::String& path() const { return path_; }
@ -54,7 +53,7 @@ class OpenFileResponse {
z_cap_t memory_; z_cap_t memory_;
// Parses everything except for caps. // Parses everything except for caps.
glcr::Status ParseFromBytesInternal(const yunq::MessageView& message); glcr::Status ParseFromBytesInternal(const glcr::ByteBuffer&, uint64_t offset);
}; };
class GetDirectoryRequest { class GetDirectoryRequest {
public: public:
@ -63,8 +62,8 @@ class GetDirectoryRequest {
GetDirectoryRequest(const GetDirectoryRequest&) = delete; GetDirectoryRequest(const GetDirectoryRequest&) = delete;
GetDirectoryRequest(GetDirectoryRequest&&) = delete; GetDirectoryRequest(GetDirectoryRequest&&) = delete;
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message); [[nodiscard]] glcr::Status ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset);
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer&); [[nodiscard]] glcr::Status ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset, const glcr::CapBuffer&);
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const; uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const;
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const; uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const;
const glcr::String& path() const { return path_; } const glcr::String& path() const { return path_; }
@ -74,7 +73,7 @@ class GetDirectoryRequest {
glcr::String path_; glcr::String path_;
// Parses everything except for caps. // Parses everything except for caps.
glcr::Status ParseFromBytesInternal(const yunq::MessageView& message); glcr::Status ParseFromBytesInternal(const glcr::ByteBuffer&, uint64_t offset);
}; };
class Directory { class Directory {
public: public:
@ -83,8 +82,8 @@ class Directory {
Directory(const Directory&) = delete; Directory(const Directory&) = delete;
Directory(Directory&&) = delete; Directory(Directory&&) = delete;
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message); [[nodiscard]] glcr::Status ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset);
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer&); [[nodiscard]] glcr::Status ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset, const glcr::CapBuffer&);
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const; uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const;
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const; uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const;
const glcr::String& filenames() const { return filenames_; } const glcr::String& filenames() const { return filenames_; }
@ -94,6 +93,6 @@ class Directory {
glcr::String filenames_; glcr::String filenames_;
// Parses everything except for caps. // Parses everything except for caps.
glcr::Status ParseFromBytesInternal(const yunq::MessageView& message); glcr::Status ParseFromBytesInternal(const glcr::ByteBuffer&, uint64_t offset);
}; };

6
sys/victoriafalls/lib/victoriafalls/victoriafalls.yunq.server.cpp
View File

@ -104,8 +104,7 @@ glcr::Status VFSServerBase::HandleRequest(const glcr::ByteBuffer& request,
OpenFileRequest yunq_request; OpenFileRequest yunq_request;
yunq::MessageView request_view(request, kHeaderSize); RETURN_ERROR(yunq_request.ParseFromBytes(request, kHeaderSize, req_caps));
RETURN_ERROR(yunq_request.ParseFromBytes(request_view, req_caps));
@ -125,8 +124,7 @@ glcr::Status VFSServerBase::HandleRequest(const glcr::ByteBuffer& request,
GetDirectoryRequest yunq_request; GetDirectoryRequest yunq_request;
yunq::MessageView request_view(request, kHeaderSize); RETURN_ERROR(yunq_request.ParseFromBytes(request, kHeaderSize, req_caps));
RETURN_ERROR(yunq_request.ParseFromBytes(request_view, req_caps));

21
sys/voyageurs/lib/voyageurs/voyageurs.yunq.cpp
View File

@ -1,7 +1,6 @@
// Generated file -- DO NOT MODIFY. // Generated file -- DO NOT MODIFY.
#include "voyageurs.yunq.h" #include "voyageurs.yunq.h"
#include <yunq/message_view.h>
#include <yunq/serialize.h> #include <yunq/serialize.h>
@ -15,23 +14,27 @@ struct ExtPointer {
}; };
} // namespace } // namespace
glcr::Status KeyboardListener::ParseFromBytes(const yunq::MessageView& message) { glcr::Status KeyboardListener::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset) {
RETURN_ERROR(ParseFromBytesInternal(message)); RETURN_ERROR(ParseFromBytesInternal(bytes, offset));
// Parse port_capability. // Parse port_capability.
ASSIGN_OR_RETURN(port_capability_, message.ReadCapability(0)); // FIXME: Implement in-buffer capabilities for inprocess serialization.
set_port_capability(0);
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
glcr::Status KeyboardListener::ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer& caps) { glcr::Status KeyboardListener::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset, const glcr::CapBuffer& caps) {
RETURN_ERROR(ParseFromBytesInternal(message)); RETURN_ERROR(ParseFromBytesInternal(bytes, offset));
// Parse port_capability. // Parse port_capability.
ASSIGN_OR_RETURN(port_capability_, message.ReadCapability(0, caps)); uint64_t port_capability_ptr = bytes.At<uint64_t>(offset + header_size + (8 * 0));
set_port_capability(caps.At(port_capability_ptr));
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
glcr::Status KeyboardListener::ParseFromBytesInternal(const yunq::MessageView& message) { glcr::Status KeyboardListener::ParseFromBytesInternal(const glcr::ByteBuffer& bytes, uint64_t offset) {
RETURN_ERROR(message.CheckHeader()); RETURN_ERROR(yunq::CheckHeader(bytes, offset));
// Parse port_capability. // Parse port_capability.
// Skip Cap.
return glcr::Status::Ok(); return glcr::Status::Ok();
} }

7
sys/voyageurs/lib/voyageurs/voyageurs.yunq.h
View File

@ -6,7 +6,6 @@
#include <glacier/status/status.h> #include <glacier/status/status.h>
#include <glacier/container/vector.h> #include <glacier/container/vector.h>
#include <glacier/string/string.h> #include <glacier/string/string.h>
#include <yunq/message_view.h>
#include <ztypes.h> #include <ztypes.h>
@ -17,8 +16,8 @@ class KeyboardListener {
KeyboardListener(const KeyboardListener&) = delete; KeyboardListener(const KeyboardListener&) = delete;
KeyboardListener(KeyboardListener&&) = delete; KeyboardListener(KeyboardListener&&) = delete;
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message); [[nodiscard]] glcr::Status ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset);
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer&); [[nodiscard]] glcr::Status ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset, const glcr::CapBuffer&);
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const; uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const;
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const; uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const;
const z_cap_t& port_capability() const { return port_capability_; } const z_cap_t& port_capability() const { return port_capability_; }
@ -28,6 +27,6 @@ class KeyboardListener {
z_cap_t port_capability_; z_cap_t port_capability_;
// Parses everything except for caps. // Parses everything except for caps.
glcr::Status ParseFromBytesInternal(const yunq::MessageView& message); glcr::Status ParseFromBytesInternal(const glcr::ByteBuffer&, uint64_t offset);
}; };

3
sys/voyageurs/lib/voyageurs/voyageurs.yunq.server.cpp
View File

@ -104,8 +104,7 @@ glcr::Status VoyageursServerBase::HandleRequest(const glcr::ByteBuffer& request,
KeyboardListener yunq_request; KeyboardListener yunq_request;
yunq::MessageView request_view(request, kHeaderSize); RETURN_ERROR(yunq_request.ParseFromBytes(request, kHeaderSize, req_caps));
RETURN_ERROR(yunq_request.ParseFromBytes(request_view, req_caps));

12
sys/yellowstone/lib/yellowstone/yellowstone.yunq.client.cpp
View File

@ -87,8 +87,7 @@ glcr::Status YellowstoneClient::GetEndpoint(const GetEndpointRequest& request, E
RET_ERR(buffer_.At<uint64_t>(8)); RET_ERR(buffer_.At<uint64_t>(8));
yunq::MessageView resp_view(buffer_, 16); RETURN_ERROR(response.ParseFromBytes(buffer_, 16, cap_buffer_));
RETURN_ERROR(response.ParseFromBytes(resp_view, cap_buffer_));
return glcr::OK; return glcr::OK;
@ -127,8 +126,7 @@ glcr::Status YellowstoneClient::GetAhciInfo(AhciInfo& response) {
RET_ERR(buffer_.At<uint64_t>(8)); RET_ERR(buffer_.At<uint64_t>(8));
yunq::MessageView resp_view(buffer_, 16); RETURN_ERROR(response.ParseFromBytes(buffer_, 16, cap_buffer_));
RETURN_ERROR(response.ParseFromBytes(resp_view, cap_buffer_));
return glcr::OK; return glcr::OK;
@ -167,8 +165,7 @@ glcr::Status YellowstoneClient::GetFramebufferInfo(FramebufferInfo& response) {
RET_ERR(buffer_.At<uint64_t>(8)); RET_ERR(buffer_.At<uint64_t>(8));
yunq::MessageView resp_view(buffer_, 16); RETURN_ERROR(response.ParseFromBytes(buffer_, 16, cap_buffer_));
RETURN_ERROR(response.ParseFromBytes(resp_view, cap_buffer_));
return glcr::OK; return glcr::OK;
@ -207,8 +204,7 @@ glcr::Status YellowstoneClient::GetDenali(DenaliInfo& response) {
RET_ERR(buffer_.At<uint64_t>(8)); RET_ERR(buffer_.At<uint64_t>(8));
yunq::MessageView resp_view(buffer_, 16); RETURN_ERROR(response.ParseFromBytes(buffer_, 16, cap_buffer_));
RETURN_ERROR(response.ParseFromBytes(resp_view, cap_buffer_));
return glcr::OK; return glcr::OK;

143
sys/yellowstone/lib/yellowstone/yellowstone.yunq.cpp
View File

@ -1,7 +1,6 @@
// Generated file -- DO NOT MODIFY. // Generated file -- DO NOT MODIFY.
#include "yellowstone.yunq.h" #include "yellowstone.yunq.h"
#include <yunq/message_view.h>
#include <yunq/serialize.h> #include <yunq/serialize.h>
@ -17,25 +16,31 @@ struct ExtPointer {
}; };
} // namespace } // namespace
glcr::Status RegisterEndpointRequest::ParseFromBytes(const yunq::MessageView& message) { glcr::Status RegisterEndpointRequest::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset) {
RETURN_ERROR(ParseFromBytesInternal(message)); RETURN_ERROR(ParseFromBytesInternal(bytes, offset));
// Parse endpoint_capability. // Parse endpoint_capability.
ASSIGN_OR_RETURN(endpoint_capability_, message.ReadCapability(1)); // FIXME: Implement in-buffer capabilities for inprocess serialization.
set_endpoint_capability(0);
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
glcr::Status RegisterEndpointRequest::ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer& caps) { glcr::Status RegisterEndpointRequest::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset, const glcr::CapBuffer& caps) {
RETURN_ERROR(ParseFromBytesInternal(message)); RETURN_ERROR(ParseFromBytesInternal(bytes, offset));
// Parse endpoint_capability. // Parse endpoint_capability.
ASSIGN_OR_RETURN(endpoint_capability_, message.ReadCapability(1, caps)); uint64_t endpoint_capability_ptr = bytes.At<uint64_t>(offset + header_size + (8 * 1));
set_endpoint_capability(caps.At(endpoint_capability_ptr));
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
glcr::Status RegisterEndpointRequest::ParseFromBytesInternal(const yunq::MessageView& message) { glcr::Status RegisterEndpointRequest::ParseFromBytesInternal(const glcr::ByteBuffer& bytes, uint64_t offset) {
RETURN_ERROR(message.CheckHeader()); RETURN_ERROR(yunq::CheckHeader(bytes, offset));
// Parse endpoint_name. // Parse endpoint_name.
ASSIGN_OR_RETURN(endpoint_name_, message.ReadField<glcr::String>(0)); auto endpoint_name_pointer = bytes.At<ExtPointer>(offset + header_size + (8 * 0));
set_endpoint_name(bytes.StringAt(offset + endpoint_name_pointer.offset, endpoint_name_pointer.length));
// Parse endpoint_capability. // Parse endpoint_capability.
// Skip Cap.
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
@ -88,20 +93,22 @@ uint64_t RegisterEndpointRequest::SerializeToBytes(glcr::ByteBuffer& bytes, uint
return next_extension; return next_extension;
} }
glcr::Status GetEndpointRequest::ParseFromBytes(const yunq::MessageView& message) { glcr::Status GetEndpointRequest::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset) {
RETURN_ERROR(ParseFromBytesInternal(message)); RETURN_ERROR(ParseFromBytesInternal(bytes, offset));
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
glcr::Status GetEndpointRequest::ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer& caps) { glcr::Status GetEndpointRequest::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset, const glcr::CapBuffer& caps) {
RETURN_ERROR(ParseFromBytesInternal(message)); RETURN_ERROR(ParseFromBytesInternal(bytes, offset));
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
glcr::Status GetEndpointRequest::ParseFromBytesInternal(const yunq::MessageView& message) { glcr::Status GetEndpointRequest::ParseFromBytesInternal(const glcr::ByteBuffer& bytes, uint64_t offset) {
RETURN_ERROR(message.CheckHeader()); RETURN_ERROR(yunq::CheckHeader(bytes, offset));
// Parse endpoint_name. // Parse endpoint_name.
ASSIGN_OR_RETURN(endpoint_name_, message.ReadField<glcr::String>(0)); auto endpoint_name_pointer = bytes.At<ExtPointer>(offset + header_size + (8 * 0));
set_endpoint_name(bytes.StringAt(offset + endpoint_name_pointer.offset, endpoint_name_pointer.length));
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
@ -148,23 +155,27 @@ uint64_t GetEndpointRequest::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t
return next_extension; return next_extension;
} }
glcr::Status Endpoint::ParseFromBytes(const yunq::MessageView& message) { glcr::Status Endpoint::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset) {
RETURN_ERROR(ParseFromBytesInternal(message)); RETURN_ERROR(ParseFromBytesInternal(bytes, offset));
// Parse endpoint. // Parse endpoint.
ASSIGN_OR_RETURN(endpoint_, message.ReadCapability(0)); // FIXME: Implement in-buffer capabilities for inprocess serialization.
set_endpoint(0);
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
glcr::Status Endpoint::ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer& caps) { glcr::Status Endpoint::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset, const glcr::CapBuffer& caps) {
RETURN_ERROR(ParseFromBytesInternal(message)); RETURN_ERROR(ParseFromBytesInternal(bytes, offset));
// Parse endpoint. // Parse endpoint.
ASSIGN_OR_RETURN(endpoint_, message.ReadCapability(0, caps)); uint64_t endpoint_ptr = bytes.At<uint64_t>(offset + header_size + (8 * 0));
set_endpoint(caps.At(endpoint_ptr));
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
glcr::Status Endpoint::ParseFromBytesInternal(const yunq::MessageView& message) { glcr::Status Endpoint::ParseFromBytesInternal(const glcr::ByteBuffer& bytes, uint64_t offset) {
RETURN_ERROR(message.CheckHeader()); RETURN_ERROR(yunq::CheckHeader(bytes, offset));
// Parse endpoint. // Parse endpoint.
// Skip Cap.
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
@ -195,25 +206,29 @@ uint64_t Endpoint::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t offset, gl
return next_extension; return next_extension;
} }
glcr::Status AhciInfo::ParseFromBytes(const yunq::MessageView& message) { glcr::Status AhciInfo::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset) {
RETURN_ERROR(ParseFromBytesInternal(message)); RETURN_ERROR(ParseFromBytesInternal(bytes, offset));
// Parse ahci_region. // Parse ahci_region.
ASSIGN_OR_RETURN(ahci_region_, message.ReadCapability(0)); // FIXME: Implement in-buffer capabilities for inprocess serialization.
set_ahci_region(0);
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
glcr::Status AhciInfo::ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer& caps) { glcr::Status AhciInfo::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset, const glcr::CapBuffer& caps) {
RETURN_ERROR(ParseFromBytesInternal(message)); RETURN_ERROR(ParseFromBytesInternal(bytes, offset));
// Parse ahci_region. // Parse ahci_region.
ASSIGN_OR_RETURN(ahci_region_, message.ReadCapability(0, caps)); uint64_t ahci_region_ptr = bytes.At<uint64_t>(offset + header_size + (8 * 0));
set_ahci_region(caps.At(ahci_region_ptr));
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
glcr::Status AhciInfo::ParseFromBytesInternal(const yunq::MessageView& message) { glcr::Status AhciInfo::ParseFromBytesInternal(const glcr::ByteBuffer& bytes, uint64_t offset) {
RETURN_ERROR(message.CheckHeader()); RETURN_ERROR(yunq::CheckHeader(bytes, offset));
// Parse ahci_region. // Parse ahci_region.
// Skip Cap.
// Parse region_length. // Parse region_length.
ASSIGN_OR_RETURN(region_length_, message.ReadField<uint64_t>(1)); set_region_length(bytes.At<uint64_t>(offset + header_size + (8 * 1)));
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
@ -248,42 +263,42 @@ uint64_t AhciInfo::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t offset, gl
return next_extension; return next_extension;
} }
glcr::Status FramebufferInfo::ParseFromBytes(const yunq::MessageView& message) { glcr::Status FramebufferInfo::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset) {
RETURN_ERROR(ParseFromBytesInternal(message)); RETURN_ERROR(ParseFromBytesInternal(bytes, offset));
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
glcr::Status FramebufferInfo::ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer& caps) { glcr::Status FramebufferInfo::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset, const glcr::CapBuffer& caps) {
RETURN_ERROR(ParseFromBytesInternal(message)); RETURN_ERROR(ParseFromBytesInternal(bytes, offset));
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
glcr::Status FramebufferInfo::ParseFromBytesInternal(const yunq::MessageView& message) { glcr::Status FramebufferInfo::ParseFromBytesInternal(const glcr::ByteBuffer& bytes, uint64_t offset) {
RETURN_ERROR(message.CheckHeader()); RETURN_ERROR(yunq::CheckHeader(bytes, offset));
// Parse address_phys. // Parse address_phys.
ASSIGN_OR_RETURN(address_phys_, message.ReadField<uint64_t>(0)); set_address_phys(bytes.At<uint64_t>(offset + header_size + (8 * 0)));
// Parse width. // Parse width.
ASSIGN_OR_RETURN(width_, message.ReadField<uint64_t>(1)); set_width(bytes.At<uint64_t>(offset + header_size + (8 * 1)));
// Parse height. // Parse height.
ASSIGN_OR_RETURN(height_, message.ReadField<uint64_t>(2)); set_height(bytes.At<uint64_t>(offset + header_size + (8 * 2)));
// Parse pitch. // Parse pitch.
ASSIGN_OR_RETURN(pitch_, message.ReadField<uint64_t>(3)); set_pitch(bytes.At<uint64_t>(offset + header_size + (8 * 3)));
// Parse bpp. // Parse bpp.
ASSIGN_OR_RETURN(bpp_, message.ReadField<uint64_t>(4)); set_bpp(bytes.At<uint64_t>(offset + header_size + (8 * 4)));
// Parse memory_model. // Parse memory_model.
ASSIGN_OR_RETURN(memory_model_, message.ReadField<uint64_t>(5)); set_memory_model(bytes.At<uint64_t>(offset + header_size + (8 * 5)));
// Parse red_mask_size. // Parse red_mask_size.
ASSIGN_OR_RETURN(red_mask_size_, message.ReadField<uint64_t>(6)); set_red_mask_size(bytes.At<uint64_t>(offset + header_size + (8 * 6)));
// Parse red_mask_shift. // Parse red_mask_shift.
ASSIGN_OR_RETURN(red_mask_shift_, message.ReadField<uint64_t>(7)); set_red_mask_shift(bytes.At<uint64_t>(offset + header_size + (8 * 7)));
// Parse green_mask_size. // Parse green_mask_size.
ASSIGN_OR_RETURN(green_mask_size_, message.ReadField<uint64_t>(8)); set_green_mask_size(bytes.At<uint64_t>(offset + header_size + (8 * 8)));
// Parse green_mask_shift. // Parse green_mask_shift.
ASSIGN_OR_RETURN(green_mask_shift_, message.ReadField<uint64_t>(9)); set_green_mask_shift(bytes.At<uint64_t>(offset + header_size + (8 * 9)));
// Parse blue_mask_size. // Parse blue_mask_size.
ASSIGN_OR_RETURN(blue_mask_size_, message.ReadField<uint64_t>(10)); set_blue_mask_size(bytes.At<uint64_t>(offset + header_size + (8 * 10)));
// Parse blue_mask_shift. // Parse blue_mask_shift.
ASSIGN_OR_RETURN(blue_mask_shift_, message.ReadField<uint64_t>(11)); set_blue_mask_shift(bytes.At<uint64_t>(offset + header_size + (8 * 11)));
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
@ -356,27 +371,31 @@ uint64_t FramebufferInfo::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t off
return next_extension; return next_extension;
} }
glcr::Status DenaliInfo::ParseFromBytes(const yunq::MessageView& message) { glcr::Status DenaliInfo::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset) {
RETURN_ERROR(ParseFromBytesInternal(message)); RETURN_ERROR(ParseFromBytesInternal(bytes, offset));
// Parse denali_endpoint. // Parse denali_endpoint.
ASSIGN_OR_RETURN(denali_endpoint_, message.ReadCapability(0)); // FIXME: Implement in-buffer capabilities for inprocess serialization.
set_denali_endpoint(0);
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
glcr::Status DenaliInfo::ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer& caps) { glcr::Status DenaliInfo::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset, const glcr::CapBuffer& caps) {
RETURN_ERROR(ParseFromBytesInternal(message)); RETURN_ERROR(ParseFromBytesInternal(bytes, offset));
// Parse denali_endpoint. // Parse denali_endpoint.
ASSIGN_OR_RETURN(denali_endpoint_, message.ReadCapability(0, caps)); uint64_t denali_endpoint_ptr = bytes.At<uint64_t>(offset + header_size + (8 * 0));
set_denali_endpoint(caps.At(denali_endpoint_ptr));
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
glcr::Status DenaliInfo::ParseFromBytesInternal(const yunq::MessageView& message) { glcr::Status DenaliInfo::ParseFromBytesInternal(const glcr::ByteBuffer& bytes, uint64_t offset) {
RETURN_ERROR(message.CheckHeader()); RETURN_ERROR(yunq::CheckHeader(bytes, offset));
// Parse denali_endpoint. // Parse denali_endpoint.
// Skip Cap.
// Parse device_id. // Parse device_id.
ASSIGN_OR_RETURN(device_id_, message.ReadField<uint64_t>(1)); set_device_id(bytes.At<uint64_t>(offset + header_size + (8 * 1)));
// Parse lba_offset. // Parse lba_offset.
ASSIGN_OR_RETURN(lba_offset_, message.ReadField<uint64_t>(2)); set_lba_offset(bytes.At<uint64_t>(offset + header_size + (8 * 2)));
return glcr::Status::Ok(); return glcr::Status::Ok();
} }

37
sys/yellowstone/lib/yellowstone/yellowstone.yunq.h
View File

@ -6,7 +6,6 @@
#include <glacier/status/status.h> #include <glacier/status/status.h>
#include <glacier/container/vector.h> #include <glacier/container/vector.h>
#include <glacier/string/string.h> #include <glacier/string/string.h>
#include <yunq/message_view.h>
#include <ztypes.h> #include <ztypes.h>
@ -19,8 +18,8 @@ class RegisterEndpointRequest {
RegisterEndpointRequest(const RegisterEndpointRequest&) = delete; RegisterEndpointRequest(const RegisterEndpointRequest&) = delete;
RegisterEndpointRequest(RegisterEndpointRequest&&) = delete; RegisterEndpointRequest(RegisterEndpointRequest&&) = delete;
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message); [[nodiscard]] glcr::Status ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset);
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer&); [[nodiscard]] glcr::Status ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset, const glcr::CapBuffer&);
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const; uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const;
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const; uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const;
const glcr::String& endpoint_name() const { return endpoint_name_; } const glcr::String& endpoint_name() const { return endpoint_name_; }
@ -33,7 +32,7 @@ class RegisterEndpointRequest {
z_cap_t endpoint_capability_; z_cap_t endpoint_capability_;
// Parses everything except for caps. // Parses everything except for caps.
glcr::Status ParseFromBytesInternal(const yunq::MessageView& message); glcr::Status ParseFromBytesInternal(const glcr::ByteBuffer&, uint64_t offset);
}; };
class GetEndpointRequest { class GetEndpointRequest {
public: public:
@ -42,8 +41,8 @@ class GetEndpointRequest {
GetEndpointRequest(const GetEndpointRequest&) = delete; GetEndpointRequest(const GetEndpointRequest&) = delete;
GetEndpointRequest(GetEndpointRequest&&) = delete; GetEndpointRequest(GetEndpointRequest&&) = delete;
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message); [[nodiscard]] glcr::Status ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset);
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer&); [[nodiscard]] glcr::Status ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset, const glcr::CapBuffer&);
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const; uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const;
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const; uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const;
const glcr::String& endpoint_name() const { return endpoint_name_; } const glcr::String& endpoint_name() const { return endpoint_name_; }
@ -53,7 +52,7 @@ class GetEndpointRequest {
glcr::String endpoint_name_; glcr::String endpoint_name_;
// Parses everything except for caps. // Parses everything except for caps.
glcr::Status ParseFromBytesInternal(const yunq::MessageView& message); glcr::Status ParseFromBytesInternal(const glcr::ByteBuffer&, uint64_t offset);
}; };
class Endpoint { class Endpoint {
public: public:
@ -62,8 +61,8 @@ class Endpoint {
Endpoint(const Endpoint&) = delete; Endpoint(const Endpoint&) = delete;
Endpoint(Endpoint&&) = delete; Endpoint(Endpoint&&) = delete;
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message); [[nodiscard]] glcr::Status ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset);
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer&); [[nodiscard]] glcr::Status ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset, const glcr::CapBuffer&);
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const; uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const;
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const; uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const;
const z_cap_t& endpoint() const { return endpoint_; } const z_cap_t& endpoint() const { return endpoint_; }
@ -73,7 +72,7 @@ class Endpoint {
z_cap_t endpoint_; z_cap_t endpoint_;
// Parses everything except for caps. // Parses everything except for caps.
glcr::Status ParseFromBytesInternal(const yunq::MessageView& message); glcr::Status ParseFromBytesInternal(const glcr::ByteBuffer&, uint64_t offset);
}; };
class AhciInfo { class AhciInfo {
public: public:
@ -82,8 +81,8 @@ class AhciInfo {
AhciInfo(const AhciInfo&) = delete; AhciInfo(const AhciInfo&) = delete;
AhciInfo(AhciInfo&&) = delete; AhciInfo(AhciInfo&&) = delete;
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message); [[nodiscard]] glcr::Status ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset);
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer&); [[nodiscard]] glcr::Status ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset, const glcr::CapBuffer&);
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const; uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const;
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const; uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const;
const z_cap_t& ahci_region() const { return ahci_region_; } const z_cap_t& ahci_region() const { return ahci_region_; }
@ -96,7 +95,7 @@ class AhciInfo {
uint64_t region_length_; uint64_t region_length_;
// Parses everything except for caps. // Parses everything except for caps.
glcr::Status ParseFromBytesInternal(const yunq::MessageView& message); glcr::Status ParseFromBytesInternal(const glcr::ByteBuffer&, uint64_t offset);
}; };
class FramebufferInfo { class FramebufferInfo {
public: public:
@ -105,8 +104,8 @@ class FramebufferInfo {
FramebufferInfo(const FramebufferInfo&) = delete; FramebufferInfo(const FramebufferInfo&) = delete;
FramebufferInfo(FramebufferInfo&&) = delete; FramebufferInfo(FramebufferInfo&&) = delete;
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message); [[nodiscard]] glcr::Status ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset);
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer&); [[nodiscard]] glcr::Status ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset, const glcr::CapBuffer&);
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const; uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const;
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const; uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const;
const uint64_t& address_phys() const { return address_phys_; } const uint64_t& address_phys() const { return address_phys_; }
@ -149,7 +148,7 @@ class FramebufferInfo {
uint64_t blue_mask_shift_; uint64_t blue_mask_shift_;
// Parses everything except for caps. // Parses everything except for caps.
glcr::Status ParseFromBytesInternal(const yunq::MessageView& message); glcr::Status ParseFromBytesInternal(const glcr::ByteBuffer&, uint64_t offset);
}; };
class DenaliInfo { class DenaliInfo {
public: public:
@ -158,8 +157,8 @@ class DenaliInfo {
DenaliInfo(const DenaliInfo&) = delete; DenaliInfo(const DenaliInfo&) = delete;
DenaliInfo(DenaliInfo&&) = delete; DenaliInfo(DenaliInfo&&) = delete;
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message); [[nodiscard]] glcr::Status ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset);
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer&); [[nodiscard]] glcr::Status ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset, const glcr::CapBuffer&);
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const; uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const;
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const; uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const;
const z_cap_t& denali_endpoint() const { return denali_endpoint_; } const z_cap_t& denali_endpoint() const { return denali_endpoint_; }
@ -175,7 +174,7 @@ class DenaliInfo {
uint64_t lba_offset_; uint64_t lba_offset_;
// Parses everything except for caps. // Parses everything except for caps.
glcr::Status ParseFromBytesInternal(const yunq::MessageView& message); glcr::Status ParseFromBytesInternal(const glcr::ByteBuffer&, uint64_t offset);
}; };

6
sys/yellowstone/lib/yellowstone/yellowstone.yunq.server.cpp
View File

@ -106,8 +106,7 @@ glcr::Status YellowstoneServerBase::HandleRequest(const glcr::ByteBuffer& reques
RegisterEndpointRequest yunq_request; RegisterEndpointRequest yunq_request;
yunq::MessageView request_view(request, kHeaderSize); RETURN_ERROR(yunq_request.ParseFromBytes(request, kHeaderSize, req_caps));
RETURN_ERROR(yunq_request.ParseFromBytes(request_view, req_caps));
@ -125,8 +124,7 @@ glcr::Status YellowstoneServerBase::HandleRequest(const glcr::ByteBuffer& reques
GetEndpointRequest yunq_request; GetEndpointRequest yunq_request;
yunq::MessageView request_view(request, kHeaderSize); RETURN_ERROR(yunq_request.ParseFromBytes(request, kHeaderSize, req_caps));
RETURN_ERROR(yunq_request.ParseFromBytes(request_view, req_caps));

3
yunq/client.cpp.jinja
View File

@ -56,8 +56,7 @@ glcr::Status {{interface.name}}Client::{{method.name}}(const {{method.request}}&
RET_ERR(buffer_.At<uint64_t>(8)); RET_ERR(buffer_.At<uint64_t>(8));
{% if method.response != None %} {% if method.response != None %}
yunq::MessageView resp_view(buffer_, 16); RETURN_ERROR(response.ParseFromBytes(buffer_, 16, cap_buffer_));
RETURN_ERROR(response.ParseFromBytes(resp_view, cap_buffer_));
{% endif %} {% endif %}
return glcr::OK; return glcr::OK;

57
yunq/message.cpp.jinja
View File

@ -1,7 +1,6 @@
// Generated file -- DO NOT MODIFY. // Generated file -- DO NOT MODIFY.
#include "{{file}}.h" #include "{{file}}.h"
#include <yunq/message_view.h>
#include <yunq/serialize.h> #include <yunq/serialize.h>
{% if package != None %} {% if package != None %}
@ -19,54 +18,62 @@ struct ExtPointer {
} // namespace } // namespace
{%- for message in messages %} {%- for message in messages %}
glcr::Status {{message.name}}::ParseFromBytes(const yunq::MessageView& message) { glcr::Status {{message.name}}::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset) {
RETURN_ERROR(ParseFromBytesInternal(message)); RETURN_ERROR(ParseFromBytesInternal(bytes, offset));
{%- for field in message.fields %} {%- for field in message.fields %}
{%- if field.type == Type.CAPABILITY %} {%- if field.type == Type.CAPABILITY %}
{%- if not field.repeated %}
// Parse {{field.name}}. // Parse {{field.name}}.
ASSIGN_OR_RETURN({{field.name}}_, message.ReadCapability({{loop.index0}})); // FIXME: Implement in-buffer capabilities for inprocess serialization.
{%- else %} set_{{field.name}}(0);
// Parse {{field.name}}.
ASSIGN_OR_RETURN({{field.name}}_, message.ReadRepeatedCapability({{loop.index0}}));
{%- endif %}
{%- endif %} {%- endif %}
{%- endfor %} {%- endfor %}
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
glcr::Status {{message.name}}::ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer& caps) { glcr::Status {{message.name}}::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset, const glcr::CapBuffer& caps) {
RETURN_ERROR(ParseFromBytesInternal(message)); RETURN_ERROR(ParseFromBytesInternal(bytes, offset));
{%- for field in message.fields %} {%- for field in message.fields %}
{%- if field.type == Type.CAPABILITY %} {%- if field.type == Type.CAPABILITY %}
{%- if not field.repeated %}
// Parse {{field.name}}. // Parse {{field.name}}.
ASSIGN_OR_RETURN({{field.name}}_, message.ReadCapability({{loop.index0}}, caps)); uint64_t {{field.name}}_ptr = bytes.At<uint64_t>(offset + header_size + (8 * {{loop.index0}}));
{%- else %}
// Parse {{field.name}}. set_{{field.name}}(caps.At({{field.name}}_ptr));
ASSIGN_OR_RETURN({{field.name}}_, message.ReadRepeatedCapability({{loop.index0}}, caps));
{%- endif %}
{%- endif %} {%- endif %}
{%- endfor %} {%- endfor %}
return glcr::Status::Ok(); return glcr::Status::Ok();
} }
glcr::Status {{message.name}}::ParseFromBytesInternal(const yunq::MessageView& message) { glcr::Status {{message.name}}::ParseFromBytesInternal(const glcr::ByteBuffer& bytes, uint64_t offset) {
RETURN_ERROR(message.CheckHeader()); RETURN_ERROR(yunq::CheckHeader(bytes, offset));
{%- for field in message.fields %} {%- for field in message.fields %}
// Parse {{field.name}}. // Parse {{field.name}}.
{%- if field.type != Type.CAPABILITY %}
{%- if not field.repeated %} {%- if not field.repeated %}
ASSIGN_OR_RETURN({{field.name}}_, message.ReadField<{{field.cpp_type()}}>({{loop.index0}})); {%- if field.type == Type.U64 %}
set_{{field.name}}(bytes.At<uint64_t>(offset + header_size + (8 * {{loop.index0}})));
{%- elif field.type == Type.I64 %}
set_{{field.name}}(bytes.At<int64_t>(offset + header_size + (8 * {{loop.index0}})));
{%- elif field.type == Type.STRING %}
auto {{field.name}}_pointer = bytes.At<ExtPointer>(offset + header_size + (8 * {{loop.index0}}));
set_{{field.name}}(bytes.StringAt(offset + {{field.name}}_pointer.offset, {{field.name}}_pointer.length));
{%- elif field.type == Type.CAPABILITY %}
// Skip Cap.
{%- else %} {%- else %}
ASSIGN_OR_RETURN({{field.name}}_, message.ReadRepeated<{{field.cpp_type()}}>({{loop.index0}})); // TODO: Unimplemented parsing {{field.type}}
{% endif %}
{%- endif %} {%- endif %}
{%- else %}
auto {{field.name}}_pointer = bytes.At<ExtPointer>(offset + header_size + (8 * {{loop.index0}}));
{{field.name}}_.Resize({{field.name}}_pointer.length / sizeof({{field.cpp_type()}}));
for (uint64_t i = offset + {{field.name}}_pointer.offset;
i < offset + {{field.name}}_pointer.offset + {{field.name}}_pointer.length;
i += sizeof({{field.cpp_type()}})) {
{{field.name}}_.PushBack(bytes.At<{{field.cpp_type()}}>(i));
}
{% endif %}
{%- endfor %} {%- endfor %}
return glcr::Status::Ok(); return glcr::Status::Ok();

7
yunq/message.h.jinja
View File

@ -6,7 +6,6 @@
#include <glacier/status/status.h> #include <glacier/status/status.h>
#include <glacier/container/vector.h> #include <glacier/container/vector.h>
#include <glacier/string/string.h> #include <glacier/string/string.h>
#include <yunq/message_view.h>
#include <ztypes.h> #include <ztypes.h>
{% if package != None %} {% if package != None %}
@ -21,8 +20,8 @@ class {{message.name}} {
{{message.name}}(const {{message.name}}&) = delete; {{message.name}}(const {{message.name}}&) = delete;
{{message.name}}({{message.name}}&&) = delete; {{message.name}}({{message.name}}&&) = delete;
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message); [[nodiscard]] glcr::Status ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset);
[[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer&); [[nodiscard]] glcr::Status ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset, const glcr::CapBuffer&);
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const; uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const;
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const; uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const;
@ -46,7 +45,7 @@ class {{message.name}} {
{%- endfor %} {%- endfor %}
// Parses everything except for caps. // Parses everything except for caps.
glcr::Status ParseFromBytesInternal(const yunq::MessageView& message); glcr::Status ParseFromBytesInternal(const glcr::ByteBuffer&, uint64_t offset);
}; };
{%- endfor %} {%- endfor %}

3
yunq/server.cpp.jinja
View File

@ -107,8 +107,7 @@ glcr::Status {{interface.name}}ServerBase::HandleRequest(const glcr::ByteBuffer&
{% if method.request != None %} {% if method.request != None %}
{{method.request}} yunq_request; {{method.request}} yunq_request;
yunq::MessageView request_view(request, kHeaderSize); RETURN_ERROR(yunq_request.ParseFromBytes(request, kHeaderSize, req_caps));
RETURN_ERROR(yunq_request.ParseFromBytes(request_view, req_caps));
{% endif %} {% endif %}
{% if method.response != None %} {% if method.response != None %}

9
zion/loader/init_loader.cpp
View File

@ -90,8 +90,7 @@ void DumpModules() {
dbgln("[boot] Dumping bootloader modules."); dbgln("[boot] Dumping bootloader modules.");
for (uint64_t i = 0; i < resp.module_count; i++) { for (uint64_t i = 0; i < resp.module_count; i++) {
const limine_file& file = *resp.modules[i]; const limine_file& file = *resp.modules[i];
dbgln(" {},{x},{x}", glcr::String(file.path), (uint64_t)file.address, dbgln(" {},{x},{}", file.path, file.address, file.size);
file.size);
} }
#endif #endif
} }
@ -112,8 +111,6 @@ void WriteInitProgram(glcr::RefPtr<Port> port, glcr::String name, uint64_t id) {
const limine_file& prog = GetInitProgram(name); const limine_file& prog = GetInitProgram(name);
glcr::RefPtr<VariableMemoryObject> prog_vmmo = glcr::RefPtr<VariableMemoryObject> prog_vmmo =
glcr::MakeRefCounted<VariableMemoryObject>(prog.size); glcr::MakeRefCounted<VariableMemoryObject>(prog.size);
// TODO: These seem to be page aligned we should just construct an object
// around them.
prog_vmmo->CopyBytesToObject(reinterpret_cast<uint64_t>(prog.address), prog_vmmo->CopyBytesToObject(reinterpret_cast<uint64_t>(prog.address),
prog.size); prog.size);
port->WriteKernel(id, MakeRefCounted<Capability>(prog_vmmo)); port->WriteKernel(id, MakeRefCounted<Capability>(prog_vmmo));
@ -124,10 +121,6 @@ glcr::ErrorCode WritePciVmmo(glcr::RefPtr<Port> port, uint64_t id) {
auto vmmo = auto vmmo =
glcr::MakeRefCounted<ViewMemoryObject>(config.base, config.offset); glcr::MakeRefCounted<ViewMemoryObject>(config.base, config.offset);
#if K_INIT_DEBUG
dbgln("PCI Configuration found at: {x}:{x}", config.base, config.offset);
#endif
port->WriteKernel(id, MakeRefCounted<Capability>(vmmo)); port->WriteKernel(id, MakeRefCounted<Capability>(vmmo));
return glcr::OK; return glcr::OK;