150 lines
3 KiB
C
150 lines
3 KiB
C
#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;
|
|
};
|
|
}
|
|
}
|