Implement schedsleep() syscall to sleep a process for a given time

kernel/hal/x86_64/intr.c

@@ -193,9 +193,7 @@ void hal_syscalldispatch(IntrStackFrame *frame) {
       frame->regs.rax = E_BADSYSCALL;
       return;
     }
-    spinlock_acquire(&PROCS.spinlock);
     uint64_t calling_proc_pid = PROCS.current->pid;
-    spinlock_release(&PROCS.spinlock);
     hal_intr_enable();
     int32_t ret = fn(frame, calling_proc_pid, frame->regs.rdi, frame->regs.rsi, frame->regs.rdx,
                                               frame->regs.r10, frame->regs.r8,  frame->regs.r9);

kernel/hal/x86_64/pit.c

@@ -29,12 +29,11 @@ void pit_init(void) {
   uint32_t hz = 1000;
   uint32_t div = PIT_FREQ / hz;
   io_out8(PIT_CMD, PIT_CMD_BINARY | PIT_CMD_MODE3 | PIT_CMD_RW_BOTH | PIT_CMD_COUNTER0);
-  io_out8(PIT_COUNTER0, div);
+  io_out8(PIT_COUNTER0, div & 0xFF);
   io_out8(PIT_COUNTER0, div >> 8);
 }
 
 void pit_wait(uint32_t ms) {
   uint32_t now = PIT_TICKS;
-  ++ms;
   while (PIT_TICKS - now < ms);
 }

kernel/syscall/sched.c

@@ -9,3 +9,9 @@
 int32_t SYSCALL0(sys_schedrelease) {
   return E_DOSCHEDULING;
 }
+
+int32_t SYSCALL1(sys_schedsleep, ms1) {
+  uint32_t ms = (uint32_t)ms1;
+  hal_wait(ms);
+  return E_OK;
+}

kernel/syscall/sched.h

@@ -5,5 +5,6 @@
 #include "syscall.h"
 
 int32_t SYSCALL0(sys_schedrelease);
+int32_t SYSCALL1(sys_schedsleep, ms1);
 
 #endif // SYSCALL_SCHED_H_

kernel/syscall/syscall.c

@@ -27,6 +27,7 @@ SyscallFn SYSCALL_TABLE[SYSCALLS_MAX] = {
   [SYS_MMAN_UNMAP] = &sys_mman_unmap,
 
   [SYS_SCHEDRELEASE] = &sys_schedrelease,
+  [SYS_SCHEDSLEEP]   = &sys_schedsleep,
 
   [SYS_RAND]       = &sys_rand,
 

share/sysdefs/syscall.h

@@ -5,6 +5,7 @@
 #define SYS_MMAN_MAP   5
 #define SYS_MMAN_UNMAP 6
 #define SYS_SCHEDRELEASE 7
+#define SYS_SCHEDSLEEP 8
 #define SYS_RAND       9
 #define SYS_VFSMOUNT   10
 #define SYS_VFSUNMOUNT 11

ulib/system/system.c

@@ -23,6 +23,10 @@ int32_t schedrelease(void) {
   return syscall(SYS_SCHEDRELEASE, 0, 0, 0, 0, 0, 0);
 }
 
+int32_t schedsleep(uint32_t ms) {
+  return syscall(SYS_SCHEDSLEEP, (uint64_t)ms, 0, 0, 0, 0, 0);
+}
+
 int32_t rand(void) {
   return syscall(SYS_RAND, 0, 0, 0, 0, 0, 0);
 }

ulib/system/system.h

@@ -14,6 +14,7 @@ void debugprint(const char *string);
 int32_t mman_map(uint8_t *addr, size_t size, uint64_t prot, uint64_t flags, uint8_t **out);
 int32_t mman_unmap(uint8_t *addr);
 int32_t schedrelease(void);
+int32_t schedsleep(uint32_t ms);
 int32_t rand(void);
 int32_t vfsmount(char *mountpoint, char *fstype, Dev_t *dev, bool format);
 int32_t vfsunmount(char *mountpoint);

user/diagdummy/block.c

@@ -1,7 +1,19 @@
 #include <ulib.h>
 
 void diagdummy_block(void) {
-  uprintf("blocking...\n");
-  while(1) {
+  unsigned long ms = 0;
+  if (argslen() > 1) {
+    char *strms = *(args()+1);
+    char *endp;
+    ms = string_conv_strtoul(strms, &endp, 10);
+  }
+
+  if (ms == 0) {
+    uprintf("blocking...\n");
+    while(1) {
+    }
+  } else {
+    uprintf("ms = %lu\n", ms);
+    schedsleep(ms);
   }
 }