lib/CMakeLists.txt

@@ -1,3 +1,4 @@
 add_subdirectory(glacier)
 add_subdirectory(libc)
+add_subdirectory(libcxx)
 add_subdirectory(mammoth)

lib/libcxx/CMakeLists.txt

@@ -0,0 +1,15 @@
+add_library(cxx STATIC
+  src/new.cpp
+  )
+
+target_include_directories(cxx
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
+  PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
+
+target_link_libraries(cxx
+  c
+  zion_lib
+  )
+
+set_target_properties(cxx PROPERTIES
+  COMPILE_FLAGS "${CMAKE_CXX_FLAGS} ${BASE_COMPILE_FLAGS}")

lib/libcxx/include/cstddef

@@ -0,0 +1,34 @@
+/* vim: syntax=cpp */
+
+#pragma once
+
+#include "cstdint"
+
+namespace std {
+  using ptrdiff_t = uint64_t;
+  using size_t = uint64_t;
+  // FIXME: I don't understand what this does.
+  using max_align_t = uint64_t;
+  using nullptr_t = decltype(nullptr);
+ 
+  enum class byte : unsigned char {};
+ 
+  // byte type operations
+  template<class IntType>
+    constexpr byte& operator<<=(byte& b, IntType shift) noexcept;
+  template<class IntType>
+    constexpr byte operator<<(byte b, IntType shift) noexcept;
+  template<class IntType>
+    constexpr byte& operator>>=(byte& b, IntType shift) noexcept;
+  template<class IntType>
+    constexpr byte operator>>(byte b, IntType shift) noexcept;
+  constexpr byte& operator|=(byte& l, byte r) noexcept;
+  constexpr byte operator|(byte l, byte r) noexcept;
+  constexpr byte& operator&=(byte& l, byte r) noexcept;
+  constexpr byte operator&(byte l, byte r) noexcept;
+  constexpr byte& operator^=(byte& l, byte r) noexcept;
+  constexpr byte operator^(byte l, byte r) noexcept;
+  constexpr byte operator~(byte b) noexcept;
+  template<class IntType>
+    constexpr IntType to_integer(byte b) noexcept;
+}

lib/libcxx/include/cstdint

@@ -0,0 +1,5 @@
+/* vim: syntax=cpp */
+
+#pragma once
+
+#include <stdint.h>

lib/libcxx/include/new

@@ -0,0 +1,69 @@
+/* vim: syntax=cpp */
+
+#pragma once
+
+#include "cstddef"
+
+namespace std {
+  // storage allocation errors
+  class bad_alloc;
+  class bad_array_new_length;
+ 
+  struct destroying_delete_t {
+    explicit destroying_delete_t() = default;
+  };
+  inline constexpr destroying_delete_t destroying_delete{};
+ 
+  // global operator new control
+  enum class align_val_t : size_t {};
+ 
+  struct nothrow_t { explicit nothrow_t() = default; };
+  extern const nothrow_t nothrow;
+ 
+  using new_handler = void (*)();
+  new_handler get_new_handler() noexcept;
+  new_handler set_new_handler(new_handler new_p) noexcept;
+ 
+  // pointer optimization barrier
+  template<class T> [[nodiscard]] constexpr T* launder(T* p) noexcept;
+ 
+  // hardware interference size
+  // inline constexpr size_t hardware_destructive_interference_size =
+  //   /* implementation-defined */;
+  // inline constexpr size_t hardware_constructive_interference_size =
+  //   /* implementation-defined */;
+}
+ 
+// storage allocation and deallocation
+[[nodiscard]] void* operator new(std::size_t size);
+[[nodiscard]] void* operator new(std::size_t size, std::align_val_t alignment);
+[[nodiscard]] void* operator new(std::size_t size, const std::nothrow_t&) noexcept;
+[[nodiscard]] void* operator new(std::size_t size, std::align_val_t alignment,
+                                 const std::nothrow_t&) noexcept;
+ 
+void  operator delete(void* ptr) noexcept;
+void  operator delete(void* ptr, std::size_t size) noexcept;
+void  operator delete(void* ptr, std::align_val_t alignment) noexcept;
+void  operator delete(void* ptr, std::size_t size, std::align_val_t alignment) noexcept;
+void  operator delete(void* ptr, const std::nothrow_t&) noexcept;
+void  operator delete(void* ptr, std::align_val_t alignment,
+                      const std::nothrow_t&) noexcept;
+ 
+[[nodiscard]] void* operator new[](std::size_t size);
+[[nodiscard]] void* operator new[](std::size_t size, std::align_val_t alignment);
+[[nodiscard]] void* operator new[](std::size_t size, const std::nothrow_t&) noexcept;
+[[nodiscard]] void* operator new[](std::size_t size, std::align_val_t alignment,
+                                   const std::nothrow_t&) noexcept;
+ 
+void  operator delete[](void* ptr) noexcept;
+void  operator delete[](void* ptr, std::size_t size) noexcept;
+void  operator delete[](void* ptr, std::align_val_t alignment) noexcept;
+void  operator delete[](void* ptr, std::size_t size, std::align_val_t alignment) noexcept;
+void  operator delete[](void* ptr, const std::nothrow_t&) noexcept;
+void  operator delete[](void* ptr, std::align_val_t alignment,
+                        const std::nothrow_t&) noexcept;
+ 
+[[nodiscard]] void* operator new  (std::size_t size, void* ptr) noexcept;
+[[nodiscard]] void* operator new[](std::size_t size, void* ptr) noexcept;
+void  operator delete  (void* ptr, void*) noexcept;
+void  operator delete[](void* ptr, void*) noexcept;

lib/libcxx/src/new.cpp

@@ -0,0 +1,8 @@
+#include "new"
+
+#include <stdlib.h>
+
+[[nodiscard]] void* operator new(std::size_t size) { return malloc(size); }
+[[nodiscard]] void* operator new[](std::size_t size) { return malloc(size); }
+
+void operator delete(void*, std::size_t) {}

lib/mammoth/CMakeLists.txt

@@ -5,10 +5,8 @@ add_library(mammoth_lib STATIC
   src/endpoint_server.cpp
   src/init.cpp
   src/memory_region.cpp
-  src/new.cpp
   src/process.cpp
-  src/port_client.cpp
-  src/port_server.cpp
+  src/port.cpp
   src/thread.cpp
   )
 

lib/mammoth/include/mammoth/port.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <glacier/status/error_or.h>
+#include <glacier/string/string.h>
+#include <stdint.h>
+#include <zcall.h>
+
+// FIXME: Split send and receive.
+class Port {
+ public:
+  static glcr::ErrorOr<Port> Create();
+  Port(uint64_t port_cap);
+
+  glcr::ErrorCode RecvCap(uint64_t* num_bytes, char* msg, uint64_t* cap);
+  z_err_t PollForIntCap(uint64_t* msg, uint64_t* cap);
+
+  template <typename T>
+  z_err_t WriteMessage(const T& obj, uint64_t cap);
+
+  glcr::ErrorCode WriteString(glcr::String str, uint64_t cap);
+
+  // FIXME: We can't create error_ors of ints
+  glcr::ErrorCode Duplicate(uint64_t* new_cap);
+
+ private:
+  uint64_t port_cap_;
+};
+
+template <typename T>
+z_err_t Port::WriteMessage(const T& obj, uint64_t cap) {
+  return ZPortSend(port_cap_, sizeof(obj), &obj, 1, &cap);
+}

lib/mammoth/include/mammoth/port_client.h

@@ -1,28 +0,0 @@
-#pragma once
-
-#include <glacier/status/error_or.h>
-#include <glacier/string/string.h>
-#include <stdint.h>
-#include <zcall.h>
-
-class PortClient {
- public:
-  static PortClient AdoptPort(z_cap_t port_cap);
-
-  template <typename T>
-  z_err_t WriteMessage(const T& obj, z_cap_t cap);
-
-  glcr::ErrorCode WriteString(glcr::String str, z_cap_t cap);
-
-  z_cap_t cap() { return port_cap_; }
-
- private:
-  z_cap_t port_cap_;
-
-  PortClient(z_cap_t port_cap);
-};
-
-template <typename T>
-z_err_t PortClient::WriteMessage(const T& obj, z_cap_t cap) {
-  return ZPortSend(port_cap_, sizeof(obj), &obj, 1, &cap);
-}

lib/mammoth/include/mammoth/port_server.h

@@ -1,24 +0,0 @@
-#pragma once
-
-#include <glacier/status/error_or.h>
-#include <ztypes.h>
-
-#include "mammoth/port_client.h"
-
-class PortServer {
- public:
-  static glcr::ErrorOr<PortServer> Create();
-  static PortServer AdoptCap(z_cap_t cap);
-
-  glcr::ErrorOr<PortClient> CreateClient();
-
-  glcr::ErrorCode RecvCap(uint64_t* num_bytes, char* msg, uint64_t* cap);
-  glcr::ErrorCode PollForIntCap(uint64_t* msg, uint64_t* cap);
-
-  z_cap_t cap() { return port_cap_; }
-
- private:
-  z_cap_t port_cap_;
-
-  PortServer(z_cap_t cap);
-};

lib/mammoth/src/init.cpp

@@ -4,7 +4,7 @@
 #include <ztypes.h>
 
 #include "mammoth/debug.h"
-#include "mammoth/port_server.h"
+#include "mammoth/port.h"
 
 uint64_t gSelfProcCap = 0;
 uint64_t gSelfVmasCap = 0;
@@ -15,7 +15,7 @@ uint64_t gBootDenaliVmmoCap = 0;
 uint64_t gBootVictoriaFallsVmmoCap = 0;
 
 z_err_t ParseInitPort(uint64_t init_port_cap) {
-  PortServer port = PortServer::AdoptCap(init_port_cap);
+  Port port(init_port_cap);
   z_err_t ret;
   uint64_t init_sig, init_cap;
   while ((ret = port.PollForIntCap(&init_sig, &init_cap)) != glcr::EMPTY) {

lib/mammoth/src/new.cpp

@@ -1,7 +0,0 @@
-#include <stdint.h>
-#include <stdlib.h>
-
-[[nodiscard]] void* operator new(uint64_t size) { return malloc(size); }
-[[nodiscard]] void* operator new[](uint64_t size) { return malloc(size); }
-
-void operator delete(void*, uint64_t) {}

lib/mammoth/src/port.cpp

@@ -0,0 +1,45 @@
+#include "mammoth/port.h"
+
+#include <glacier/status/error.h>
+#include <zcall.h>
+
+#include "mammoth/debug.h"
+
+glcr::ErrorOr<Port> Port::Create() {
+  z_cap_t port;
+  RET_ERR(ZPortCreate(&port));
+  return Port(port);
+}
+Port::Port(uint64_t port_cap) : port_cap_(port_cap) {}
+
+glcr::ErrorCode Port::RecvCap(uint64_t *num_bytes, char *msg, uint64_t *cap) {
+  uint64_t caps = 1;
+  RET_ERR(ZPortRecv(port_cap_, num_bytes, reinterpret_cast<uint8_t *>(msg),
+                    &caps, cap));
+
+  if (caps != 1) {
+    return glcr::FAILED_PRECONDITION;
+  }
+  return glcr::OK;
+}
+z_err_t Port::PollForIntCap(uint64_t *msg, uint64_t *cap) {
+  uint64_t bytes = sizeof(uint64_t);
+  uint64_t caps = 1;
+  RET_ERR(ZPortPoll(port_cap_, &bytes, reinterpret_cast<uint8_t *>(msg), &caps,
+                    cap));
+
+  if (bytes != sizeof(uint64_t)) {
+    return glcr::FAILED_PRECONDITION;
+  }
+  if (caps != 1) {
+    return glcr::FAILED_PRECONDITION;
+  }
+  return glcr::OK;
+}
+glcr::ErrorCode Port::WriteString(glcr::String str, uint64_t cap) {
+  return ZPortSend(port_cap_, str.length() + 1, str.cstr(), 1, &cap);
+}
+
+glcr::ErrorCode Port::Duplicate(uint64_t *new_cap) {
+  return ZCapDuplicate(port_cap_, new_cap);
+}

lib/mammoth/src/port_client.cpp

@@ -1,13 +0,0 @@
-#include "mammoth/port_client.h"
-
-#include <glacier/status/error.h>
-#include <zcall.h>
-
-#include "mammoth/debug.h"
-
-PortClient PortClient::AdoptPort(z_cap_t cap) { return PortClient(cap); }
-PortClient::PortClient(z_cap_t port_cap) : port_cap_(port_cap) {}
-
-glcr::ErrorCode PortClient::WriteString(glcr::String str, z_cap_t cap) {
-  return ZPortSend(port_cap_, str.length() + 1, str.cstr(), 1, &cap);
-}

lib/mammoth/src/port_server.cpp

@@ -1,47 +0,0 @@
-#include "mammoth/port_server.h"
-
-#include <zcall.h>
-
-glcr::ErrorOr<PortServer> PortServer::Create() {
-  z_cap_t port;
-  RET_ERR(ZPortCreate(&port));
-  return PortServer(port);
-}
-
-PortServer PortServer::AdoptCap(z_cap_t cap) { return PortServer(cap); }
-
-PortServer::PortServer(z_cap_t port_cap) : port_cap_(port_cap) {}
-
-glcr::ErrorOr<PortClient> PortServer::CreateClient() {
-  // FIXME: Restrict permissions.
-  z_cap_t new_port;
-  RET_ERR(ZCapDuplicate(port_cap_, &new_port));
-  return PortClient::AdoptPort(new_port);
-}
-
-glcr::ErrorCode PortServer::RecvCap(uint64_t *num_bytes, char *msg,
-                                    uint64_t *cap) {
-  uint64_t caps = 1;
-  RET_ERR(ZPortRecv(port_cap_, num_bytes, reinterpret_cast<uint8_t *>(msg),
-                    &caps, cap));
-
-  if (caps != 1) {
-    return glcr::FAILED_PRECONDITION;
-  }
-  return glcr::OK;
-}
-
-z_err_t PortServer::PollForIntCap(uint64_t *msg, uint64_t *cap) {
-  uint64_t bytes = sizeof(uint64_t);
-  uint64_t caps = 1;
-  RET_ERR(ZPortPoll(port_cap_, &bytes, reinterpret_cast<uint8_t *>(msg), &caps,
-                    cap));
-
-  if (bytes != sizeof(uint64_t)) {
-    return glcr::FAILED_PRECONDITION;
-  }
-  if (caps != 1) {
-    return glcr::FAILED_PRECONDITION;
-  }
-  return glcr::OK;
-}

lib/mammoth/src/process.cpp

@@ -6,8 +6,7 @@
 #include "mammoth/debug.h"
 #include "mammoth/endpoint_server.h"
 #include "mammoth/init.h"
-#include "mammoth/port_client.h"
-#include "mammoth/port_server.h"
+#include "mammoth/port.h"
 
 #define MAM_PROC_DEBUG 0
 
@@ -106,13 +105,14 @@ glcr::ErrorCode SpawnProcessFromElfRegion(uint64_t program,
 #if MAM_PROC_DEBUG
   dbgln("Port Create");
 #endif
-  ASSIGN_OR_RETURN(PortServer server, PortServer::Create());
-  ASSIGN_OR_RETURN(PortClient pclient, server.CreateClient());
+  RET_ERR(ZPortCreate(&port_cap));
+  uint64_t port_cap_donate;
+  RET_ERR(ZCapDuplicate(port_cap, &port_cap_donate));
 
 #if MAM_PROC_DEBUG
   dbgln("Spawn");
 #endif
-  RET_ERR(ZProcessSpawn(gSelfProcCap, server.cap(), &proc_cap, &as_cap,
+  RET_ERR(ZProcessSpawn(gSelfProcCap, port_cap_donate, &proc_cap, &as_cap,
                         &foreign_port_id));
 
   uint64_t entry_point = LoadElfProgram(program, as_cap);
@@ -123,9 +123,10 @@ glcr::ErrorCode SpawnProcessFromElfRegion(uint64_t program,
   uint64_t thread_cap;
   RET_ERR(ZThreadCreate(proc_cap, &thread_cap));
 
-  RET_ERR(pclient.WriteMessage<uint64_t>(Z_INIT_SELF_PROC, proc_cap));
-  RET_ERR(pclient.WriteMessage<uint64_t>(Z_INIT_SELF_VMAS, as_cap));
-  RET_ERR(pclient.WriteMessage<uint64_t>(Z_INIT_ENDPOINT, client.GetCap()));
+  Port p(port_cap);
+  RET_ERR(p.WriteMessage<uint64_t>(Z_INIT_SELF_PROC, proc_cap));
+  RET_ERR(p.WriteMessage<uint64_t>(Z_INIT_SELF_VMAS, as_cap));
+  RET_ERR(p.WriteMessage<uint64_t>(Z_INIT_ENDPOINT, client.GetCap()));
 
 #if MAM_PROC_DEBUG
   dbgln("Thread start");

scripts/build_image.sh

@@ -26,14 +26,14 @@ parted -s $dev mklabel gpt mkpart EFI fat32 1MiB 10MiB mkpart ext2 10MiB 100% se
 mkfs.fat -F 12 "${dev}p1"
 mke2fs "${dev}p2"
 
-limine bios-install "${dev}"
+limine-deploy "${dev}"
 
 mkdir -p efi/
 mount "${dev}p1" efi/
 
 mkdir -p efi/EFI/BOOT
 cp /usr/share/limine/BOOTX64.EFI efi/EFI/BOOT
-cp /usr/share/limine/limine-bios.sys efi/
+cp /usr/share/limine/limine.sys efi/
 cp ../zion/boot/limine.cfg efi/
 cp zion/zion efi/
 mkdir -p efi/sys

sys/denali/CMakeLists.txt

@@ -12,6 +12,7 @@ target_include_directories(denali
    "${CMAKE_CURRENT_SOURCE_DIR}/include")
 
 target_link_libraries(denali
+  cxx
   glacier
   mammoth_lib
   yellowstonestub

sys/denali/denali.cpp

@@ -2,7 +2,7 @@
 #include <mammoth/debug.h>
 #include <mammoth/endpoint_server.h>
 #include <mammoth/init.h>
-#include <mammoth/port_client.h>
+#include <mammoth/port.h>
 #include <stdint.h>
 #include <yellowstone.h>
 
@@ -26,7 +26,7 @@ uint64_t main(uint64_t init_port_cap) {
     check(resp_cap_or.error());
   }
   auto resp_cap = resp_cap_or.value();
-  PortClient notify = PortClient::AdoptPort(resp_cap.second());
+  Port notify(resp_cap.second());
 
   ASSIGN_OR_RETURN(EndpointServer endpoint, EndpointServer::Create());
   ASSIGN_OR_RETURN(EndpointClient client, endpoint.CreateClient());

sys/yellowstone/CMakeLists.txt

@@ -8,6 +8,7 @@ add_executable(yellowstone
    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
 
 target_link_libraries(yellowstone
+  cxx
   mammoth_lib
   glacier
   libdenali

sys/yellowstone/yellowstone_server.cpp

@@ -8,6 +8,8 @@
 #include "hw/gpt.h"
 #include "include/yellowstone.h"
 
+// FIXME: This linkage was missing :(
+void* operator new[](uint64_t size) { return malloc(size); }
 namespace {
 
 void ServerThreadBootstrap(void* yellowstone) {
@@ -32,11 +34,11 @@ glcr::ErrorCode HandleDenaliRegistration(z_cap_t endpoint_cap) {
 
 glcr::ErrorOr<YellowstoneServer> YellowstoneServer::Create() {
   ASSIGN_OR_RETURN(EndpointServer server, EndpointServer::Create());
-  ASSIGN_OR_RETURN(PortServer port, PortServer::Create());
+  ASSIGN_OR_RETURN(Port port, Port::Create());
   return YellowstoneServer(server, port);
 }
 
-YellowstoneServer::YellowstoneServer(EndpointServer server, PortServer port)
+YellowstoneServer::YellowstoneServer(EndpointServer server, Port port)
     : server_(server), register_port_(port) {}
 
 Thread YellowstoneServer::RunServer() {
@@ -61,12 +63,9 @@ void YellowstoneServer::ServerThread() {
         break;
       case kYellowstoneGetRegistration: {
         dbgln("Yellowstone::GetRegistration");
-        auto client_or = register_port_.CreateClient();
-        if (!client_or.ok()) {
-          check(client_or.error());
-        }
+        uint64_t reg_cap;
+        check(register_port_.Duplicate(&reg_cap));
         YellowstoneGetRegistrationResp resp;
-        uint64_t reg_cap = client_or.value().cap();
         check(ZReplyPortSend(reply_port_cap, sizeof(resp), &resp, 1, &reg_cap));
         break;
       }

sys/yellowstone/yellowstone_server.h

@@ -2,7 +2,7 @@
 
 #include <glacier/status/error_or.h>
 #include <mammoth/endpoint_server.h>
-#include <mammoth/port_server.h>
+#include <mammoth/port.h>
 #include <mammoth/thread.h>
 
 class YellowstoneServer {
@@ -19,7 +19,7 @@ class YellowstoneServer {
 
  private:
   EndpointServer server_;
-  PortServer register_port_;
+  Port register_port_;
 
   static const uint64_t kBufferSize = 128;
   uint8_t server_buffer_[kBufferSize];
@@ -29,5 +29,5 @@ class YellowstoneServer {
   z_cap_t denali_cap_ = 0;
   z_cap_t victoria_falls_cap_ = 0;
 
-  YellowstoneServer(EndpointServer server, PortServer port);
+  YellowstoneServer(EndpointServer server, Port port);
 };