[zion] Remove temp PCI Memory Object create function.

Pass the PCI memory space to the yellowstone init process instead.

lib/mammoth/include/mammoth/endpoint_server.h

@@ -5,6 +5,9 @@
 #include <ztypes.h>
 
 #include "mammoth/endpoint_client.h"
+#include "mammoth/request_context.h"
+#include "mammoth/response_context.h"
+#include "mammoth/thread.h"
 
 class EndpointServer {
  public:
@@ -12,19 +15,22 @@ class EndpointServer {
   EndpointServer(const EndpointServer&) = delete;
   EndpointServer& operator=(const EndpointServer&) = delete;
 
-  static glcr::ErrorOr<glcr::UniquePtr<EndpointServer>> Create();
-  static glcr::UniquePtr<EndpointServer> Adopt(z_cap_t endpoint_cap);
-
   glcr::ErrorOr<glcr::UniquePtr<EndpointClient>> CreateClient();
 
-  // FIXME: Release Cap here.
+  Thread RunServer();
-  z_cap_t GetCap() { return endpoint_cap_; }
 
-  glcr::ErrorCode Recieve(uint64_t* num_bytes, void* data,
+  virtual glcr::ErrorCode HandleRequest(RequestContext& request,
-                          z_cap_t* reply_port_cap);
+                                        ResponseContext& response) = 0;
+
+ protected:
+  EndpointServer(z_cap_t cap) : endpoint_cap_(cap) {}
 
  private:
   z_cap_t endpoint_cap_;
 
-  EndpointServer(z_cap_t cap) : endpoint_cap_(cap) {}
+  static const uint64_t kBufferSize = 1024;
+  uint8_t recieve_buffer_[kBufferSize];
+
+  friend void EndpointServerThreadBootstrap(void* endpoint_server);
+  void ServerThread();
 };

lib/mammoth/include/mammoth/request_context.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <glacier/status/error.h>
+#include <stdint.h>
+
+class RequestContext {
+ public:
+  RequestContext(void* buffer, uint64_t buffer_length)
+      : buffer_(buffer), buffer_length_(buffer_length) {
+    if (buffer_length_ < sizeof(uint64_t)) {
+      request_id_ = -1;
+    } else {
+      request_id_ = *reinterpret_cast<uint64_t*>(buffer);
+    }
+  }
+
+  uint64_t request_id() { return request_id_; }
+
+  template <typename T>
+  glcr::ErrorCode As(T** arg) {
+    if (buffer_length_ < sizeof(T)) {
+      return glcr::INVALID_ARGUMENT;
+    }
+    *arg = reinterpret_cast<T*>(buffer_);
+    return glcr::OK;
+  }
+
+ private:
+  uint64_t request_id_;
+  void* buffer_;
+  uint64_t buffer_length_;
+};

lib/mammoth/include/mammoth/response_context.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <glacier/status/error.h>
+#include <zcall.h>
+#include <ztypes.h>
+
+class ResponseContext {
+ public:
+  ResponseContext(z_cap_t reply_port) : reply_port_(reply_port) {}
+
+  ResponseContext(ResponseContext&) = delete;
+
+  template <typename T>
+  glcr::ErrorCode WriteStruct(const T& response) {
+    // FIXME: Here and below probably don't count as written on error.
+    written_ = true;
+    return ZReplyPortSend(reply_port_, sizeof(T), &response, 0, nullptr);
+  }
+
+  template <typename T>
+  glcr::ErrorCode WriteStructWithCap(const T& response, z_cap_t capability) {
+    written_ = true;
+    return ZReplyPortSend(reply_port_, sizeof(T), &response, 1, &capability);
+  }
+
+  glcr::ErrorCode WriteError(glcr::ErrorCode code) {
+    uint64_t response[2]{
+        static_cast<uint64_t>(-1),
+        code,
+    };
+    written_ = true;
+    return ZReplyPortSend(reply_port_, sizeof(response), &response, 0, nullptr);
+  }
+
+  bool HasWritten() { return written_; }
+
+ private:
+  z_cap_t reply_port_;
+  bool written_ = false;
+};

lib/mammoth/src/endpoint_server.cpp

@@ -1,13 +1,10 @@
 #include "mammoth/endpoint_server.h"
 
-glcr::ErrorOr<glcr::UniquePtr<EndpointServer>> EndpointServer::Create() {
+#include "mammoth/debug.h"
-  uint64_t cap;
-  RET_ERR(ZEndpointCreate(&cap));
-  return glcr::UniquePtr<EndpointServer>(new EndpointServer(cap));
-}
 
-glcr::UniquePtr<EndpointServer> EndpointServer::Adopt(z_cap_t endpoint_cap) {
+// Declared as friend in EndpointServer.
-  return glcr::UniquePtr<EndpointServer>(new EndpointServer(endpoint_cap));
+void EndpointServerThreadBootstrap(void* endpoint_server) {
+  reinterpret_cast<EndpointServer*>(endpoint_server)->ServerThread();
 }
 
 glcr::ErrorOr<glcr::UniquePtr<EndpointClient>> EndpointServer::CreateClient() {
@@ -17,7 +14,28 @@ glcr::ErrorOr<glcr::UniquePtr<EndpointClient>> EndpointServer::CreateClient() {
   return EndpointClient::AdoptEndpoint(client_cap);
 }
 
-glcr::ErrorCode EndpointServer::Recieve(uint64_t* num_bytes, void* data,
+Thread EndpointServer::RunServer() {
-                                        z_cap_t* reply_port_cap) {
+  return Thread(EndpointServerThreadBootstrap, this);
-  return ZEndpointRecv(endpoint_cap_, num_bytes, data, reply_port_cap);
+}
+
+void EndpointServer::ServerThread() {
+  while (true) {
+    uint64_t message_size = kBufferSize;
+    uint64_t reply_port_cap = 0;
+    glcr::ErrorCode err = ZEndpointRecv(endpoint_cap_, &message_size,
+                                        recieve_buffer_, &reply_port_cap);
+    if (err != glcr::OK) {
+      dbgln("Error in receive: %x", err);
+      continue;
+    }
+
+    RequestContext request(recieve_buffer_, message_size);
+    ResponseContext response(reply_port_cap);
+    // FIXME: Consider pumping these errors into the response as well.
+    check(HandleRequest(request, response));
+    if (!response.HasWritten()) {
+      dbgln("Returning without having written a response. Req type %x",
+            request.request_id());
+    }
+  }
 }

lib/mammoth/src/init.cpp

@@ -13,6 +13,7 @@ uint64_t gInitEndpointCap = 0;
 
 uint64_t gBootDenaliVmmoCap = 0;
 uint64_t gBootVictoriaFallsVmmoCap = 0;
+uint64_t gBootPciVmmoCap = 0;
 
 z_err_t ParseInitPort(uint64_t init_port_cap) {
   PortServer port = PortServer::AdoptCap(init_port_cap);
@@ -40,6 +41,10 @@ z_err_t ParseInitPort(uint64_t init_port_cap) {
         dbgln("received victoria falls");
         gBootVictoriaFallsVmmoCap = init_cap;
         break;
+      case Z_BOOT_PCI_VMMO:
+        dbgln("received pci");
+        gBootPciVmmoCap = init_cap;
+        break;
       default:
         dbgln("Unexpected init type %x, continuing.", init_sig);
     }

sys/denali/ahci/command.cpp

@@ -7,8 +7,8 @@
 Command::~Command() {}
 
 DmaReadCommand::DmaReadCommand(uint64_t lba, uint64_t sector_cnt,
-                               DmaCallback callback, z_cap_t reply_port)
+                               DmaCallback callback, ResponseContext& response)
-    : reply_port_(reply_port),
+    : response_(response),
       lba_(lba),
       sector_cnt_(sector_cnt),
       callback_(callback) {
@@ -50,5 +50,5 @@ void DmaReadCommand::PopulatePrdt(PhysicalRegionDescriptor* prdt) {
   prdt[0].byte_count = region_.size();
 }
 void DmaReadCommand::Callback() {
-  callback_(reply_port_, lba_, sector_cnt_, region_.cap());
+  callback_(response_, lba_, sector_cnt_, region_.cap());
 }

sys/denali/ahci/command.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <mammoth/memory_region.h>
+#include <mammoth/response_context.h>
 #include <stdint.h>
 
 #include "ahci/ahci.h"
@@ -15,9 +16,9 @@ class Command {
 
 class DmaReadCommand : public Command {
  public:
-  typedef void (*DmaCallback)(z_cap_t, uint64_t, uint64_t, z_cap_t);
+  typedef void (*DmaCallback)(ResponseContext&, uint64_t, uint64_t, z_cap_t);
   DmaReadCommand(uint64_t lba, uint64_t sector_cnt, DmaCallback callback,
-                 z_cap_t reply_port);
+                 ResponseContext& reply_port);
 
   virtual ~DmaReadCommand() override;
 
@@ -27,7 +28,7 @@ class DmaReadCommand : public Command {
   void Callback() override;
 
  private:
-  z_cap_t reply_port_;
+  ResponseContext& response_;
   uint64_t lba_;
   uint64_t sector_cnt_;
   DmaCallback callback_;

sys/denali/client/denali_client.cpp

@@ -6,13 +6,14 @@
 
 glcr::ErrorOr<MappedMemoryRegion> DenaliClient::ReadSectors(
     uint64_t device_id, uint64_t lba, uint64_t num_sectors) {
-  DenaliRead read{
+  DenaliReadRequest read{
       .device_id = device_id,
       .lba = lba,
       .size = num_sectors,
   };
   auto pair_or =
-      endpoint_->CallEndpointGetCap<DenaliRead, DenaliReadResponse>(read);
+      endpoint_->CallEndpointGetCap<DenaliReadRequest, DenaliReadResponse>(
+          read);
   if (!pair_or) {
     return pair_or.error();
   }

sys/denali/denali.cpp

@@ -19,14 +19,15 @@ uint64_t main(uint64_t init_port_cap) {
   ASSIGN_OR_RETURN(MappedMemoryRegion ahci_region, stub.GetAhciConfig());
   ASSIGN_OR_RETURN(auto driver, AhciDriver::Init(ahci_region));
 
-  ASSIGN_OR_RETURN(glcr::UniquePtr<EndpointServer> endpoint,
+  ASSIGN_OR_RETURN(glcr::UniquePtr<DenaliServer> server,
-                   EndpointServer::Create());
+                   DenaliServer::Create(*driver));
+
   ASSIGN_OR_RETURN(glcr::UniquePtr<EndpointClient> client,
-                   endpoint->CreateClient());
+                   server->CreateClient());
   check(stub.Register("denali", *client));
 
-  DenaliServer server(glcr::Move(endpoint), *driver);
+  Thread server_thread = server->RunServer();
-  RET_ERR(server.RunServer());
+
-  // FIXME: Add thread join.
+  check(server_thread.Join());
   return 0;
 }

sys/denali/denali_server.cpp

@@ -7,61 +7,57 @@
 
 namespace {
 DenaliServer* gServer = nullptr;
-void HandleResponse(z_cap_t reply_port, uint64_t lba, uint64_t size,
+void HandleResponse(ResponseContext& response, uint64_t lba, uint64_t size,
                     z_cap_t mem) {
-  gServer->HandleResponse(reply_port, lba, size, mem);
+  gServer->HandleResponse(response, lba, size, mem);
 }
 }  // namespace
 
-DenaliServer::DenaliServer(glcr::UniquePtr<EndpointServer> server,
+glcr::ErrorOr<glcr::UniquePtr<DenaliServer>> DenaliServer::Create(
-                           AhciDriver& driver)
+    AhciDriver& driver) {
-    : server_(glcr::Move(server)), driver_(driver) {
+  z_cap_t cap;
-  gServer = this;
+  RET_ERR(ZEndpointCreate(&cap));
+  return glcr::UniquePtr<DenaliServer>(new DenaliServer(cap, driver));
 }
 
-glcr::ErrorCode DenaliServer::RunServer() {
+glcr::ErrorCode DenaliServer::HandleRequest(RequestContext& request,
-  while (true) {
+                                            ResponseContext& response) {
-    uint64_t buff_size = kBuffSize;
+  switch (request.request_id()) {
-    z_cap_t reply_port;
-    RET_ERR(server_->Recieve(&buff_size, read_buffer_, &reply_port));
-    if (buff_size < sizeof(uint64_t)) {
-      dbgln("Skipping invalid message");
-      continue;
-    }
-    uint64_t type = *reinterpret_cast<uint64_t*>(read_buffer_);
-    switch (type) {
-      case Z_INVALID:
-        dbgln(reinterpret_cast<char*>(read_buffer_));
-        break;
     case DENALI_READ: {
-        DenaliRead* read_req = reinterpret_cast<DenaliRead*>(read_buffer_);
+      DenaliReadRequest* req = 0;
-        uint64_t memcap = 0;
+      glcr::ErrorCode err = request.As<DenaliReadRequest>(&req);
-        RET_ERR(HandleRead(*read_req, reply_port));
+      if (err != glcr::OK) {
+        response.WriteError(err);
+      }
+      err = HandleRead(req, response);
+      if (err != glcr::OK) {
+        response.WriteError(err);
+      }
       break;
     }
     default:
-        dbgln("Invalid message type.");
+      response.WriteError(glcr::UNIMPLEMENTED);
-        return glcr::UNIMPLEMENTED;
+      break;
-    }
   }
+  return glcr::OK;
 }
 
-glcr::ErrorCode DenaliServer::HandleRead(const DenaliRead& read,
+glcr::ErrorCode DenaliServer::HandleRead(DenaliReadRequest* request,
-                                         z_cap_t reply_port) {
+                                         ResponseContext& context) {
-  ASSIGN_OR_RETURN(AhciDevice * device, driver_.GetDevice(read.device_id));
+  ASSIGN_OR_RETURN(AhciDevice * device, driver_.GetDevice(request->device_id));
 
-  device->IssueCommand(
+  device->IssueCommand(new DmaReadCommand(request->lba, request->size,
-      new DmaReadCommand(read.lba, read.size, ::HandleResponse, reply_port));
+                                          ::HandleResponse, context));
 
   return glcr::OK;
 }
 
-void DenaliServer::HandleResponse(z_cap_t reply_port, uint64_t lba,
+void DenaliServer::HandleResponse(ResponseContext& response, uint64_t lba,
                                   uint64_t size, z_cap_t mem) {
   DenaliReadResponse resp{
       .device_id = 0,
       .lba = lba,
       .size = size,
   };
-  check(ZReplyPortSend(reply_port, sizeof(resp), &resp, 1, &mem));
+  check(response.WriteStructWithCap<DenaliReadResponse>(resp, mem));
 }

sys/denali/denali_server.h

@@ -6,21 +6,26 @@
 #include "ahci/ahci_driver.h"
 #include "denali/denali.h"
 
-class DenaliServer {
+class DenaliServer : public EndpointServer {
  public:
-  DenaliServer(glcr::UniquePtr<EndpointServer> server, AhciDriver& driver);
+  static glcr::ErrorOr<glcr::UniquePtr<DenaliServer>> Create(
+      AhciDriver& driver);
 
-  glcr::ErrorCode RunServer();
+  void HandleResponse(ResponseContext& response, uint64_t lba, uint64_t size,
-
-  void HandleResponse(z_cap_t reply_port, uint64_t lba, uint64_t size,
                       z_cap_t cap);
 
+  virtual glcr::ErrorCode HandleRequest(RequestContext& request,
+                                        ResponseContext& response) override;
+
  private:
   static const uint64_t kBuffSize = 1024;
-  glcr::UniquePtr<EndpointServer> server_;
   uint8_t read_buffer_[kBuffSize];
 
   AhciDriver& driver_;
 
-  glcr::ErrorCode HandleRead(const DenaliRead& read, z_cap_t reply_port);
+  DenaliServer(z_cap_t endpoint_cap, AhciDriver& driver)
+      : EndpointServer(endpoint_cap), driver_(driver) {}
+
+  glcr::ErrorCode HandleRead(DenaliReadRequest* request,
+                             ResponseContext& context);
 };

sys/denali/include/denali/denali.h

@@ -5,7 +5,7 @@
 #define DENALI_INVALID 0
 #define DENALI_READ 100
 
-struct DenaliRead {
+struct DenaliReadRequest {
   uint64_t request_type = DENALI_READ;
   uint64_t device_id;
 

sys/yellowstone/hw/pcie.cpp

@@ -15,13 +15,9 @@ PciDeviceHeader* PciHeader(uint64_t base, uint64_t bus, uint64_t dev,
 }  // namespace
 
 PciReader::PciReader() {
-  dbgln("Creating PCI obj");
-  uint64_t vmmo_cap, vmmo_size;
-  check(ZTempPcieConfigObjectCreate(&vmmo_cap, &vmmo_size));
-
   dbgln("Creating addr space");
   uint64_t vaddr;
-  check(ZAddressSpaceMap(gSelfVmasCap, 0, vmmo_cap, &vaddr));
+  check(ZAddressSpaceMap(gSelfVmasCap, 0, gBootPciVmmoCap, &vaddr));
   dbgln("Addr %lx", vaddr);
 
   dbgln("Dumping PCI");

sys/yellowstone/yellowstone.cpp

@@ -13,13 +13,13 @@ uint64_t main(uint64_t port_cap) {
   check(ParseInitPort(port_cap));
 
   ASSIGN_OR_RETURN(auto server, YellowstoneServer::Create());
-  Thread server_thread = server->RunServer();
   Thread registration_thread = server->RunRegistration();
+  Thread server_thread = server->RunServer();
 
   uint64_t vaddr;
   check(ZAddressSpaceMap(gSelfVmasCap, 0, gBootDenaliVmmoCap, &vaddr));
   ASSIGN_OR_RETURN(glcr::UniquePtr<EndpointClient> client,
-                   server->GetServerClient());
+                   server->CreateClient());
   check(SpawnProcessFromElfRegion(vaddr, glcr::Move(client)));
 
   check(server_thread.Join());

sys/yellowstone/yellowstone_server.cpp

@@ -12,11 +12,6 @@
 
 namespace {
 
-void ServerThreadBootstrap(void* yellowstone) {
-  dbgln("Yellowstone server starting");
-  static_cast<YellowstoneServer*>(yellowstone)->ServerThread();
-}
-
 void RegistrationThreadBootstrap(void* yellowstone) {
   dbgln("Yellowstone registration starting");
   static_cast<YellowstoneServer*>(yellowstone)->RegistrationThread();
@@ -40,40 +35,29 @@ glcr::ErrorOr<PartitionInfo> HandleDenaliRegistration(z_cap_t endpoint_cap) {
 }  // namespace
 
 glcr::ErrorOr<glcr::UniquePtr<YellowstoneServer>> YellowstoneServer::Create() {
-  ASSIGN_OR_RETURN(auto server, EndpointServer::Create());
+  z_cap_t cap;
+  RET_ERR(ZEndpointCreate(&cap));
   ASSIGN_OR_RETURN(PortServer port, PortServer::Create());
-  return glcr::UniquePtr<YellowstoneServer>(
+  return glcr::UniquePtr<YellowstoneServer>(new YellowstoneServer(cap, port));
-      new YellowstoneServer(glcr::Move(server), port));
 }
 
-YellowstoneServer::YellowstoneServer(glcr::UniquePtr<EndpointServer> server,
+YellowstoneServer::YellowstoneServer(z_cap_t endpoint_cap, PortServer port)
-                                     PortServer port)
+    : EndpointServer(endpoint_cap), register_port_(port) {}
-    : server_(glcr::Move(server)), register_port_(port) {}
-
-Thread YellowstoneServer::RunServer() {
-  return Thread(ServerThreadBootstrap, this);
-}
 
 Thread YellowstoneServer::RunRegistration() {
   return Thread(RegistrationThreadBootstrap, this);
 }
 
-void YellowstoneServer::ServerThread() {
+glcr::ErrorCode YellowstoneServer::HandleRequest(RequestContext& request,
-  while (true) {
+                                                 ResponseContext& response) {
-    uint64_t num_bytes = kBufferSize;
+  switch (request.request_id()) {
-    uint64_t reply_port_cap;
-    // FIXME: Error handling.
-    check(server_->Recieve(&num_bytes, server_buffer_, &reply_port_cap));
-    YellowstoneGetReq* req =
-        reinterpret_cast<YellowstoneGetReq*>(server_buffer_);
-    switch (req->type) {
     case kYellowstoneGetAhci: {
       dbgln("Yellowstone::GetAHCI");
       YellowstoneGetAhciResp resp{
           .type = kYellowstoneGetAhci,
           .ahci_phys_offset = pci_reader_.GetAhciPhysical(),
       };
-        check(ZReplyPortSend(reply_port_cap, sizeof(resp), &resp, 0, nullptr));
+      RET_ERR(response.WriteStruct<YellowstoneGetAhciResp>(resp));
       break;
     }
     case kYellowstoneGetRegistration: {
@@ -84,7 +68,7 @@ void YellowstoneServer::ServerThread() {
       }
       YellowstoneGetRegistrationResp resp;
       uint64_t reg_cap = client_or.value().cap();
-        check(ZReplyPortSend(reply_port_cap, sizeof(resp), &resp, 1, &reg_cap));
+      RET_ERR(response.WriteStructWithCap(resp, reg_cap));
       break;
     }
     case kYellowstoneGetDenali: {
@@ -96,15 +80,15 @@ void YellowstoneServer::ServerThread() {
           .device_id = device_id_,
           .lba_offset = lba_offset_,
       };
-        check(ZReplyPortSend(reply_port_cap, sizeof(resp), &resp, 1,
+      RET_ERR(response.WriteStructWithCap(resp, new_denali));
-                             &new_denali));
       break;
     }
     default:
-        dbgln("Unknown request type: %x", req->type);
+      dbgln("Unknown request type: %x", request.request_id());
+      return glcr::UNIMPLEMENTED;
       break;
   }
-  }
+  return glcr::OK;
 }
 
 void YellowstoneServer::RegistrationThread() {
@@ -127,7 +111,7 @@ void YellowstoneServer::RegistrationThread() {
       uint64_t vaddr;
       check(
           ZAddressSpaceMap(gSelfVmasCap, 0, gBootVictoriaFallsVmmoCap, &vaddr));
-      auto client_or = GetServerClient();
+      auto client_or = CreateClient();
       if (!client_or.ok()) {
         check(client_or.error());
       }
@@ -144,8 +128,3 @@ void YellowstoneServer::RegistrationThread() {
     dbgln(name.cstr());
   }
 }
-
-glcr::ErrorOr<glcr::UniquePtr<EndpointClient>>
-YellowstoneServer::GetServerClient() {
-  return server_->CreateClient();
-}

sys/yellowstone/yellowstone_server.h

@@ -8,20 +8,19 @@
 
 #include "hw/pcie.h"
 
-class YellowstoneServer {
+class YellowstoneServer : public EndpointServer {
  public:
   static glcr::ErrorOr<glcr::UniquePtr<YellowstoneServer>> Create();
 
-  Thread RunServer();
   Thread RunRegistration();
 
-  void ServerThread();
   void RegistrationThread();
 
-  glcr::ErrorOr<glcr::UniquePtr<EndpointClient>> GetServerClient();
+  virtual glcr::ErrorCode HandleRequest(RequestContext& request,
+                                        ResponseContext& response) override;
 
  private:
-  glcr::UniquePtr<EndpointServer> server_;
+  // FIXME: Separate this to its own service.
   PortServer register_port_;
 
   static const uint64_t kBufferSize = 128;
@@ -36,5 +35,5 @@ class YellowstoneServer {
 
   PciReader pci_reader_;
 
-  YellowstoneServer(glcr::UniquePtr<EndpointServer> server, PortServer port);
+  YellowstoneServer(z_cap_t endpoint_cap, PortServer port);
 };

zion/include/zcall.h

@@ -106,7 +106,6 @@ SYS3(MemoryObjectCreatePhysical, uint64_t, paddr, uint64_t, size, z_cap_t*,
      vmmo_cap);
 SYS3(MemoryObjectCreateContiguous, uint64_t, size, z_cap_t*, vmmo_cap,
      uint64_t*, paddr);
-SYS2(TempPcieConfigObjectCreate, z_cap_t*, vmmo_cap, uint64_t*, vmmo_size);
 
 SYS2(ChannelCreate, z_cap_t*, channel1, z_cap_t*, channel2);
 SYS5(ChannelSend, z_cap_t, chan_cap, uint64_t, num_bytes, const void*, data,

zion/include/zglobal.h

@@ -9,3 +9,4 @@ extern uint64_t gInitEndpointCap;
 
 extern uint64_t gBootDenaliVmmoCap;
 extern uint64_t gBootVictoriaFallsVmmoCap;
+extern uint64_t gBootPciVmmoCap;

zion/include/ztypes.h

@@ -27,8 +27,6 @@ const uint64_t kZionMemoryObjectCreate = 0x30;
 const uint64_t kZionMemoryObjectCreatePhysical = 0x31;
 const uint64_t kZionMemoryObjectCreateContiguous = 0x32;
 
-const uint64_t kZionTempPcieConfigObjectCreate = 0x3F;
-
 // IPC Calls
 const uint64_t kZionChannelCreate = 0x40;
 const uint64_t kZionChannelSend = 0x41;
@@ -90,3 +88,4 @@ typedef uint64_t z_cap_t;
 
 #define Z_BOOT_DENALI_VMMO 0x4200'0000
 #define Z_BOOT_VICTORIA_FALLS_VMMO 0x4200'0001
+#define Z_BOOT_PCI_VMMO 0x4200'0002

zion/loader/init_loader.cpp

@@ -3,6 +3,7 @@
 #include <glacier/memory/ref_ptr.h>
 #include <glacier/string/string.h>
 
+#include "boot/acpi.h"
 #include "boot/boot_info.h"
 #include "debug/debug.h"
 #include "include/zcall.h"
@@ -127,6 +128,16 @@ void WriteInitProgram(glcr::RefPtr<Port> port, glcr::String name, uint64_t id) {
                     MakeRefCounted<Capability>(prog_vmmo, ZC_READ | ZC_WRITE));
 }
 
+glcr::ErrorCode WritePciVmmo(glcr::RefPtr<Port> port, uint64_t id) {
+  ASSIGN_OR_RETURN(PcieConfiguration config, GetPciExtendedConfiguration());
+  auto vmmo =
+      glcr::MakeRefCounted<FixedMemoryObject>(config.base, config.offset);
+
+  port->WriteKernel(id, MakeRefCounted<Capability>(vmmo, ZC_READ | ZC_WRITE));
+
+  return glcr::OK;
+}
+
 }  // namespace
 
 void LoadInitProgram() {
@@ -147,6 +158,10 @@ void LoadInitProgram() {
   WriteInitProgram(port, "/sys/denali", Z_BOOT_DENALI_VMMO);
   WriteInitProgram(port, "/sys/victoriafalls", Z_BOOT_VICTORIA_FALLS_VMMO);
 
+  if (WritePciVmmo(port, Z_BOOT_PCI_VMMO) != glcr::OK) {
+    panic("Failed to provide PCI info to init.");
+  }
+
   // Start process.
   const limine_file& init_prog = GetInitProgram("/sys/yellowstone");
   uint64_t entry = LoadElfProgram(

zion/syscall/memory_object.cpp

@@ -29,14 +29,3 @@ z_err_t MemoryObjectCreateContiguous(ZMemoryObjectCreateContiguousReq* req) {
   *req->paddr = paddr;
   return glcr::OK;
 }
-
-z_err_t TempPcieConfigObjectCreate(ZTempPcieConfigObjectCreateReq* req) {
-  auto& curr_proc = gScheduler->CurrentProcess();
-  ASSIGN_OR_RETURN(PcieConfiguration config, GetPciExtendedConfiguration());
-  auto vmmo_ref =
-      glcr::MakeRefCounted<FixedMemoryObject>(config.base, config.offset);
-  *req->vmmo_cap = curr_proc.AddNewCapability(
-      StaticCastRefPtr<MemoryObject>(vmmo_ref), ZC_WRITE);
-  *req->vmmo_size = config.offset;
-  return glcr::OK;
-}

zion/syscall/memory_object.h

@@ -5,4 +5,3 @@
 z_err_t MemoryObjectCreate(ZMemoryObjectCreateReq* req);
 z_err_t MemoryObjectCreatePhysical(ZMemoryObjectCreatePhysicalReq* req);
 z_err_t MemoryObjectCreateContiguous(ZMemoryObjectCreateContiguousReq* req);
-z_err_t TempPcieConfigObjectCreate(ZTempPcieConfigObjectCreateReq* req);

zion/syscall/syscall.cpp

@@ -63,7 +63,6 @@ extern "C" z_err_t SyscallHandler(uint64_t call_id, void* req) {
     CASE(MemoryObjectCreate);
     CASE(MemoryObjectCreatePhysical);
     CASE(MemoryObjectCreateContiguous);
-    CASE(TempPcieConfigObjectCreate);
     // syscall/ipc.h
     CASE(ChannelCreate);
     CASE(ChannelSend);