[Denali] Update HBA pointers to volatile. Store CommandList in arrayview.

For now this can only sleep in increments of the scheduler quantum
(currently 50ms). It also uses a somewhat ineffecient way of tracking
the sleeping threads - it will scale linearly with the number of
sleeping threads.

lib/glacier/container/array_view.h

@@ -10,7 +10,9 @@ class ArrayView {
   ArrayView() : data_(nullptr), size_(0) {}
 
   ArrayView(const ArrayView&) = default;
+  ArrayView& operator=(const ArrayView&) = default;
   ArrayView(ArrayView&&) = default;
+  ArrayView& operator=(ArrayView&&) = default;
 
   ArrayView(T* data, uint64_t size) : data_(data), size_(size) {}
 

lib/glacier/container/intrusive_list.h

@@ -20,6 +20,8 @@ class IntrusiveList {
   void PushFront(const RefPtr<T>& obj);
   void PushBack(const RefPtr<T>& obj);
 
+  void Remove(const RefPtr<T>& obj);
+
   RefPtr<T> PopFront();
   RefPtr<T> PopBack();
 
@@ -64,6 +66,29 @@ void IntrusiveList<T>::PushBack(const RefPtr<T>& obj) {
   back_ = obj;
 }
 
+template <typename T>
+void IntrusiveList<T>::Remove(const RefPtr<T>& obj) {
+  if (!obj) {
+    return;
+  }
+  if (front_ == obj) {
+    front_ = obj->next_;
+  }
+  if (back_ == obj) {
+    back_ = obj->prev_;
+  }
+  if (obj->prev_) {
+    obj->prev_->next_ = obj->next_;
+  }
+  if (obj->next_) {
+    obj->next_->prev_ = obj->prev_;
+  }
+
+  obj->prev_ = nullptr;
+  obj->next_ = nullptr;
+  size_--;
+}
+
 template <typename T>
 RefPtr<T> IntrusiveList<T>::PopFront() {
   if (front_ == nullptr) {

sys/denali/CMakeLists.txt

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

sys/denali/ahci/ahci.h

@@ -37,6 +37,10 @@ struct PciMsiCap {
   uint16_t message_data;
 } __attribute__((packed));
 
+const uint32_t kGlobalHostControl_HW_Reset = 1;
+const uint32_t kGlobalHostControl_AHCI_Enable = (1 << 31);
+const uint32_t kGlobalHostControl_Interrupt_Enable = (1 << 1);
+
 struct AhciHba {
   uint32_t capabilities;
   uint32_t global_host_control;
@@ -51,6 +55,9 @@ struct AhciHba {
   uint32_t bohc;  // 0x28, BIOS/OS handoff control and status
 } __attribute__((packed));
 
+const uint32_t kCommand_FIS_Receive_Enable = (1 << 4);
+const uint32_t kCommand_Start = 1;
+
 struct AhciPort {
   uint64_t command_list_base;
   uint64_t fis_base;

sys/denali/ahci/ahci_controller.cpp

@@ -1,4 +1,4 @@
-#include "ahci/ahci_driver.h"
+#include "ahci/ahci_controller.h"
 
 #include <glacier/status/error.h>
 #include <glacier/status/error_or.h>
@@ -11,7 +11,7 @@ namespace {
 const uint64_t kGhc_InteruptEnable = 0x2;
 
 void interrupt_thread(void* void_driver) {
-  AhciDriver* driver = static_cast<AhciDriver*>(void_driver);
+  AhciController* driver = static_cast<AhciController*>(void_driver);
 
   driver->InterruptLoop();
 
@@ -20,31 +20,32 @@ void interrupt_thread(void* void_driver) {
 
 }  // namespace
 
-glcr::ErrorOr<glcr::UniquePtr<AhciDriver>> AhciDriver::Init(
+glcr::ErrorOr<glcr::UniquePtr<AhciController>> AhciController::Init(
     mmth::OwnedMemoryRegion&& pci_region) {
-  glcr::UniquePtr<AhciDriver> driver(new AhciDriver(glcr::Move(pci_region)));
-  // RET_ERR(driver->LoadCapabilities());
+  glcr::UniquePtr<AhciController> driver(
+      new AhciController(glcr::Move(pci_region)));
   RET_ERR(driver->LoadHbaRegisters());
-  RET_ERR(driver->LoadDevices());
+  driver->DumpCapabilities();
+  RET_ERR(driver->ResetHba());
   RET_ERR(driver->RegisterIrq());
-  // driver->DumpCapabilities();
+  RET_ERR(driver->LoadDevices());
   // driver->DumpPorts();
   return driver;
 }
 
-glcr::ErrorOr<AhciDevice*> AhciDriver::GetDevice(uint64_t id) {
+glcr::ErrorOr<AhciDevice*> AhciController::GetDevice(uint64_t id) {
   if (id >= 32) {
     return glcr::INVALID_ARGUMENT;
   }
 
-  if (devices_[id] != nullptr && !devices_[id]->IsInit()) {
+  if (devices_[id].empty()) {
     return glcr::NOT_FOUND;
   }
 
-  return devices_[id];
+  return devices_[id].get();
 }
 
-void AhciDriver::DumpCapabilities() {
+void AhciController::DumpCapabilities() {
   dbgln("AHCI Capabilities:");
   uint32_t caps = ahci_hba_->capabilities;
 
@@ -122,26 +123,25 @@ void AhciDriver::DumpCapabilities() {
   dbgln("Control {x}", ahci_hba_->global_host_control);
 }
 
-void AhciDriver::DumpPorts() {
+void AhciController::DumpPorts() {
   for (uint64_t i = 0; i < 6; i++) {
-    AhciDevice* dev = devices_[i];
-    if (dev == nullptr || !dev->IsInit()) {
+    if (devices_[i].empty()) {
       continue;
     }
 
     dbgln("");
     dbgln("Port {}:", i);
-    dev->DumpInfo();
+    devices_[i]->DumpInfo();
   }
 }
 
-void AhciDriver::InterruptLoop() {
+void AhciController::InterruptLoop() {
   dbgln("Starting interrupt loop");
   while (true) {
     uint64_t bytes, caps;
     check(ZPortRecv(irq_port_cap_, &bytes, nullptr, &caps, nullptr));
     for (uint64_t i = 0; i < 32; i++) {
-      if (devices_[i] != nullptr && devices_[i]->IsInit() &&
+      if (!devices_[i].empty() && devices_[i]->IsInit() &&
           (ahci_hba_->interrupt_status & (1 << i))) {
         devices_[i]->HandleIrq();
         ahci_hba_->interrupt_status &= ~(1 << i);
@@ -150,15 +150,17 @@ void AhciDriver::InterruptLoop() {
   }
 }
 
-glcr::ErrorCode AhciDriver::LoadCapabilities() {
+glcr::ErrorCode AhciController::LoadCapabilities() {
   if (!(pci_device_header_->status_reg & 0x10)) {
     dbgln("No caps!");
     return glcr::FAILED_PRECONDITION;
   }
-  uint8_t* base = reinterpret_cast<uint8_t*>(pci_device_header_);
+  volatile uint8_t* base =
+      reinterpret_cast<volatile uint8_t*>(pci_device_header_);
   uint16_t offset = pci_device_header_->cap_ptr;
   do {
-    uint16_t* cap = reinterpret_cast<uint16_t*>(base + offset);
+    volatile uint16_t* cap =
+        reinterpret_cast<volatile uint16_t*>(base + offset);
     switch (*cap & 0xFF) {
       case 0x01:
         dbgln("Power Management");
@@ -179,7 +181,7 @@ glcr::ErrorCode AhciDriver::LoadCapabilities() {
   return glcr::OK;
 }
 
-glcr::ErrorCode AhciDriver::RegisterIrq() {
+glcr::ErrorCode AhciController::RegisterIrq() {
   if (pci_device_header_->interrupt_pin == 0) {
     crash("Can't register IRQ without a pin num", glcr::INVALID_ARGUMENT);
   }
@@ -205,7 +207,7 @@ glcr::ErrorCode AhciDriver::RegisterIrq() {
   return glcr::OK;
 }
 
-glcr::ErrorCode AhciDriver::LoadHbaRegisters() {
+glcr::ErrorCode AhciController::LoadHbaRegisters() {
   ahci_region_ = mmth::OwnedMemoryRegion ::DirectPhysical(
       pci_device_header_->abar, 0x1100);
   ahci_hba_ = reinterpret_cast<AhciHba*>(ahci_region_.vaddr());
@@ -215,15 +217,34 @@ glcr::ErrorCode AhciDriver::LoadHbaRegisters() {
   return glcr::OK;
 }
 
-glcr::ErrorCode AhciDriver::LoadDevices() {
-  for (uint8_t i = 0; i < 32; i++) {
+glcr::ErrorCode AhciController::ResetHba() {
+  ahci_hba_->global_host_control |= kGlobalHostControl_HW_Reset;
+
+  // TODO: Consider sleeping here.
+  while (ahci_hba_->global_host_control & kGlobalHostControl_HW_Reset) {
+    continue;
+  }
+
+  ahci_hba_->global_host_control |= kGlobalHostControl_AHCI_Enable;
+
+  return static_cast<glcr::ErrorCode>(ZThreadSleep(50));
+}
+
+glcr::ErrorCode AhciController::LoadDevices() {
+  for (uint8_t i = 0; i <= num_ports_; i++) {
     if (!(ahci_hba_->port_implemented & (1 << i))) {
-      devices_[i] = nullptr;
       continue;
     }
+
     uint64_t port_addr =
         reinterpret_cast<uint64_t>(ahci_hba_) + 0x100 + (0x80 * i);
+    AhciPort* port = reinterpret_cast<AhciPort*>(port_addr);
+    if ((port->sata_status & 0x103) != 0x103) {
+      continue;
+    }
+
     devices_[i] = new AhciDevice(reinterpret_cast<AhciPort*>(port_addr));
+    devices_[i]->DumpInfo();
   }
   return glcr::OK;
 }

sys/denali/ahci/ahci_controller.h

@@ -8,9 +8,9 @@
 #include "ahci/ahci.h"
 #include "ahci/ahci_device.h"
 
-class AhciDriver {
+class AhciController {
  public:
-  static glcr::ErrorOr<glcr::UniquePtr<AhciDriver>> Init(
+  static glcr::ErrorOr<glcr::UniquePtr<AhciController>> Init(
       mmth::OwnedMemoryRegion&& ahci_phys);
   glcr::ErrorCode RegisterIrq();
 
@@ -23,24 +23,24 @@ class AhciDriver {
 
  private:
   mmth::OwnedMemoryRegion pci_region_;
-  PciDeviceHeader* pci_device_header_ = nullptr;
+  volatile PciDeviceHeader* pci_device_header_ = nullptr;
   mmth::OwnedMemoryRegion ahci_region_;
-  AhciHba* ahci_hba_ = nullptr;
+  volatile AhciHba* ahci_hba_ = nullptr;
 
-  // TODO: Allocate these dynamically.
-  AhciDevice* devices_[32];
+  glcr::UniquePtr<AhciDevice> devices_[32];
 
   Thread irq_thread_;
   uint64_t irq_port_cap_ = 0;
 
-  uint64_t num_ports_;
-  uint64_t num_commands_;
+  uint8_t num_ports_;
+  uint8_t num_commands_;
 
   glcr::ErrorCode LoadCapabilities();
   glcr::ErrorCode LoadHbaRegisters();
+  glcr::ErrorCode ResetHba();
   glcr::ErrorCode LoadDevices();
 
-  AhciDriver(mmth::OwnedMemoryRegion&& pci_region)
+  AhciController(mmth::OwnedMemoryRegion&& pci_region)
       : pci_region_(glcr::Move(pci_region)),
         pci_device_header_(
             reinterpret_cast<PciDeviceHeader*>(pci_region_.vaddr())) {}

sys/denali/ahci/ahci_device.cpp

@@ -6,7 +6,8 @@
 
 AhciDevice::AhciDevice(AhciPort* port) : port_struct_(port) {
   if ((port_struct_->sata_status & 0x103) != 0x103) {
-    return;
+    crash("Creating device on port without a device",
+          glcr::FAILED_PRECONDITION);
   }
 
   // 0x0-0x400 -> Command List
@@ -22,35 +23,45 @@ AhciDevice::AhciDevice(AhciPort* port) : port_struct_(port) {
   received_fis_ =
       reinterpret_cast<ReceivedFis*>(command_structures_.vaddr() + 0x400);
   port_struct_->fis_base = paddr + 0x400;
+  port_struct_->command |= kCommand_FIS_Receive_Enable;
 
-  command_tables_ =
-      reinterpret_cast<CommandTable*>(command_structures_.vaddr() + 0x500);
+  command_tables_ = glcr::ArrayView(
+      reinterpret_cast<CommandTable*>(command_structures_.vaddr() + 0x500), 32);
 
   for (uint64_t i = 0; i < 32; i++) {
+    // This leaves space for 2 prdt entries.
     command_list_->command_headers[i].command_table_base_addr =
         (paddr + 0x500) + (0x100 * i);
+    commands_[i] = nullptr;
   }
   port_struct_->interrupt_enable = 0xFFFFFFFF;
-  // Reset the CMD and FRE bits since we move these structures.
-  // FIXME: I think we need to poll these bits to make sure they become
-  // 0 before setting them back to one.
-  port_struct_->command &= ~(0x00000011);
-  port_struct_->command |= 0x00000011;
+  port_struct_->sata_error = -1;
+  port_struct_->command |= kCommand_Start;
 }
 
 glcr::ErrorCode AhciDevice::IssueCommand(Command* command) {
-  command->PopulateFis(command_tables_->command_fis);
-  command->PopulatePrdt(command_tables_->prdt);
+  uint64_t slot;
+  for (slot = 0; slot < 32; slot++) {
+    if (commands_[slot] == nullptr) {
+      break;
+    }
+  }
+  if (slot == 32) {
+    dbgln("All slots full");
+    return glcr::INTERNAL;
+  }
+  command->PopulateFis(command_tables_[slot].command_fis);
+  command->PopulatePrdt(command_tables_[slot].prdt);
 
-  command_list_->command_headers[0].command =
+  command_list_->command_headers[slot].command =
       (sizeof(HostToDeviceRegisterFis) / 2) & 0x1F;
-  command_list_->command_headers[0].prd_table_length = 1;
-  command_list_->command_headers[0].prd_byte_count = 0;
+  command_list_->command_headers[slot].prd_table_length = 1;
+  command_list_->command_headers[slot].prd_byte_count = 0;
 
-  commands_[0] = command;
+  commands_[slot] = command;
 
-  commands_issued_ |= 1;
-  port_struct_->command_issue |= 1;
+  commands_issued_ |= (1 << slot);
+  port_struct_->command_issue |= (1 << slot);
 
   return glcr::OK;
 }
@@ -61,17 +72,9 @@ void AhciDevice::DumpInfo() {
   dbgln("Command: {x}", port_struct_->command);
   dbgln("Signature: {x}", port_struct_->signature);
   dbgln("SATA status: {x}", port_struct_->sata_status);
+  dbgln("SATA error: {x}", port_struct_->sata_error);
   dbgln("Int status: {x}", port_struct_->interrupt_status);
   dbgln("Int enable: {x}", port_struct_->interrupt_enable);
-
-  // Just dump one command info for now.
-  for (uint64_t i = 0; i < 32; i++) {
-    dbgln("Command Header: {}", i);
-    dbgln("Command {x}", command_list_->command_headers[i].command);
-    dbgln("PRD Len: {x}", command_list_->command_headers[i].prd_table_length);
-    dbgln("Command Table {x}",
-          command_list_->command_headers[i].command_table_base_addr);
-  }
 }
 
 void AhciDevice::HandleIrq() {
@@ -92,7 +95,8 @@ void AhciDevice::HandleIrq() {
   // TODO: Do something with this information.
   if (int_status & 0x1) {
     // Device to host.
-    DeviceToHostRegisterFis& fis = received_fis_->device_to_host_register_fis;
+    volatile DeviceToHostRegisterFis& fis =
+        received_fis_->device_to_host_register_fis;
     if (fis.fis_type != FIS_TYPE_REG_D2H) {
       dbgln("BAD FIS TYPE (exp,act): {x}, {x}",
             static_cast<uint64_t>(FIS_TYPE_REG_D2H),
@@ -106,7 +110,7 @@ void AhciDevice::HandleIrq() {
   }
   if (int_status & 0x2) {
     // PIO.
-    PioSetupFis& fis = received_fis_->pio_set_fis;
+    volatile PioSetupFis& fis = received_fis_->pio_set_fis;
     if (fis.fis_type != FIS_TYPE_PIO_SETUP) {
       dbgln("BAD FIS TYPE (exp,act): {x}, {x}",
             static_cast<uint64_t>(FIS_TYPE_PIO_SETUP),

sys/denali/ahci/ahci_device.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <glacier/container/array_view.h>
 #include <glacier/status/error.h>
 #include <mammoth/util/memory_region.h>
 #include <ztypes.h>
@@ -25,13 +26,13 @@ class AhciDevice {
   AhciDevice& operator=(const AhciDevice&) = delete;
 
  private:
-  AhciPort* port_struct_ = nullptr;
+  volatile AhciPort* port_struct_ = nullptr;
   mmth::OwnedMemoryRegion command_structures_;
 
-  CommandList* command_list_ = nullptr;
-  ReceivedFis* received_fis_ = nullptr;
-  CommandTable* command_tables_ = nullptr;
+  volatile CommandList* command_list_ = nullptr;
+  volatile ReceivedFis* received_fis_ = nullptr;
+  glcr::ArrayView<CommandTable> command_tables_;
 
   Command* commands_[32];
-  volatile uint32_t commands_issued_ = 0;
+  uint32_t commands_issued_ = 0;
 };

sys/denali/denali.cpp

@@ -4,7 +4,7 @@
 #include <stdint.h>
 #include <yellowstone/yellowstone.yunq.client.h>
 
-#include "ahci/ahci_driver.h"
+#include "ahci/ahci_controller.h"
 #include "denali_server.h"
 
 using yellowstone::AhciInfo;
@@ -19,7 +19,7 @@ uint64_t main(uint64_t init_port_cap) {
   check(stub.GetAhciInfo(ahci));
   mmth::OwnedMemoryRegion ahci_region =
       mmth::OwnedMemoryRegion::FromCapability(ahci.ahci_region());
-  ASSIGN_OR_RETURN(auto driver, AhciDriver::Init(glcr::Move(ahci_region)));
+  ASSIGN_OR_RETURN(auto driver, AhciController::Init(glcr::Move(ahci_region)));
 
   ASSIGN_OR_RETURN(glcr::UniquePtr<DenaliServer> server,
                    DenaliServer::Create(*driver));

sys/denali/denali_server.cpp

@@ -6,7 +6,7 @@
 #include <zcall.h>
 
 glcr::ErrorOr<glcr::UniquePtr<DenaliServer>> DenaliServer::Create(
-    AhciDriver& driver) {
+    AhciController& driver) {
   z_cap_t cap;
   RET_ERR(ZEndpointCreate(&cap));
   return glcr::UniquePtr<DenaliServer>(new DenaliServer(cap, driver));

sys/denali/denali_server.h

@@ -2,13 +2,13 @@
 
 #include <glacier/status/error.h>
 
-#include "ahci/ahci_driver.h"
+#include "ahci/ahci_controller.h"
 #include "lib/denali/denali.yunq.server.h"
 
 class DenaliServer : public DenaliServerBase {
  public:
   static glcr::ErrorOr<glcr::UniquePtr<DenaliServer>> Create(
-      AhciDriver& driver);
+      AhciController& driver);
 
   glcr::Status HandleRead(const ReadRequest& req, ReadResponse& resp) override;
   glcr::Status HandleReadMany(const ReadManyRequest& req,
@@ -18,8 +18,8 @@ class DenaliServer : public DenaliServerBase {
   static const uint64_t kBuffSize = 1024;
   uint8_t read_buffer_[kBuffSize];
 
-  AhciDriver& driver_;
+  AhciController& driver_;
 
-  DenaliServer(z_cap_t endpoint_cap, AhciDriver& driver)
+  DenaliServer(z_cap_t endpoint_cap, AhciController& driver)
       : DenaliServerBase(endpoint_cap), driver_(driver) {}
 };

sys/teton/terminal.cpp

@@ -68,9 +68,14 @@ void Terminal::ExecuteCommand(const glcr::String& command) {
     }
     auto file = mmth::File::Open(tokens[1]);
 
-    // TODO: Wait until the process exits.
-    auto error_or_cap = mmth::SpawnProcessFromElfRegion(
-        (uint64_t)file.raw_ptr(), gInitEndpointCap);
+    z_cap_t endpoint;
+    if (ZCapDuplicate(gInitEndpointCap, kZionPerm_All, &endpoint) != glcr::OK) {
+      console_.WriteString("Couldn't duplicate yellowstone cap for spawn");
+      return;
+    }
+
+    auto error_or_cap =
+        mmth::SpawnProcessFromElfRegion((uint64_t)file.raw_ptr(), endpoint);
     if (!error_or_cap.ok()) {
       console_.WriteString(
           glcr::StrFormat("Error: {}\n", error_or_cap.error()));

usr/testbed/test.cpp

@@ -1,7 +1,10 @@
 #include <mammoth/util/debug.h>
+#include <zcall.h>
 
 uint64_t main(uint64_t init_port_cap) {
   dbgln("testbed");
+  check(ZThreadSleep(2000));
+  dbgln("testbed2");
 
   return glcr::OK;
 }

zion/include/zcall.h

@@ -17,6 +17,7 @@ SYS4(ThreadStart, z_cap_t, thread_cap, uint64_t, entry, uint64_t, arg1,
      uint64_t, arg2);
 SYS0(ThreadExit);
 SYS1(ThreadWait, z_cap_t, thread_cap);
+SYS1(ThreadSleep, uint64_t, millis);
 
 SYS5(AddressSpaceMap, z_cap_t, vmas_cap, uint64_t, vmas_offset, z_cap_t,
      vmmo_cap, uint64_t, align, uint64_t*, vaddr);

zion/include/ztypes.h

@@ -19,6 +19,7 @@ const uint64_t kZionThreadCreate = 0x10;
 const uint64_t kZionThreadStart = 0x11;
 const uint64_t kZionThreadExit = 0x12;
 const uint64_t kZionThreadWait = 0x13;
+const uint64_t kZionThreadSleep = 0x14;
 
 // Memory Calls
 const uint64_t kZionAddressSpaceMap = 0x21;

zion/object/thread.h

@@ -29,6 +29,7 @@ class Thread : public KernelObject, public glcr::IntrusiveListNode<Thread> {
     RUNNING,
     RUNNABLE,
     BLOCKED,
+    SLEEPING,
     CLEANUP,
     FINISHED,
   };
@@ -69,6 +70,9 @@ class Thread : public KernelObject, public glcr::IntrusiveListNode<Thread> {
 
   void Wait();
 
+  void SetSleepTicks(uint64_t sleep_ticks) { sleep_ticks_ = sleep_ticks; }
+  bool DecrementSleepTicks() { return --sleep_ticks_ == 0; }
+
  private:
   friend class glcr::MakeRefCountedFriend<Thread>;
   Thread(Process& proc, uint64_t tid);
@@ -79,6 +83,7 @@ class Thread : public KernelObject, public glcr::IntrusiveListNode<Thread> {
   State state_ = CREATED;
   bool is_kernel_ = false;
   uint64_t user_stack_base_;
+  uint64_t sleep_ticks_;
 
   // Startup Context for the thread.
   uint64_t rip_;

zion/scheduler/scheduler.cpp

@@ -45,14 +45,11 @@ void Scheduler::Preempt() {
     return;
   }
 
+  DecrementSleepingThreads();
+
   ClearDeadThreadsFromFront();
 
   asm volatile("cli");
-  if (current_thread_ == sleep_thread_) {
-    // Sleep should never be preempted. (We should yield it if another thread
-    // becomes scheduleable).
-    return;
-  }
 
   if (runnable_threads_.size() == 0) {
     // Continue.
@@ -102,9 +99,33 @@ void Scheduler::Yield() {
   SwapToCurrent(*prev);
 }
 
+void Scheduler::Sleep(uint64_t millis) {
+  // FIXME: Improve resolution of sleep calls.
+  uint64_t ticks = (millis / 50) + 1;
+  current_thread_->SetSleepTicks(ticks);
+  current_thread_->SetState(Thread::SLEEPING);
+  sleeping_threads_.PushBack(current_thread_);
+  Yield();
+}
+
 void Scheduler::ClearDeadThreadsFromFront() {
   while (runnable_threads_.size() > 0 &&
          runnable_threads_.PeekFront()->IsDying()) {
     runnable_threads_.PopFront();
   }
 }
+
+void Scheduler::DecrementSleepingThreads() {
+  auto thread = sleeping_threads_.PeekFront();
+  while (thread) {
+    if (thread->DecrementSleepTicks()) {
+      auto thread_next = thread->next_;
+      sleeping_threads_.Remove(thread);
+      thread->SetState(Thread::RUNNABLE);
+      runnable_threads_.PushBack(thread);
+      thread = thread_next;
+    } else {
+      thread = thread->next_;
+    }
+  }
+}

zion/scheduler/scheduler.h

@@ -23,18 +23,23 @@ class Scheduler {
   void Preempt();
   void Yield();
 
+  void Sleep(uint64_t millis);
+
  private:
   bool enabled_ = false;
 
   glcr::RefPtr<Thread> current_thread_;
   glcr::IntrusiveList<Thread> runnable_threads_;
 
+  glcr::IntrusiveList<Thread> sleeping_threads_;
+
   glcr::RefPtr<Thread> sleep_thread_;
 
   Scheduler();
   void SwapToCurrent(Thread& prev);
 
   void ClearDeadThreadsFromFront();
+  void DecrementSleepingThreads();
 };
 
 extern Scheduler* gScheduler;

zion/syscall/syscall.cpp

@@ -59,6 +59,7 @@ extern "C" z_err_t SyscallHandler(uint64_t call_id, void* req) {
     CASE(ThreadStart);
     CASE(ThreadExit);
     CASE(ThreadWait);
+    CASE(ThreadSleep);
     // syscall/address_space.h
     CASE(AddressSpaceMap);
     CASE(AddressSpaceUnmap);

zion/syscall/thread.cpp

@@ -53,3 +53,8 @@ glcr::ErrorCode ThreadWait(ZThreadWaitReq* req) {
   thread->Wait();
   return glcr::OK;
 }
+
+glcr::ErrorCode ThreadSleep(ZThreadSleepReq* req) {
+  gScheduler->Sleep(req->millis);
+  return glcr::OK;
+}

zion/syscall/thread.h

@@ -8,3 +8,4 @@ glcr::ErrorCode ThreadCreate(ZThreadCreateReq* req);
 glcr::ErrorCode ThreadStart(ZThreadStartReq* req);
 glcr::ErrorCode ThreadExit(ZThreadExitReq*);
 glcr::ErrorCode ThreadWait(ZThreadWaitReq* req);
+glcr::ErrorCode ThreadSleep(ZThreadSleepReq* req);