CMakeLists.txt

@@ -9,7 +9,7 @@ set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED True)
 set(CMAKE_EXPORT_COMPILE_COMMANDS True)
 
-set(BASE_COMPILE_FLAGS "-fno-rtti -fno-exceptions -mgeneral-regs-only")
+set(BASE_COMPILE_FLAGS "-ffreestanding -fno-exceptions -mgeneral-regs-only")
 set(BASE_LINK_FLAGS "-nostdlib")
 
 add_subdirectory(zion)

lib/libcxx/src/new.cpp

@@ -4,5 +4,3 @@
 
 [[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/include/mammoth/channel.h

@@ -8,7 +8,6 @@ class Channel {
   Channel() {}
   void adopt_cap(uint64_t id);
   uint64_t release_cap();
-  uint64_t cap();
 
   z_err_t WriteStr(const char* msg);
   z_err_t ReadStr(char* buffer, uint64_t* size);

lib/mammoth/include/mammoth/memory_region.h

@@ -15,9 +15,6 @@ class MappedMemoryRegion {
 
   uint64_t paddr() { return paddr_; }
   uint64_t vaddr() { return vaddr_; }
-  uint64_t size() { return size_; }
-
-  uint64_t cap() { return vmmo_cap_; }
 
   operator bool() { return vmmo_cap_ != 0; }
 

lib/mammoth/src/channel.cpp

@@ -29,8 +29,6 @@ uint64_t Channel::release_cap() {
   return cap;
 }
 
-uint64_t Channel::cap() { return chan_cap_; }
-
 z_err_t Channel::WriteStr(const char* msg) {
   if (!chan_cap_) {
     return Z_ERR_NULL;

lib/mammoth/src/process.cpp

@@ -69,7 +69,7 @@ uint64_t LoadElfProgram(uint64_t base, uint64_t as_cap) {
     dbgln("Create mem object");
 #endif
     uint64_t mem_cap;
-    uint64_t size = program.memsz;
+    uint64_t size = program.filesz;
     check(ZMemoryObjectCreate(size, &mem_cap));
 
 #if MAM_PROC_DEBUG

sys/denali/CMakeLists.txt

@@ -1,7 +1,6 @@
 add_executable(denali
   ahci/ahci_device.cpp
   ahci/ahci_driver.cpp
-  ahci/command.cpp
   denali.cpp
   denali_server.cpp
   )

sys/denali/ahci/ahci.h

@@ -96,7 +96,7 @@ struct CommandTable {
   uint8_t command_fis[64];
   uint8_t atapi_command[16];
   uint8_t reserved[48];
-  PhysicalRegionDescriptor prdt[65535];
+  PhysicalRegionDescriptor prds[65535];
 } __attribute__((packed));
 
 typedef enum {

sys/denali/ahci/ahci_device.cpp

@@ -4,6 +4,12 @@
 #include <string.h>
 #include <zcall.h>
 
+namespace {
+
+void HandleIdent(AhciDevice* dev) { dev->HandleIdentify(); }
+
+}  // namespace
+
 AhciDevice::AhciDevice(AhciPort* port) : port_struct_(port) {
   if ((port_struct_->sata_status & 0x103) != 0x103) {
     return;
@@ -32,25 +38,59 @@ AhciDevice::AhciDevice(AhciPort* port) : port_struct_(port) {
       reinterpret_cast<CommandTable*>(command_structures_.vaddr() + ct_off);
 
   port_struct_->interrupt_enable = 0xFFFFFFFF;
+
+  if (port_struct_->signature == 0x101) {
+    SendIdentify();
+  }
 }
 
-z_err_t AhciDevice::IssueCommand(Command* command) {
+z_err_t AhciDevice::SendIdentify() {
-  command->PopulateFis(command_table_->command_fis);
+  HostToDeviceRegisterFis fis{
-  command->PopulatePrdt(command_table_->prdt);
+      .fis_type = FIS_TYPE_REG_H2D,
+      .pmp_and_c = 0x80,
+      .command = 0xEC,
+      .featurel = 0,
 
-  command_list_->command_headers[0].command =
+      .lba0 = 0,
-      (sizeof(HostToDeviceRegisterFis) / 2) & 0x1F;
+      .lba1 = 0,
+      .lba2 = 0,
+      .device = 0,
+
+      .lba3 = 0,
+      .lba4 = 0,
+      .lba5 = 0,
+      .featureh = 0,
+
+      .count = 0,
+      .icc = 0,
+      .control = 0,
+
+      .reserved = 0,
+  };
+
+  command_list_->command_headers[0].command = (sizeof(fis) / 2) & 0x1F;
   command_list_->command_headers[0].prd_table_length = 1;
-  command_list_->command_headers[0].prd_byte_count = 0;
 
-  commands_[0] = command;
+  memcpy(command_table_->command_fis, &fis, sizeof(fis));
+
+  commands_[0].region = MappedMemoryRegion::ContiguousPhysical(512);
+  //  commands_[0].callback = HandleIdent;
+
+  command_table_->prds[0].region_address = commands_[0].region.paddr();
+  command_table_->prds[0].byte_count = 512;
 
-  commands_issued_ |= 1;
   port_struct_->command_issue |= 1;
+  commands_issued_ |= 1;
 
   return Z_OK;
 }
 
+void AhciDevice::HandleIdentify() {
+  dbgln("Handling Idenify");
+  uint16_t* ident = reinterpret_cast<uint16_t*>(commands_[0].region.vaddr());
+  dbgln("Ident: %x", ident[0]);
+}
+
 void AhciDevice::DumpInfo() {
   dbgln("Comlist: %lx", port_struct_->command_list_base);
   dbgln("FIS: %lx", port_struct_->fis_base);
@@ -76,15 +116,11 @@ void AhciDevice::HandleIrq() {
   port_struct_->interrupt_status = int_status;
 
   uint32_t commands_finished = commands_issued_ & ~port_struct_->command_issue;
-  dbgln("finished %x", commands_finished);
-  dbgln("status %x", int_status);
-  dbgln("Issued %x, %x", commands_issued_, port_struct_->command_issue);
 
-  // FIXME: Pass error codes to the callback.
   for (uint64_t i = 0; i < 32; i++) {
     if (commands_finished & (1 << i)) {
+      // commands_[i].callback(this);
       commands_issued_ &= ~(1 << i);
-      commands_[i]->Callback();
     }
   }
 
@@ -98,7 +134,6 @@ void AhciDevice::HandleIrq() {
     }
     if (fis.error) {
       dbgln("D2H err: %x", fis.error);
-      dbgln("status: %x", fis.status);
     }
   }
   if (int_status & 0x2) {

sys/denali/ahci/ahci_device.h

@@ -4,7 +4,6 @@
 #include <zerrors.h>
 
 #include "ahci/ahci.h"
-#include "ahci/command.h"
 
 class AhciDevice {
  public:
@@ -16,13 +15,11 @@ class AhciDevice {
 
   bool IsInit() { return port_struct_ != nullptr && command_structures_; }
 
-  z_err_t IssueCommand(Command* command);
+  z_err_t SendIdentify();
+  void HandleIdentify();
 
   void HandleIrq();
 
-  AhciDevice(const AhciDevice&) = delete;
-  AhciDevice& operator=(const AhciDevice&) = delete;
-
  private:
   AhciPort* port_struct_ = nullptr;
   MappedMemoryRegion command_structures_;
@@ -31,6 +28,10 @@ class AhciDevice {
   ReceivedFis* received_fis_ = nullptr;
   CommandTable* command_table_ = nullptr;
 
-  Command* commands_[32];
+  struct Command {
-  volatile uint32_t commands_issued_ = 0;
+    MappedMemoryRegion region;
+    // std::function<void(MappedMemoryRegion)> callback;
+  };
+  Command commands_[32];
+  uint32_t commands_issued_ = 0;
 };

sys/denali/ahci/ahci_driver.cpp

@@ -33,16 +33,16 @@ z_err_t AhciDriver::Init() {
   return Z_OK;
 }
 
-z_err_t AhciDriver::GetDevice(uint64_t id, AhciDevice** device) {
+z_err_t AhciDriver::GetDevice(uint64_t id, AhciDevice& device) {
   if (id >= 32) {
     return Z_ERR_INVALID;
   }
 
-  if (devices_[id] != nullptr && !devices_[id]->IsInit()) {
+  if (!devices_[id].IsInit()) {
     return Z_ERR_NOT_FOUND;
   }
 
-  *device = devices_[id];
+  device = devices_[id];
   return Z_OK;
 }
 
@@ -126,27 +126,24 @@ void AhciDriver::DumpCapabilities() {
 
 void AhciDriver::DumpPorts() {
   for (uint64_t i = 0; i < 6; i++) {
-    AhciDevice* dev = devices_[i];
+    AhciDevice& dev = devices_[i];
-    if (dev == nullptr || !dev->IsInit()) {
+    if (!dev.IsInit()) {
       continue;
     }
 
     dbgln("");
     dbgln("Port %u:", i);
-    dev->DumpInfo();
+    dev.DumpInfo();
   }
 }
 
 void AhciDriver::InterruptLoop() {
-  dbgln("Starting interrupt loop");
   while (true) {
     uint64_t type, bytes, caps;
     check(ZPortRecv(irq_port_cap_, 0, 0, 0, 0, &type, &bytes, &caps));
     for (uint64_t i = 0; i < 32; i++) {
-      if (devices_[i] != nullptr && devices_[i]->IsInit() &&
+      if (devices_[i].IsInit() && (ahci_hba_->interrupt_status & (1 << i))) {
-          (ahci_hba_->interrupt_status & (1 << i))) {
+        devices_[i].HandleIrq();
-        dbgln("Interrupt for %u", i);
-        devices_[i]->HandleIrq();
         ahci_hba_->interrupt_status &= ~(1 << i);
       }
     }
@@ -215,7 +212,7 @@ z_err_t AhciDriver::LoadDevices() {
     }
     uint64_t port_addr =
         reinterpret_cast<uint64_t>(ahci_hba_) + 0x100 + (0x80 * i);
-    devices_[i] = new AhciDevice(reinterpret_cast<AhciPort*>(port_addr));
+    devices_[i] = AhciDevice(reinterpret_cast<AhciPort*>(port_addr));
   }
   return Z_OK;
 }

sys/denali/ahci/ahci_driver.h

@@ -12,7 +12,7 @@ class AhciDriver {
 
   void InterruptLoop();
 
-  z_err_t GetDevice(uint64_t id, AhciDevice** device);
+  z_err_t GetDevice(uint64_t id, AhciDevice& device);
 
   void DumpCapabilities();
   void DumpPorts();
@@ -24,7 +24,7 @@ class AhciDriver {
   AhciHba* ahci_hba_ = nullptr;
 
   // TODO: Allocate these dynamically.
-  AhciDevice* devices_[32];
+  AhciDevice devices_[32];
 
   Thread irq_thread_;
   uint64_t irq_port_cap_ = 0;

sys/denali/ahci/command.cpp

@@ -1,49 +0,0 @@
-#include "ahci/command.h"
-
-#include <string.h>
-
-#include "ahci/ahci.h"
-
-Command::~Command() {}
-
-DmaReadCommand::DmaReadCommand(uint64_t lba, uint64_t sector_cnt,
-                               DmaCallback callback)
-    : lba_(lba), sector_cnt_(sector_cnt), callback_(callback) {
-  region_ = MappedMemoryRegion::ContiguousPhysical(sector_cnt * 512);
-}
-
-DmaReadCommand::~DmaReadCommand() {}
-
-void DmaReadCommand::PopulateFis(uint8_t* command_fis) {
-  HostToDeviceRegisterFis fis{
-      .fis_type = FIS_TYPE_REG_H2D,
-      .pmp_and_c = 0x80,
-      .command = 0x25,
-      .featurel = 0,
-
-      .lba0 = static_cast<uint8_t>(lba_ & 0xFF),
-      .lba1 = static_cast<uint8_t>((lba_ >> 8) & 0xFF),
-      .lba2 = static_cast<uint8_t>((lba_ >> 16) & 0xFF),
-      .device = (1 << 6),  // ATA LBA Mode
-
-      .lba3 = static_cast<uint8_t>((lba_ >> 24) & 0xFF),
-      .lba4 = static_cast<uint8_t>((lba_ >> 32) & 0xFF),
-      .lba5 = static_cast<uint8_t>((lba_ >> 40) & 0xFF),
-      .featureh = 0,
-
-      .count = static_cast<uint16_t>(sector_cnt_),
-      .icc = 0,
-      .control = 0,
-
-      .reserved = 0,
-  };
-
-  uint64_t bytes = sector_cnt_ * 512;
-
-  memcpy(command_fis, &fis, sizeof(fis));
-}
-void DmaReadCommand::PopulatePrdt(PhysicalRegionDescriptor* prdt) {
-  prdt[0].region_address = region_.paddr();
-  prdt[0].byte_count = region_.size();
-}
-void DmaReadCommand::Callback() { callback_(lba_, sector_cnt_, region_.cap()); }

sys/denali/ahci/command.h

@@ -1,33 +0,0 @@
-#pragma once
-
-#include <mammoth/memory_region.h>
-#include <stdint.h>
-
-#include "ahci/ahci.h"
-
-class Command {
- public:
-  virtual ~Command();
-  virtual void PopulateFis(uint8_t* command_fis) = 0;
-  virtual void PopulatePrdt(PhysicalRegionDescriptor* prdt) = 0;
-  virtual void Callback() = 0;
-};
-
-class DmaReadCommand : public Command {
- public:
-  typedef void (*DmaCallback)(uint64_t, uint64_t, uint64_t);
-  DmaReadCommand(uint64_t lba, uint64_t sector_cnt, DmaCallback callback);
-
-  virtual ~DmaReadCommand() override;
-
-  void PopulateFis(uint8_t* command_fis) override;
-  void PopulatePrdt(PhysicalRegionDescriptor* prdt) override;
-
-  void Callback() override;
-
- private:
-  uint64_t lba_;
-  uint64_t sector_cnt_;
-  DmaCallback callback_;
-  MappedMemoryRegion region_;
-};

sys/denali/denali_server.cpp

@@ -3,17 +3,8 @@
 #include <mammoth/debug.h>
 #include <zcall.h>
 
-namespace {
-DenaliServer* gServer = nullptr;
-void HandleResponse(uint64_t lba, uint64_t size, uint64_t cap) {
-  gServer->HandleResponse(lba, size, cap);
-}
-}  // namespace
-
 DenaliServer::DenaliServer(uint64_t channel_cap, AhciDriver& driver)
-    : channel_cap_(channel_cap), driver_(driver) {
+    : channel_cap_(channel_cap), driver_(driver) {}
-  gServer = this;
-}
 
 z_err_t DenaliServer::RunServer() {
   while (true) {
@@ -29,7 +20,12 @@ z_err_t DenaliServer::RunServer() {
       case DENALI_READ: {
         DenaliRead* read_req = reinterpret_cast<DenaliRead*>(read_buffer_);
         uint64_t memcap = 0;
-        RET_ERR(HandleRead(*read_req));
+        DenaliReadResponse resp;
+        RET_ERR(HandleRead(*read_req, resp, memcap));
+        uint64_t caps_len = memcap ? 1 : 0;
+        RET_ERR(ZChannelSend(channel_cap_, 0, sizeof(DenaliReadResponse),
+                             reinterpret_cast<uint8_t*>(&resp), caps_len,
+                             &memcap));
         break;
       }
       default:
@@ -39,22 +35,10 @@ z_err_t DenaliServer::RunServer() {
   }
 }
 
-z_err_t DenaliServer::HandleRead(const DenaliRead& read) {
+z_err_t DenaliServer::HandleRead(const DenaliRead& read,
-  AhciDevice* device;
+                                 DenaliReadResponse& resp, uint64_t& memcap) {
-  RET_ERR(driver_.GetDevice(read.device_id, &device));
+  AhciDevice device;
-
+  RET_ERR(driver_.GetDevice(read.device_id, device));
-  device->IssueCommand(
-      new DmaReadCommand(read.lba, read.size, ::HandleResponse));
 
   return Z_OK;
 }
-
-void DenaliServer::HandleResponse(uint64_t lba, uint64_t size, uint64_t cap) {
-  DenaliReadResponse resp{
-      .device_id = 0,
-      .lba = lba,
-      .size = size,
-  };
-  check(ZChannelSend(channel_cap_, DENALI_READ, sizeof(resp),
-                     reinterpret_cast<uint8_t*>(&resp), 1, &cap));
-}

sys/denali/denali_server.h

@@ -9,8 +9,6 @@ class DenaliServer {
 
   z_err_t RunServer();
 
-  void HandleResponse(uint64_t lba, uint64_t size, uint64_t cap);
-
  private:
   static const uint64_t kBuffSize = 1024;
   uint64_t channel_cap_;
@@ -18,5 +16,6 @@ class DenaliServer {
 
   AhciDriver& driver_;
 
-  z_err_t HandleRead(const DenaliRead& read);
+  z_err_t HandleRead(const DenaliRead& read, DenaliReadResponse& resp,
+                     uint64_t& mem_cap);
 };

sys/yellowstone/yellowstone.cpp

@@ -6,34 +6,14 @@
 
 #include "hw/pcie.h"
 
-int main() {
+uint64_t main() {
   dbgln("Yellowstone Initializing.");
   uint64_t vaddr;
   check(ZAddressSpaceMap(Z_INIT_VMAS_SELF, 0, Z_INIT_BOOT_VMMO, &vaddr));
 
   Channel local;
   check(SpawnProcessFromElfRegion(vaddr, local));
-
+  local.WriteStr("Hello!");
-  DenaliRead read{
-      .device_id = 0,
-      .lba = 0,
-      .size = 1,
-  };
-  check(ZChannelSend(local.cap(), DENALI_READ, sizeof(DenaliRead),
-                     reinterpret_cast<uint8_t*>(&read), 0, nullptr));
-
-  DenaliReadResponse resp;
-  uint64_t mem_cap, type, bytes, caps;
-
-  check(ZChannelRecv(local.cap(), sizeof(resp),
-                     reinterpret_cast<uint8_t*>(&resp), 1, &mem_cap, &type,
-                     &bytes, &caps));
-
-  dbgln("Resp: %u", type);
-
-  check(ZAddressSpaceMap(Z_INIT_VMAS_SELF, 0, mem_cap, &vaddr));
-  uint32_t* mbr = reinterpret_cast<uint32_t*>(vaddr + 0x1FE);
-  dbgln("MBR: %x", *mbr);
 
   DumpPciEDevices();
 

zion/object/channel.cpp

@@ -82,9 +82,7 @@ z_err_t Channel::EnqueueMessage(const ZMessage& msg) {
   pending_messages_.PushBack(message);
 
   if (blocked_threads_.size() > 0) {
-    auto thread = blocked_threads_.PopFront();
+    gScheduler->Enqueue(blocked_threads_.PopFront());
-    thread->SetState(Thread::RUNNABLE);
-    gScheduler->Enqueue(thread);
   }
   return Z_OK;
 }

zion/object/port.cpp

@@ -27,9 +27,7 @@ z_err_t Port::Write(const ZMessage& msg) {
   MutexHolder lock(mutex_);
   pending_messages_.PushBack(message);
   if (blocked_threads_.size() > 0) {
-    auto thread = blocked_threads_.PopFront();
+    gScheduler->Enqueue(blocked_threads_.PopFront());
-    thread->SetState(Thread::RUNNABLE);
-    gScheduler->Enqueue(thread);
   }
   return Z_OK;
 }