Magic commit

Some things work, others don't.

18 files changed, 344 insertions, 114 deletions

diff --git a/src/kernel/boot.asm b/src/kernel/boot.asm
index 85d4254..58ee8d6 100644
--- a/src/kernel/boot.asm
+++ b/src/kernel/boot.asm
@@ -15,16 +15,11 @@ section .text
     global _start
     extern kernel_main
     _start:
-        mov esp, STACK_TOP
-        push ebx
-        push eax
+        push esp
         cli
         call kernel_main
         cli
-
-    hlt_L:
-        hlt
-        jmp hlt_L
+        jmp $
 
     global jump_userspace
     jump_userspace:
diff --git a/src/kernel/fs/install.c b/src/kernel/fs/install.c
index daeb91b..f7e2489 100644
--- a/src/kernel/fs/install.c
+++ b/src/kernel/fs/install.c
@@ -7,7 +7,7 @@
 #include <kernel/lib/stdio.h>
 #include <kernel/timer/timer.h>
 #include <kernel/memory/kheap.h>
-#include <kernel/graphics/font.h>
+#include <kernel/fs/load.h>
 
 void install_melvix()
 {
diff --git a/src/kernel/graphics/font.c b/src/kernel/fs/load.c
index 10372b3..be7d5b8 100644
--- a/src/kernel/graphics/font.c
+++ b/src/kernel/fs/load.c
@@ -1,19 +1,21 @@
+#include <kernel/fs/load.h>
 #include <kernel/fs/marfs/marfs.h>
-#include <kernel/graphics/font.h>
 #include <kernel/fs/ata_pio.h>
 #include <kernel/fs/atapi_pio.h>
 #include <kernel/system.h>
 #include <kernel/fs/iso9660/iso9660.h>
 #include <kernel/memory/kheap.h>
 
-void font_install()
+void load_binaries()
 {
+    userspace = kmalloc(10000);
     font = (struct font *) kmalloc(100000);; // High quality shit
 
     uint8_t boot_drive_id = (uint8_t) (*((uint8_t *) 0x9000));
     if (boot_drive_id != 0xE0) {
         struct ata_interface *primary_master = new_ata(1, 0x1F0);
         marfs_init(primary_master);
+        marfs_read_whole_file(4, (uint8_t *) userspace);
         marfs_read_whole_file(5, (uint8_t *) font);
     } else {
         char *font_p[] = {"FONT.BIN"};
@@ -21,6 +23,12 @@ void font_install()
         if (!font_e) panic("Font not found!");
         ATAPI_granular_read(1 + (font_e->length / 2048), font_e->lba, (uint8_t *) font);
         kfree(font_e);
+
+        char *user_p[] = {"USER.BIN"};
+        struct iso9660_entity *user_e = ISO9660_get(user_p, 1);
+        if (!user_e) panic("Userspace binary not found!");
+        ATAPI_granular_read(1 + (user_e->length / 2048), user_e->lba, (uint8_t *) userspace);
+        kfree(user_e);
     }
-    vga_log("Successfully loaded font");
+    vga_log("Successfully loaded binaries");
 }
\ No newline at end of file
diff --git a/src/kernel/fs/load.h b/src/kernel/fs/load.h
new file mode 100644
index 0000000..7a0ec06
--- /dev/null
+++ b/src/kernel/fs/load.h
@@ -0,0 +1,19 @@
+#ifndef MELVIX_LOAD_H
+#define MELVIX_LOAD_H
+
+#include <stdint.h>
+
+uint32_t userspace;
+
+struct font *font;
+
+struct font {
+    uint16_t font_32[758][32];
+    uint16_t font_24[758][24];
+    uint8_t font_16[758][16];
+    uint16_t cursor[19];
+};
+
+void load_binaries();
+
+#endif
diff --git a/src/kernel/graphics/font.h b/src/kernel/graphics/font.h
deleted file mode 100644
index 7778979..0000000
--- a/src/kernel/graphics/font.h
+++ /dev/null
@@ -1,19 +0,0 @@
-// Generated using the Spleen font and the bdf2c converter (modified using the conv.sh script)
-// Spleen font: (c) 2018-2019, Frederic Cambus, License: MIT
-// bdf2c: (c) 2009-2010 Lutz Sammer, License: AGPLv3
-
-#ifndef MELVIX_FONT_H
-#define MELVIX_FONT_H
-
-#include <stdint.h>
-
-struct font *font;
-
-struct font {
-    uint16_t font_32[758][32];
-    uint16_t font_24[758][24];
-    uint8_t font_16[758][16];
-    uint16_t cursor[19];
-};
-
-#endif
diff --git a/src/kernel/graphics/vesa.c b/src/kernel/graphics/vesa.c
index e2b0036..576fc18 100644
--- a/src/kernel/graphics/vesa.c
+++ b/src/kernel/graphics/vesa.c
@@ -1,5 +1,5 @@
 #include <kernel/graphics/vesa.h>
-#include <kernel/graphics/font.h>
+#include <kernel/fs/load.h>
 #include <kernel/lib/lib.h>
 #include <kernel/system.h>
 #include <kernel/lib/stdlib.h>
diff --git a/src/kernel/graphics/vesa.h b/src/kernel/graphics/vesa.h
index 2288760..22590de 100644
--- a/src/kernel/graphics/vesa.h
+++ b/src/kernel/graphics/vesa.h
@@ -185,8 +185,6 @@ void vesa_draw_cursor(int x, int y);
  */
 void vesa_set_color(uint32_t color);
 
-void font_install();
-
 /**
  * An enum with vesa colors
  * From https://github.com/joshdick/onedark.vim/ License: MIT
diff --git a/src/kernel/kernel.c b/src/kernel/kernel.c
index efa6ca0..91206a2 100644
--- a/src/kernel/kernel.c
+++ b/src/kernel/kernel.c
@@ -9,18 +9,15 @@
 #include <kernel/smbios/smbios.h>
 #include <kernel/lib/lib.h>
 #include <kernel/syscall/syscall.h>
-#include <kernel/fs/marfs/marfs.h>
-#include <kernel/fs/iso9660/iso9660.h>
-#include <kernel/fs/atapi_pio.h>
 #include <kernel/pci/pci.h>
 #include <kernel/net/network.h>
-#include <kernel/memory/kheap.h>
 #include <kernel/lib/stdio.h>
+#include <kernel/tasks/task.h>
+#include <kernel/fs/load.h>
 
-extern void jump_userspace();
-
-void kernel_main()
+void kernel_main(uint32_t initial_stack)
 {
+    initial_esp = initial_stack;
     vga_log("Installing basic features of Melvix...");
 
     // Install features
@@ -28,13 +25,13 @@ void kernel_main()
     gdt_install();
     init_serial();
     acpi_install();
-    paging_install();
     idt_install();
     isrs_install();
     irq_install();
-    font_install();
-    serial_printf("%d", memory_get_all());
+    paging_install();
+    load_binaries();
     set_optimal_resolution();
+    serial_printf("%d", memory_get_all());
 
     // Install drivers
     asm ("cli");
@@ -51,30 +48,17 @@ void kernel_main()
     // Print total memory
     info("Total memory found: %dMiB", (memory_get_all() >> 10) + 1);
 
-    uint8_t boot_drive_id = (uint8_t) (*((uint8_t *) 0x9000));
-
 #ifdef INSTALL_MELVIX
 #include <kernel/fs/install.h>
     serial_printf("Install flag given!");
-    if (boot_drive_id == 0xE0)
+    if ((*((uint8_t *) 0x9000)) == 0xE0)
         install_melvix();
 #endif
 
-    info("Switching to user mode...");
+    tasking_install();
     syscalls_install();
     tss_flush();
-    uint32_t userspace = (uint32_t) kmalloc(8096);
-    if (boot_drive_id == 0xE0) {
-        char *user_p[] = {"USER.BIN"};
-        struct iso9660_entity *user_e = ISO9660_get(user_p, 1);
-        if (!user_e) panic("Userspace binary not found!");
-        ATAPI_granular_read(1 + (user_e->length / 2048), user_e->lba, (uint8_t *) (userspace + 4096));
-        kfree(user_e);
-        jump_userspace(userspace + 4096, userspace + 4096);
-    } else {
-        marfs_read_whole_file(4, (uint8_t *) (userspace + 4096));
-        jump_userspace(userspace + 4096, userspace + 4096);
-    }
+    switch_to_usermode(userspace);
 
     panic("This should NOT happen!");
 
diff --git a/src/kernel/syscall/actions/sys_get_pointers.c b/src/kernel/syscall/actions/sys_get_pointers.c
index 8e34ddd..bc00b3b 100644
--- a/src/kernel/syscall/actions/sys_get_pointers.c
+++ b/src/kernel/syscall/actions/sys_get_pointers.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <kernel/graphics/vesa.h>
-#include <kernel/graphics/font.h>
+#include <kernel/fs/load.h>
 #include <kernel/memory/kheap.h>
 
 struct userspace_pointers {
diff --git a/src/kernel/syscall/syscall.c b/src/kernel/syscall/syscall.c
index 367fe30..7ca7f99 100644
--- a/src/kernel/syscall/syscall.c
+++ b/src/kernel/syscall/syscall.c
@@ -6,8 +6,6 @@
 
 typedef uint32_t (*syscall_func)(unsigned int, ...);
 
-extern void jump_userspace();
-
 uint32_t (*syscalls[])() = {
         [0] = (uint32_t (*)()) halt_loop, // DEBUG!
         [1] = sys_write,
diff --git a/src/kernel/system.c b/src/kernel/system.c
index 85cadc2..ae2e524 100644
--- a/src/kernel/system.c
+++ b/src/kernel/system.c
@@ -7,6 +7,8 @@
 #include <kernel/lib/stdio.h>
 #include <stdarg.h>
 
+uint32_t initial_esp;
+
 char *vga_buffer = (char *) 0x500;
 
 void vga_clear()
diff --git a/src/kernel/system.h b/src/kernel/system.h
index 9c3ae80..8d124de 100644
--- a/src/kernel/system.h
+++ b/src/kernel/system.h
@@ -9,7 +9,7 @@ extern void ASM_KERNEL_END();
 /**
  * The initial stack pointer
  */
-extern uint32_t STACK_TOP;
+uint32_t initial_esp;
 
 /**
  * Initialize the basic features of the OS
diff --git a/src/kernel/tasks/process.asm b/src/kernel/tasks/process.asm
new file mode 100644
index 0000000..a46ac3d
--- /dev/null
+++ b/src/kernel/tasks/process.asm
@@ -0,0 +1,48 @@
+[GLOBAL read_eip]
+read_eip:
+    pop eax
+    jmp eax
+
+[GLOBAL copy_page_physical]
+copy_page_physical:
+    push ebx
+    pushf
+
+    cli
+
+    mov ebx, [esp+12]
+    mov ecx, [esp+16]
+
+    mov edx, cr0
+    and edx, 0x7fffffff
+    mov cr0, edx
+
+    mov edx, 1024
+
+.loop:
+    mov eax, [ebx]
+    mov [ecx], eax
+    add ebx, 4
+    add ecx, 4
+    dec edx
+    jnz .loop
+
+    mov edx, cr0
+    or  edx, 0x80000000
+    mov cr0, edx
+
+    popf
+    pop ebx
+    ret
+
+[GLOBAL perform_task_switch]
+perform_task_switch:
+     cli
+     mov ecx, [esp+4]
+     mov eax, [esp+8]
+     mov ebp, [esp+12]
+     mov esp, [esp+16]
+     mov cr3, eax
+     mov eax, 0x12345
+     sti
+     jmp ecx
\ No newline at end of file
diff --git a/src/kernel/tasks/task.c b/src/kernel/tasks/task.c
new file mode 100644
index 0000000..e6caf9a
--- /dev/null
+++ b/src/kernel/tasks/task.c
@@ -0,0 +1,168 @@
+#include <kernel/memory/paging.h>
+#include <kernel/tasks/task.h>
+#include <kernel/memory/kheap.h>
+#include <kernel/lib/lib.h>
+#include <kernel/gdt/gdt.h>
+#include <kernel/system.h>
+
+volatile task_t *current_task;
+volatile task_t *ready_queue;
+
+extern page_directory_t *kernel_directory;
+extern page_directory_t *current_directory;
+
+extern uint32_t read_eip();
+
+uint32_t next_pid = 1;
+
+void tasking_install()
+{
+    asm ("cli");
+    move_stack((void *) 0xE0000000, 0x2000);
+
+    current_task = ready_queue = (task_t *) kmalloc(sizeof(task_t));
+    current_task->id = (int) next_pid++;
+    current_task->esp = current_task->ebp = 0;
+    current_task->eip = 0;
+    current_task->page_directory = current_directory;
+    current_task->next = 0;
+    current_task->kernel_stack = kmalloc_a(KERNEL_STACK_SIZE);
+
+    vga_log("Installed Tasking");
+    asm ("sti");
+}
+
+void move_stack(void *new_stack_start, uint32_t size)
+{
+    for (uint32_t i = (uint32_t) new_stack_start;
+         i >= ((uint32_t) new_stack_start - size);
+         i -= 0x1000) {
+        paging_alloc_frame(paging_get_page(i, 1, current_directory), 0, 1);
+    }
+
+    uint32_t pd_addr;
+    asm volatile ("mov %%cr3, %0" : "=r" (pd_addr));
+    asm volatile ("mov %0, %%cr3" : : "r" (pd_addr));
+
+    uint32_t old_stack_pointer; asm volatile ("mov %%esp, %0" : "=r" (old_stack_pointer));
+    uint32_t old_base_pointer;  asm volatile ("mov %%ebp, %0" : "=r" (old_base_pointer));
+
+    uint32_t offset = (uint32_t) new_stack_start - initial_esp;
+
+    uint32_t new_stack_pointer = old_stack_pointer + offset;
+    uint32_t new_base_pointer = old_base_pointer + offset;
+
+    memcpy((void *) new_stack_pointer, (void *) old_stack_pointer, initial_esp - old_stack_pointer);
+
+    for (uint32_t i = (uint32_t) new_stack_start; i > (uint32_t) new_stack_start - size; i -= 4) {
+        uint32_t tmp = *(uint32_t *) i;
+        if ((old_stack_pointer < tmp) && (tmp < initial_esp)) {
+            tmp = tmp + offset;
+            uint32_t *tmp2 = (uint32_t *) i;
+            *tmp2 = tmp;
+        }
+    }
+
+    asm volatile ("mov %0, %%esp" : : "r" (new_stack_pointer));
+    asm volatile ("mov %0, %%ebp" : : "r" (new_base_pointer));
+}
+
+extern void perform_task_switch(uint32_t, uint32_t, uint32_t, uint32_t);
+
+void switch_task()
+{
+    if (!current_task)
+        return;
+
+    uint32_t esp, ebp, eip;
+    asm volatile ("mov %%esp, %0" : "=r"(esp));
+    asm volatile ("mov %%ebp, %0" : "=r"(ebp));
+
+    eip = read_eip();
+
+    if (eip == 0x12345)
+        return;
+
+    current_task->eip = eip;
+    current_task->esp = esp;
+    current_task->ebp = ebp;
+
+    current_task = current_task->next;
+    if (!current_task) current_task = ready_queue;
+
+    eip = current_task->eip;
+    esp = current_task->esp;
+    ebp = current_task->ebp;
+
+    current_directory = current_task->page_directory;
+
+    set_kernel_stack(current_task->kernel_stack + KERNEL_STACK_SIZE);
+
+    perform_task_switch(eip, current_directory->physicalAddr, ebp, esp);
+}
+
+int fork()
+{
+    asm ("cli");
+
+    task_t *parent_task = (task_t *) current_task;
+
+    page_directory_t *directory = paging_clone_directory(current_directory);
+
+    task_t *new_task = (task_t *) kmalloc(sizeof(task_t));
+    new_task->id = (int) next_pid++;
+    new_task->esp = new_task->ebp = 0;
+    new_task->eip = 0;
+    new_task->page_directory = directory;
+    current_task->kernel_stack = kmalloc_a(KERNEL_STACK_SIZE);
+    new_task->next = 0;
+
+    task_t *tmp_task = (task_t *) ready_queue;
+    while (tmp_task->next)
+        tmp_task = tmp_task->next;
+    tmp_task->next = new_task;
+
+    uint32_t eip = read_eip();
+
+    if (current_task == parent_task) {
+        uint32_t esp; asm volatile ("mov %%esp, %0" : "=r"(esp));
+        uint32_t ebp; asm volatile ("mov %%ebp, %0" : "=r"(ebp));
+        new_task->esp = esp;
+        new_task->ebp = ebp;
+        new_task->eip = eip;
+        asm volatile ("sti");
+
+        return new_task->id;
+    } else {
+        return 0;
+    }
+}
+
+int getpid()
+{
+    return current_task->id;
+}
+
+void switch_to_usermode(uint32_t binary)
+{
+    set_kernel_stack(current_task->kernel_stack + KERNEL_STACK_SIZE);
+
+    info("Switching to user mode...");
+
+    asm volatile ("\
+      cli; \
+      mov $0x23, %%ax; \
+      mov %%ax, %%ds; \
+      mov %%ax, %%es; \
+      mov %%ax, %%fs; \
+      mov %%ax, %%gs; \
+      mov %%esp, %%eax; \
+      pushl $0x23; \
+      pushl %%esp; \
+      pushf; \
+      pushl $0x1B; \
+      push %0; \
+      iret; \
+    1: \
+      " : : "r" (binary));
+}
\ No newline at end of file
diff --git a/src/kernel/tasks/task.h b/src/kernel/tasks/task.h
new file mode 100644
index 0000000..97aeb15
--- /dev/null
+++ b/src/kernel/tasks/task.h
@@ -0,0 +1,30 @@
+#ifndef MELVIX_TASK_H
+#define MELVIX_TASK_H
+
+#include <stdint.h>
+#include <kernel/memory/paging.h>
+
+#define KERNEL_STACK_SIZE 2048
+
+typedef struct task {
+    int id;
+    uint32_t esp, ebp;
+    uint32_t eip;
+    page_directory_t *page_directory;
+    uint32_t kernel_stack;
+    struct task *next;
+} task_t;
+
+void tasking_install();
+
+void switch_task();
+
+int fork();
+
+void move_stack(void *new_stack_start, uint32_t size);
+
+int getpid();
+
+void switch_to_usermode(uint32_t);
+
+#endif
diff --git a/src/kernel/timer/timer.c b/src/kernel/timer/timer.c
index cc98bc4..9bf6014 100644
--- a/src/kernel/timer/timer.c
+++ b/src/kernel/timer/timer.c
@@ -1,6 +1,7 @@
 #include <kernel/interrupts/interrupts.h>
 #include <kernel/io/io.h>
 #include <kernel/system.h>
+#include <kernel/tasks/task.h>
 
 unsigned long timer_ticks = 0;
 
@@ -16,6 +17,7 @@ void timer_phase(int hz)
 void timer_handler(struct regs *r)
 {
     timer_ticks++;
+    // switch_task();
 }
 
 // "Delay" function with CPU sleep
diff --git a/src/userspace/syscall.c b/src/userspace/syscall.c
index 132cd49..9462b10 100644
--- a/src/userspace/syscall.c
+++ b/src/userspace/syscall.c
@@ -5,9 +5,9 @@
  */
 DEFN_SYSCALL0(halt, 0);
 
-DEFN_SYSCALL1(write, 1, char *);
+DEFN_SYSCALL1(write, 1, const char *);
 
-DEFN_SYSCALL1(read, 2, char *);
+DEFN_SYSCALL1(read, 2, const char *);
 
 DEFN_SYSCALL1(writec, 3, char);
 
diff --git a/src/userspace/syscall.h b/src/userspace/syscall.h
index e46f453..bd402a1 100644
--- a/src/userspace/syscall.h
+++ b/src/userspace/syscall.h
@@ -3,72 +3,69 @@
 
 #include <stdint.h>
 
-#define DECL_SYSCALL0(fn) int syscall_##fn()
-#define DECL_SYSCALL1(fn, p1) int syscall_##fn(p1)
-#define DECL_SYSCALL2(fn, p1, p2) int syscall_##fn(p1,p2)
-#define DECL_SYSCALL3(fn, p1, p2, p3) int syscall_##fn(p1,p2,p3)
-#define DECL_SYSCALL4(fn, p1, p2, p3, p4) int syscall_##fn(p1,p2,p3,p4)
-#define DECL_SYSCALL5(fn, p1, p2, p3, p4, p5) int syscall_##fn(p1,p2,p3,p4,p5)
+#define DECL_SYSCALL0(fn) int syscall_##fn();
+#define DECL_SYSCALL1(fn, p1) int syscall_##fn(p1);
+#define DECL_SYSCALL2(fn, p1, p2) int syscall_##fn(p1,p2);
+#define DECL_SYSCALL3(fn, p1, p2, p3) int syscall_##fn(p1,p2,p3);
+#define DECL_SYSCALL4(fn, p1, p2, p3, p4) int syscall_##fn(p1,p2,p3,p4);
+#define DECL_SYSCALL5(fn, p1, p2, p3, p4, p5) int syscall_##fn(p1,p2,p3,p4,p5);
 
 #define DEFN_SYSCALL0(fn, num) \
-    int syscall_##fn() { \
-        int a; __asm__ __volatile__("int $0x80" : "=a" (a) : "0" (num)); \
-        return a; \
-    }
+int syscall_##fn() \
+{ \
+  int a; \
+  asm volatile("int $0x80" : "=a" (a) : "0" (num)); \
+  return a; \
+}
 
 #define DEFN_SYSCALL1(fn, num, P1) \
-    int syscall_##fn(P1 p1) { \
-        int __res; __asm__ __volatile__("push %%ebx; movl %2,%%ebx; int $0x80; pop %%ebx" \
-                : "=a" (__res) \
-                : "0" (num), "r" ((int)(p1)) \
-                : "memory"); \
-        return __res; \
-    }
+int syscall_##fn(P1 p1) \
+{ \
+  int a; \
+  asm volatile("int $0x80" : "=a" (a) : "0" (num), "b" ((int)p1)); \
+  return a; \
+}
 
 #define DEFN_SYSCALL2(fn, num, P1, P2) \
-    int syscall_##fn(P1 p1, P2 p2) { \
-        int __res; __asm__ __volatile__("push %%ebx; movl %2,%%ebx; int $0x80; pop %%ebx" \
-                : "=a" (__res) \
-                : "0" (num), "r" ((int)(p1)), "c"((int)(p2)) \
-                : "memory"); \
-        return __res; \
-    }
+int syscall_##fn(P1 p1, P2 p2) \
+{ \
+  int a; \
+  asm volatile("int $0x80" : "=a" (a) : "0" (num), "b" ((int)p1), "c" ((int)p2)); \
+  return a; \
+}
 
 #define DEFN_SYSCALL3(fn, num, P1, P2, P3) \
-    int syscall_##fn(P1 p1, P2 p2, P3 p3) { \
-        int __res; __asm__ __volatile__("push %%ebx; movl %2,%%ebx; int $0x80; pop %%ebx" \
-                : "=a" (__res) \
-                : "0" (num), "b" ((int)(p1)), "c"((p2)), "d"((int)(p3)) \
-                : "memory"); \
-        return __res; \
-    }
+int syscall_##fn(P1 p1, P2 p2, P3 p3) \
+{ \
+  int a; \
+  asm volatile("int $0x80" : "=a" (a) : "0" (num), "b" ((int)p1), "c" ((int)p2), "d"((int)p3)); \
+  return a; \
+}
 
 #define DEFN_SYSCALL4(fn, num, P1, P2, P3, P4) \
-    int syscall_##fn(P1 p1, P2 p2, P3 p3, P4 p4) { \
-        int __res; __asm__ __volatile__("push %%ebx; movl %2,%%ebx; int $0x80; pop %%ebx" \
-                : "=a" (__res) \
-                : "0" (num), "b" ((int)(p1)), "c"((int)(p2)), "d"((int)(p3)), "S"((int)(p4)) \
-                : "memory"); \
-        return __res; \
-    }
-
-#define DEFN_SYSCALL5(fn, num, P1, P2, P3, P4, P5) \
-    int syscall_##fn(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) { \
-        int __res; __asm__ __volatile__("push %%ebx; movl %2,%%ebx; int $0x80; pop %%ebx" \
-                : "=a" (__res) \
-                : "0" (num), "b" ((int)(p1)), "c"((int)(p2)), "d"((int)(p3)), "S"((int)(p4)), "D"((int)(p5)) \
-                : "memory"); \
-        return __res; \
-    }
+int syscall_##fn(P1 p1, P2 p2, P3 p3, P4 p4) \
+{ \
+  int a; \
+  asm volatile("int $0x80" : "=a" (a) : "0" (num), "b" ((int)p1), "c" ((int)p2), "d" ((int)p3), "S" ((int)p4)); \
+  return a; \
+}
+
+#define DEFN_SYSCALL5(fn, num) \
+int syscall_##fn(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) \
+{ \
+  int a; \
+  asm volatile("int $0x80" : "=a" (a) : "0" (num), "b" ((int)p1), "c" ((int)p2), "d" ((int)p3), "S" ((int)p4), "D" ((int)p5)); \
+  return a; \
+}
 
 /**
  * DECLARATIONS
  */
 DECL_SYSCALL0(halt);
 
-DECL_SYSCALL1(write, char *);
+DECL_SYSCALL1(write, const char *);
 
-DECL_SYSCALL1(read, char *);
+DECL_SYSCALL1(read, const char *);
 
 DECL_SYSCALL1(writec, char);