org

kernel/syscall/syscall.c

@@ -0,0 +1,149 @@
+#include "./syscall.h"
+#include "../drivers/ps2/ps2.h"
+#include "../io/io.h"
+#include "../pci/pci.h"
+#include "../scheduler/scheduler.h"
+
+#ifdef ARCH_I386
+#include "../../arch/i386/syscall.h"
+#endif
+
+enum syscall_type_d {
+  SYSCALL_yield,
+  SYSCALL_getc,
+  SYSCALL_exit,
+  SYSCALL_lspci,
+  SYSCALL_lsproc,
+  SYSCALL_powerctl
+};
+
+void powerctl(uint32_t power_mode) {
+  // TODO: Add reboot mode when ACPI is done
+  INVOKE_SYSCALL(SYSCALL_powerctl);
+}
+
+void yield() { INVOKE_SYSCALL(SYSCALL_yield); }
+char getc() {
+  INVOKE_SYSCALL(SYSCALL_getc);
+
+  char result;
+  __asm__ volatile("movb %%al, %0" : "=r"(result));
+
+  return result;
+}
+uint32_t lspci(struct pci_device *devlist, uint32_t len) {
+  int result = 0;
+  __asm__ volatile("movl %0, %%ebx" : : "r"((uint32_t)devlist) : "%ebx");
+
+  __asm__ volatile("movl %0, %%ecx" : : "r"(len) : "%ecx");
+
+  INVOKE_SYSCALL(SYSCALL_lspci);
+
+  __asm__ volatile("movl %%eax, %k0" : "=r"(result));
+
+  return result;
+}
+
+uint32_t lsproc(struct task_struct *proclist, uint32_t len) {
+  int result = 0;
+  __asm__ volatile("movl %0, %%ebx" : : "r"((uint32_t)proclist) : "%ebx");
+
+  __asm__ volatile("movl %0, %%ecx" : : "r"(len) : "%ecx");
+
+  INVOKE_SYSCALL(SYSCALL_lsproc);
+
+  __asm__ volatile("movl %%eax, %k0" : "=r"(result));
+
+  return result;
+}
+
+void __syscall_powerctl() {
+  // TODO: Implement properly
+  printf_nolock("Attempting shutdown using hypervisor-specific methods.");
+  printf_nolock("ACPI is not yet supported.");
+  outw(0x604, 0x2000);
+  outw(0x4004, 0x3400);
+  outw(0x600, 0x34);
+  outw(0xB004, 0x2000);
+}
+
+void __syscall_yield(struct regs *r) {
+  // for now, just reschedule
+  // TODO: reset PIT timer so
+  // next process doesn't get an
+  // unreasonably small quantum
+
+  schedule(r);
+}
+
+void syscall(struct regs *r) {
+  int syscall_no = r->eax;
+
+  switch (syscall_no) {
+
+  case SYSCALL_powerctl: {
+    __syscall_powerctl();
+    break;
+  };
+
+  case SYSCALL_yield: {
+    __syscall_yield(r);
+    break;
+  };
+
+  case SYSCALL_getc: {
+    process_table[current_pid].state = TASKSTATE_blocked;
+
+    for (uint32_t i = 0; i < MAX_PROCESSES; i++) {
+      if (!ps2_waiters[i].alloc) {
+        ps2_waiters[i].alloc = 1;
+        ps2_waiters[i].pid = current_pid;
+        break;
+      }
+    }
+
+    __syscall_yield(r);
+    break;
+  };
+
+  case SYSCALL_lspci: {
+    uint32_t len = r->ecx;
+    len = len < pci_devices_count ? len : pci_devices_count;
+    struct pci_device *devlist = (struct pci_device *)r->ebx;
+
+    for (uint32_t i = 0; i < len; ++i) {
+      devlist[i] = pci_devices_list[i];
+    }
+
+    r->eax = len;
+
+    break;
+  };
+
+  case SYSCALL_lsproc: {
+    uint32_t            len = r->ecx;
+    struct task_struct *proclist = (struct task_struct *)r->ebx;
+
+    uint32_t i = 0, j = 0;
+    for (; i < len; ++i, ++j) {
+      for (; j < MAX_PROCESSES && process_table[j].state == TASKSTATE_unused;
+           ++j) {
+      }
+      if (j == MAX_PROCESSES)
+        break;
+
+      proclist[i] = process_table[j];
+    }
+
+    r->eax = i;
+
+    break;
+  };
+
+  case SYSCALL_exit: {
+    process_table[current_pid].state = TASKSTATE_unused;
+    __syscall_yield(r);
+    break;
+  };
+  }
+}

kernel/syscall/syscall.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <stdint.h>
+
+#define POWERCTL_shutdown (0)
+#define POWERCTL_reboot (1)
+
+void     powerctl(uint32_t);
+char     getc();
+uint32_t lspci();
+uint32_t lsproc();
+void     yield();