Further parse AHCI information.

Send an IDENTIFY command to each drive and set up a hook to handle
interrupts.

zion/CMakeLists.txt

@@ -19,6 +19,7 @@ add_executable(zion
   object/address_space.cpp
   object/channel.cpp
   object/memory_object.cpp
+  object/port.cpp
   object/process.cpp
   object/thread.cpp
   scheduler/context_switch.s

zion/capability/capability.cpp

@@ -42,3 +42,11 @@ RefPtr<Channel> Capability::obj<Channel>() {
   }
   return StaticCastRefPtr<Channel>(obj_);
 }
+
+template <>
+RefPtr<Port> Capability::obj<Port>() {
+  if (type_ != PORT) {
+    panic("Accessing %u cap as object.", type_);
+  }
+  return StaticCastRefPtr<Port>(obj_);
+}

zion/capability/capability.h

@@ -17,6 +17,7 @@ class Capability : public RefCounted<Capability> {
     ADDRESS_SPACE,
     MEMORY_OBJECT,
     CHANNEL,
+    PORT,
   };
   Capability(const RefPtr<KernelObject>& obj, Type type, uint64_t id,
              uint64_t permissions)

zion/include/zcall.h

@@ -43,6 +43,14 @@
 #define Z_CHANNEL_RECV 0x42
 #define Z_CHANNEL_SENDRECV 0x43
 
+#define Z_PORT_CREATE 0x50
+#define Z_PORT_SEND 0x51
+#define Z_PORT_RECV 0x52
+
+#define Z_IRQ_REGISTER 0x58
+
+#define Z_IRQ_PCI_BASE 0x30
+
 // Debugging Calls.
 #define Z_DEBUG_PRINT 0x10000000
 
@@ -70,6 +78,10 @@ void ZThreadExit();
 [[nodiscard]] z_err_t ZMemoryObjectCreate(uint64_t size, uint64_t* vmmo_cap);
 [[nodiscard]] z_err_t ZMemoryObjectCreatePhysical(uint64_t paddr, uint64_t size,
                                                   uint64_t* vmmo_cap);
+[[nodiscard]] z_err_t ZMemoryObjectCreateContiguous(uint64_t size,
+                                                    uint64_t* vmmo_cap,
+                                                    uint64_t* paddr);
+
 [[nodiscard]] z_err_t ZTempPcieConfigObjectCreate(uint64_t* vmmo_cap,
                                                   uint64_t* vmmo_size);
 
@@ -83,4 +95,10 @@ void ZThreadExit();
                                    uint64_t* actual_bytes,
                                    uint64_t* actual_caps);
 
+[[nodiscard]] z_err_t ZPortRecv(uint64_t port_cap, uint64_t num_bytes,
+                                uint8_t* bytes, uint64_t num_caps,
+                                uint64_t* caps, uint64_t* type,
+                                uint64_t* actual_bytes, uint64_t* actual_caps);
+[[nodiscard]] z_err_t ZIrqRegister(uint64_t irq_num, uint64_t* port_cap);
+
 [[nodiscard]] z_err_t ZDebug(const char* message);

zion/interrupt/apic.cpp

@@ -7,7 +7,7 @@
 #include "common/port.h"
 #include "debug/debug.h"
 
-#define APIC_DEBUG 0
+#define APIC_DEBUG 1
 
 namespace {
 
@@ -17,6 +17,7 @@ namespace {
 
 const uint64_t kEoiOffset = 0xB0;
 
+// FIXME: parse these from madt.
 constexpr uint64_t kLApicBase = 0xFEE0'0000;
 constexpr uint64_t kIoApicAddr = 0xFEC0'0000;
 constexpr uint64_t kIoApicData = 0xFEC0'0010;
@@ -88,7 +89,6 @@ void InspectApic() {
   dbgln("TPR: %x", GetLocalReg(0x80));
   dbgln("APR: %x", GetLocalReg(0x90));
   dbgln("PPR: %x", GetLocalReg(0xA0));
-  dbgln("RRD: %x", GetLocalReg(0xC0));
   dbgln("LDR: %x", GetLocalReg(0xD0));
   dbgln("DFR: %x", GetLocalReg(0xE0));
   dbgln("SIV: %x", GetLocalReg(0xF0));
@@ -119,10 +119,22 @@ void EnableApic() {
   SetIoEntry(0x14, 0x20);
   // Skip Keyboard for now.
   // SetIoEntry(0x12, 0x21);
+
+  // TODO: This also works with the interrupt numbers provided by the MADT
+  // I need to do further investigation on the difference in this case and
+  // also how to find a declarative spec for where the PCI Lines are mapped.
+
+  // PCI Line 1-4
+  // FIXME: These should be level triggered according to spec I believe
+  // but because we handle the interrupt outside of the kernel it is tricky
+  // to wait to send the end of interrupt message.
+  // Because of this leave them as edge triggered and send EOI immediately.
+  SetIoEntry(0x30, 0x30);
+  SetIoEntry(0x32, 0x31);
+  SetIoEntry(0x34, 0x32);
+  SetIoEntry(0x36, 0x33);
+
   InspectApic();
 }
 
-void SignalEOI() {
-  // Value doesn't matter.
-  WriteLocalReg(kEoiOffset, 0x1);
-}
+void SignalEOI() { WriteLocalReg(kEoiOffset, 0x0); }

zion/interrupt/interrupt.cpp

@@ -138,11 +138,44 @@ extern "C" void interrupt_timer(InterruptFrame*) {
   gScheduler->Preempt();
 }
 
+RefPtr<Port> pci1_port;
+extern "C" void isr_pci1();
+extern "C" void interrupt_pci1(InterruptFrame*) {
+  dbgln("Interrupt PCI line 1");
+  pci1_port->Write({});
+  SignalEOI();
+}
+
+extern "C" void isr_pci2();
+extern "C" void interrupt_pci2(InterruptFrame*) {
+  dbgln("Interrupt PCI line 2");
+  SignalEOI();
+}
+
+extern "C" void isr_pci3();
+extern "C" void interrupt_pci3(InterruptFrame*) {
+  dbgln("Interrupt PCI line 3");
+  SignalEOI();
+}
+
+extern "C" void isr_pci4();
+extern "C" void interrupt_pci4(InterruptFrame*) {
+  dbgln("Interrupt PCI line 4");
+  SignalEOI();
+}
+
 void InitIdt() {
   gIdt[0] = CreateDescriptor(isr_divide_by_zero);
   gIdt[13] = CreateDescriptor(isr_protection_fault);
   gIdt[14] = CreateDescriptor(isr_page_fault);
-  gIdt[32] = CreateDescriptor(isr_timer);
+
+  gIdt[0x20] = CreateDescriptor(isr_timer);
+
+  gIdt[0x30] = CreateDescriptor(isr_pci1);
+  gIdt[0x31] = CreateDescriptor(isr_pci2);
+  gIdt[0x32] = CreateDescriptor(isr_pci3);
+  gIdt[0x33] = CreateDescriptor(isr_pci4);
+
   InterruptDescriptorTablePointer idtp{
       .size = sizeof(gIdt),
       .base = reinterpret_cast<uint64_t>(gIdt),
@@ -151,3 +184,5 @@ void InitIdt() {
 
   EnableApic();
 }
+
+void RegisterPciPort(const RefPtr<Port>& port) { pci1_port = port; }

zion/interrupt/interrupt.h

@@ -1,3 +1,8 @@
 #pragma once
 
+#include "lib/ref_ptr.h"
+#include "object/port.h"
+
 void InitIdt();
+
+void RegisterPciPort(const RefPtr<Port>& port);

zion/memory/physical_memory.cpp

@@ -63,6 +63,34 @@ class PhysicalMemoryManager {
     }
     return page;
   }
+  uint64_t AllocateContinuous(uint64_t num_pages) {
+    if (front_ == nullptr) {
+      panic("No available memory regions.");
+    }
+
+    if (front_->num_pages == 0) {
+      panic("Bad state, empty memory block.");
+    }
+
+    MemBlock* block = front_;
+    while (block != nullptr && block->num_pages < num_pages) {
+      block = block->next;
+    }
+
+    if (block == nullptr) {
+      panic("No memory regions to allocate");
+    }
+
+    uint64_t page = front_->base;
+    front_->base += num_pages * 0x1000;
+    front_->num_pages -= num_pages;
+    if (front_->num_pages == 0) {
+      MemBlock* temp = front_;
+      front_ = front_->next;
+      delete temp;
+    }
+    return page;
+  }
   void FreePage(uint64_t page) { AddMemoryRegion(page, 0x1000); }
 
  private:
@@ -129,4 +157,12 @@ uint64_t AllocatePage() {
   return page;
 }
 
+uint64_t AllocateContinuous(uint64_t num_continuous) {
+  if (gPmm == nullptr) {
+    panic("No physical memory manager!");
+  }
+
+  return gPmm->AllocateContinuous(num_continuous);
+}
+
 }  // namespace phys_mem

zion/memory/physical_memory.h

@@ -13,6 +13,7 @@ void InitBootstrapPageAllocation();
 void InitPhysicalMemoryManager();
 
 uint64_t AllocatePage();
+uint64_t AllocateContinuous(uint64_t num_pages);
 void FreePage(uint64_t page);
 
 }  // namespace phys_mem

zion/object/memory_object.h

@@ -35,6 +35,7 @@ class MemoryObject : public KernelObject {
 
 class FixedMemoryObject : public MemoryObject {
  public:
+  // FIXME: Validate that this is 4k aligned.
   FixedMemoryObject(uint64_t physical_addr, uint64_t size)
       : MemoryObject(size, true), physical_addr_(physical_addr) {}
 

zion/object/port.cpp

@@ -0,0 +1,50 @@
+#include "object/port.h"
+
+Port::Port() {}
+
+z_err_t Port::Write(const ZMessage& msg) {
+  if (msg.num_caps > 0) {
+    dbgln("Unimplemented passing caps on port");
+    return Z_ERR_UNIMPLEMENTED;
+  }
+
+  if (msg.num_bytes > 0x1000) {
+    dbgln("Large message size unimplemented: %x", msg.num_bytes);
+    return Z_ERR_INVALID;
+  }
+
+  Message message{
+      .type = msg.type,
+      .num_bytes = msg.num_bytes,
+      .bytes = new uint8_t[msg.num_bytes],
+  };
+  for (uint64_t i = 0; i < msg.num_bytes; i++) {
+    message.bytes[i] = msg.bytes[i];
+  }
+  pending_messages_.PushBack(message);
+  return Z_OK;
+}
+
+z_err_t Port::Read(ZMessage& msg) {
+  if (pending_messages_.size() < 1) {
+    dbgln("Implement blocking");
+    return Z_ERR_UNIMPLEMENTED;
+  }
+
+  Message next_msg = pending_messages_.PeekFront();
+  if (next_msg.num_bytes > msg.num_bytes) {
+    return Z_ERR_BUFF_SIZE;
+  }
+
+  msg.type = next_msg.type;
+  msg.num_bytes = next_msg.num_bytes;
+  msg.num_caps = 0;
+
+  for (uint64_t i = 0; i < msg.num_bytes; i++) {
+    msg.bytes[i] = next_msg.bytes[i];
+  }
+
+  pending_messages_.PopFront();
+
+  return Z_OK;
+}

zion/object/port.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "lib/linked_list.h"
+#include "object/kernel_object.h"
+#include "usr/zcall_internal.h"
+
+class Port : public KernelObject {
+ public:
+  Port();
+
+  z_err_t Write(const ZMessage& msg);
+  z_err_t Read(ZMessage& msg);
+
+ private:
+  struct Message {
+    uint64_t type;
+    uint64_t num_bytes;
+    uint8_t* bytes;
+  };
+
+  LinkedList<Message> pending_messages_;
+};

zion/object/process.cpp

@@ -127,6 +127,13 @@ uint64_t Process::AddCapability(const RefPtr<Channel>& chan) {
   return cap_id;
 }
 
+uint64_t Process::AddCapability(const RefPtr<Port>& port) {
+  uint64_t cap_id = next_cap_id_++;
+  caps_.PushBack(MakeRefCounted<Capability>(port, Capability::PORT, cap_id,
+                                            ZC_WRITE | ZC_READ));
+  return cap_id;
+}
+
 void Process::AddCapability(uint64_t cap_id, const RefPtr<MemoryObject>& vmmo) {
   caps_.PushBack(MakeRefCounted<Capability>(vmmo, Capability::MEMORY_OBJECT,
                                             cap_id, ZC_WRITE));

zion/object/process.h

@@ -7,6 +7,7 @@
 #include "lib/ref_ptr.h"
 #include "object/address_space.h"
 #include "object/channel.h"
+#include "object/port.h"
 
 // Forward decl due to cyclic dependency.
 class Thread;
@@ -37,6 +38,7 @@ class Process : public KernelObject {
   uint64_t AddCapability(const RefPtr<AddressSpace>& vmas);
   uint64_t AddCapability(const RefPtr<MemoryObject>& vmmo);
   uint64_t AddCapability(const RefPtr<Channel>& chan);
+  uint64_t AddCapability(const RefPtr<Port>& chan);
 
   void AddCapability(uint64_t cap_id, const RefPtr<MemoryObject>& vmmo);
   // Checks the state of all child threads and transitions to

zion/scheduler/scheduler.cpp

@@ -40,11 +40,13 @@ void Scheduler::Preempt() {
   if (current_thread_ == sleep_thread_) {
     // Sleep should never be preempted. (We should yield it if another thread
     // becomes scheduleable).
+    asm volatile("sti");
     return;
   }
 
   if (runnable_threads_.size() == 0) {
     // Continue.
+    asm volatile("sti");
     return;
   }
 

zion/syscall/syscall.cpp

@@ -7,7 +7,10 @@
 #include "debug/debug.h"
 #include "include/zcall.h"
 #include "include/zerrors.h"
+#include "interrupt/interrupt.h"
+#include "memory/physical_memory.h"
 #include "object/channel.h"
+#include "object/port.h"
 #include "object/process.h"
 #include "scheduler/process_manager.h"
 #include "scheduler/scheduler.h"
@@ -131,11 +134,16 @@ z_err_t MemoryObjectCreate(ZMemoryObjectCreateReq* req,
 }
 
 z_err_t MemoryObjectCreatePhysical(ZMemoryObjectCreatePhysicalReq* req,
-                                   ZMemoryObjectCreateResp* resp) {
+                                   ZMemoryObjectCreatePhysicalResp* resp) {
   auto& curr_proc = gScheduler->CurrentProcess();
-  auto vmmo_ref = MakeRefCounted<FixedMemoryObject>(req->paddr, req->size);
+  uint64_t paddr = req->paddr;
+  if (paddr == 0) {
+    paddr = phys_mem::AllocateContinuous((req->size - 1 / 0x1000) + 1);
+  }
+  auto vmmo_ref = MakeRefCounted<FixedMemoryObject>(paddr, req->size);
   resp->vmmo_cap =
       curr_proc.AddCapability(StaticCastRefPtr<MemoryObject>(vmmo_ref));
+  resp->paddr = paddr;
   return Z_OK;
 }
 
@@ -174,7 +182,30 @@ z_err_t ChannelRecv(ZChannelRecvReq* req) {
   RET_ERR(ValidateCap(chan_cap, Capability::CHANNEL, ZC_READ));
 
   auto chan = chan_cap->obj<Channel>();
-  chan->Read(req->message);
+  return chan->Read(req->message);
+}
+
+z_err_t PortRecv(ZPortRecvReq* req) {
+  auto& proc = gScheduler->CurrentProcess();
+  dbgln("Port cap %u", req->port_cap);
+  auto port_cap = proc.GetCapability(req->port_cap);
+  RET_ERR(ValidateCap(port_cap, Capability::PORT, ZC_READ));
+
+  auto port = port_cap->obj<Port>();
+  return port->Read(req->message);
+}
+
+z_err_t IrqRegister(ZIrqRegisterReq* req, ZIrqRegisterResp* resp) {
+  auto& proc = gScheduler->CurrentProcess();
+  if (req->irq_num != Z_IRQ_PCI_BASE) {
+    // FIXME: Don't hardcode this nonsense.
+    dbgln("Irq %x", req->irq_num);
+    return Z_ERR_UNIMPLEMENTED;
+  }
+  RefPtr<Port> port = MakeRefCounted<Port>();
+  resp->port_cap = proc.AddCapability(port);
+  dbgln("Port cap %u", resp->port_cap);
+  RegisterPciPort(port);
   return Z_OK;
 }
 
@@ -210,7 +241,7 @@ extern "C" z_err_t SyscallHandler(uint64_t call_id, void* req, void* resp) {
     case Z_MEMORY_OBJECT_CREATE_PHYSICAL:
       return MemoryObjectCreatePhysical(
           reinterpret_cast<ZMemoryObjectCreatePhysicalReq*>(req),
-          reinterpret_cast<ZMemoryObjectCreateResp*>(resp));
+          reinterpret_cast<ZMemoryObjectCreatePhysicalResp*>(resp));
     case Z_TEMP_PCIE_CONFIG_OBJECT_CREATE:
       return TempPcieConfigObjectCreate(
           reinterpret_cast<ZTempPcieConfigObjectCreateResp*>(resp));
@@ -220,6 +251,11 @@ extern "C" z_err_t SyscallHandler(uint64_t call_id, void* req, void* resp) {
       return ChannelSend(reinterpret_cast<ZChannelSendReq*>(req));
     case Z_CHANNEL_RECV:
       return ChannelRecv(reinterpret_cast<ZChannelRecvReq*>(req));
+    case Z_PORT_RECV:
+      return PortRecv(reinterpret_cast<ZPortRecvReq*>(req));
+    case Z_IRQ_REGISTER:
+      return IrqRegister(reinterpret_cast<ZIrqRegisterReq*>(req),
+                         reinterpret_cast<ZIrqRegisterResp*>(resp));
     case Z_DEBUG_PRINT:
       dbgln("[Debug] %s", req);
       return Z_OK;

zion/usr/zcall.cpp

@@ -90,12 +90,25 @@ z_err_t ZMemoryObjectCreatePhysical(uint64_t paddr, uint64_t size,
       .paddr = paddr,
       .size = size,
   };
-  ZMemoryObjectCreateResp resp;
+  ZMemoryObjectCreatePhysicalResp resp;
   z_err_t ret = SysCall2(Z_MEMORY_OBJECT_CREATE_PHYSICAL, &req, &resp);
   *vmmo_cap = resp.vmmo_cap;
   return ret;
 }
 
+z_err_t ZMemoryObjectCreateContiguous(uint64_t size, uint64_t* vmmo_cap,
+                                      uint64_t* paddr) {
+  ZMemoryObjectCreatePhysicalReq req{
+      .paddr = 0,
+      .size = size,
+  };
+  ZMemoryObjectCreatePhysicalResp resp;
+  z_err_t ret = SysCall2(Z_MEMORY_OBJECT_CREATE_PHYSICAL, &req, &resp);
+  *vmmo_cap = resp.vmmo_cap;
+  *paddr = resp.paddr;
+  return ret;
+}
+
 z_err_t ZTempPcieConfigObjectCreate(uint64_t* vmmo_cap, uint64_t* vmmo_size) {
   ZTempPcieConfigObjectCreateResp resp;
   z_err_t ret = SysCall2(Z_TEMP_PCIE_CONFIG_OBJECT_CREATE, 0, &resp);
@@ -150,4 +163,35 @@ z_err_t ZChannelRecv(uint64_t chan_cap, uint64_t num_bytes, uint8_t* bytes,
   return ret;
 }
 
+z_err_t ZPortRecv(uint64_t port_cap, uint64_t num_bytes, uint8_t* bytes,
+                  uint64_t num_caps, uint64_t* caps, uint64_t* type,
+                  uint64_t* actual_bytes, uint64_t* actual_caps) {
+  ZPortRecvReq req{
+      .port_cap = port_cap,
+      .message =
+          {
+              .type = 0,
+              .num_bytes = num_bytes,
+              .bytes = bytes,
+              .num_caps = num_caps,
+              .caps = caps,
+          },
+  };
+  z_err_t ret = SysCall1(Z_PORT_RECV, &req);
+  *type = req.message.type;
+  *actual_bytes = req.message.num_bytes;
+  *actual_caps = req.message.num_caps;
+  return ret;
+}
+
+z_err_t ZIrqRegister(uint64_t irq_num, uint64_t* port_cap) {
+  ZIrqRegisterReq req{
+      .irq_num = irq_num,
+  };
+  ZIrqRegisterResp resp;
+  z_err_t ret = SysCall2(Z_IRQ_REGISTER, &req, &resp);
+  *port_cap = resp.port_cap;
+  return ret;
+}
+
 z_err_t ZDebug(const char* message) { return SysCall1(Z_DEBUG_PRINT, message); }

zion/usr/zcall_internal.h

@@ -51,6 +51,11 @@ struct ZMemoryObjectCreatePhysicalReq {
   uint64_t size;
 };
 
+struct ZMemoryObjectCreatePhysicalResp {
+  uint64_t vmmo_cap;
+  uint64_t paddr;
+};
+
 struct ZTempPcieConfigObjectCreateResp {
   uint64_t vmmo_cap;
   uint64_t vmmo_size;
@@ -80,3 +85,16 @@ struct ZChannelRecvReq {
   uint64_t chan_cap;
   ZMessage message;
 };
+
+struct ZPortRecvReq {
+  uint64_t port_cap;
+  ZMessage message;
+};
+
+struct ZIrqRegisterReq {
+  uint64_t irq_num;
+};
+
+struct ZIrqRegisterResp {
+  uint64_t port_cap;
+};