Process

cmake/targets.cmake

@@ -31,7 +31,7 @@ function(cross_target_binary target)
         -nostdlib
         "-L${CROSS_PREFIX}/lib/gcc/i386-elf/12.2.0"
         -lgcc
-        DEPENDS ${target} ${TARGET_LINK_FILES})
+        DEPENDS ${target} ${TARGET_LINK_FILES} ${CMAKE_CURRENT_SOURCE_DIR}/link.ld)
 
     add_custom_target(${target}_image ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${target}.bin)
 

src/apps/foo/src/foo.c

@@ -4,7 +4,7 @@
 void foo() {
     uint32_t res = puts("Hello\n");
 
-    proc_exit(0);
+    pull_event(EBUS_EVENT_KEY, 0);
 
     res = printf("Hello 0x%X\n", res);
 

src/cpu/i386/src/cpu.asm

@@ -31,85 +31,3 @@ flush_tss:
     mov ax, (5 * 8) | 0 ; fifth 8-byte selector, symbolically OR-ed with 0 to set the RPL (requested privilege level).
     ltr ax
     ret
-
-global jump_usermode
-jump_usermode:
-    mov ebx, [esp+4]
-    mov ax, (4 * 8) | 3 ; ring 3 data with bottom 2 bits set for ring 3
-    mov ds, ax
-    mov es, ax
-    mov fs, ax
-    mov gs, ax ; SS is handled by iret
-
-    ; set up the stack frame iret expects
-    mov eax, esp
-    push (4 * 8) | 3 ; data selector
-    push eax ; current esp
-    pushf ; eflags
-    push (3 * 8) | 3 ; code selector (ring 3 code with bottom 2 bits set for ring 3)
-    push ebx ; instruction address to return to
-    iret
-
-; https://wiki.osdev.org/Brendan%27s_Multi-tasking_Tutorial
-
-;C declaration:
-;   void switch_to_task(thread_control_block *next_thread);
-;
-;WARNING: Caller is expected to disable IRQs before calling, and enable IRQs again after function returns
-
-TCB_EIP equ 4
-TCB_ESP equ 8
-TCB_CR3 equ 12
-TCB_ESP0 equ 16
-TSS_ESP0 equ 20
-
-current_task_TCB: dd 0
-
-global set_first_task
-set_first_task:
-    mov eax, [esp + 4]
-    mov [current_task_TCB], eax
-    ret
-
-global switch_to_task
-switch_to_task:
-
-    ;Save previous task's state
-
-    ;Notes:
-    ;  For cdecl; EAX, ECX, and EDX are already saved by the caller and don't need to be saved again
-    ;  EIP is already saved on the stack by the caller's "CALL" instruction
-    ;  The task isn't able to change CR3 so it doesn't need to be saved
-    ;  Segment registers are constants (while running kernel code) so they don't need to be saved
-
-    push ebx
-    push esi
-    push edi
-    push ebp
-
-    mov edi,[current_task_TCB]    ;edi = address of the previous task's "thread control block"
-    mov [edi+TCB_ESP],esp         ;Save ESP for previous task's kernel stack in the thread's TCB
-
-    ;Load next task's state
-
-    mov esi,[esp+(4+1)*4]         ;esi = address of the next task's "thread control block" (parameter passed on stack)
-    mov [current_task_TCB],esi    ;Current task's TCB is the next task TCB
-
-    mov esp,[esi+TCB_ESP]         ;Load ESP for next task's kernel stack from the thread's TCB
-    mov eax,[esi+TCB_CR3]         ;eax = address of page directory for next task
-    mov ebx,[esi+TCB_ESP0]        ;ebx = address for the top of the next task's kernel stack
-    mov [TSS_ESP0],ebx            ;Adjust the ESP0 field in the TSS (used by CPU for for CPL=3 -> CPL=0 privilege level changes)
-    mov ecx,cr3                   ;ecx = previous task's virtual address space
-
-    cmp eax,ecx                   ;Does the virtual address space need to being changed?
-    je .doneVAS                   ; no, virtual address space is the same, so don't reload it and cause TLB flushes
-    mov cr3,eax                   ; yes, load the next task's virtual address space
-
-.doneVAS:
-
-    pop ebp
-    pop edi
-    pop esi
-    pop ebx
-
-    ret                           ;Load next task's EIP from its kernel stack

src/cpu/i386/src/isr.c

@@ -2,6 +2,7 @@
 
 #include "cpu/idt.h"
 #include "cpu/ports.h"
+#include "kernel.h"
 #include "libc/proc.h"
 #include "libc/stdio.h"
 
@@ -161,7 +162,7 @@ void isr_handler(registers_t r) {
         default:
             break;
     }
-    PANIC("STOP HERE");
+    KPANIC("STOP HERE");
 }
 
 /*
@@ -191,7 +192,7 @@ void irq_handler(registers_t r) {
     if (r.int_no >= 256) {
         printf("BAD INTERRUPT 0x%X\n", r.int_no);
         print_trace(&r);
-        PANIC("BAD INTERRUPT");
+        KPANIC("BAD INTERRUPT");
         return;
     }
 

src/cpu/i386/src/tss.c

@@ -24,6 +24,10 @@ tss_entry_t * tss_get_entry(size_t i) {
     return &tss_stack[i];
 }
 
-void set_kernel_stack(uint32_t stack) { // Used when an interrupt occurs
+uint32_t tss_get_esp0() {
+    return tss_stack[0].esp0;
+}
+
+void tss_set_esp0(uint32_t stack) { // Used when an interrupt occurs
     tss_stack[0].esp0 = stack;
 }

src/cpu/include/cpu/tss.h

@@ -51,6 +51,7 @@ void init_tss();
 
 tss_entry_t * tss_get_entry(size_t i);
 
-void set_kernel_stack(uint32_t stack);
+uint32_t tss_get_esp0(void);
+void     tss_set_esp0(uint32_t stack);
 
 #endif // TSS_H

src/drivers/include/drivers/keyboard.h

@@ -82,6 +82,4 @@ typedef enum keyboard_key {
 
 void init_keyboard();
 
-char keyboard_char(uint8_t code, bool shift);
-
 #endif // KEYBOARD_H

src/drivers/src/keyboard.c

@@ -1,70 +1,104 @@
 #include "drivers/keyboard.h"
 
+#include <stdbool.h>
+
 #include "cpu/isr.h"
 #include "cpu/ports.h"
-#include "libc/signal.h"
+#include "libc/proc.h"
 #include "libc/stdio.h"
+#include "libc/string.h"
+
+static bool     e0_mode;
+static uint32_t keystate[8];
+static char     keyMap[0xFF]      = {0, 0, '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '-', '+', '\b', '\t', 'q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p', '[', ']', '\n', 0, 'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', ';', '\'', '`', 0, '\\', 'z', 'x', 'c', 'v', 'b', 'n', 'm', ',', '.', '/', 0, 0, 0, ' ', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static char     shiftKeyMap[0xFF] = {0, 0, '!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '_', '+', '\b', '\t', 'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P', '{', '}', '\n', 0, 'A', 'S', 'D', 'F', 'G', 'H', 'J', 'K', 'L', ':', '"', '~', 0, '|', 'Z', 'X', 'C', 'V', 'B', 'N', 'M', '<', '>', '?', 0, 0, 0, ' ', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+static void    keyboard_callback(registers_t * regs);
+static char    keyboard_char(uint8_t code, bool shift);
+static bool    get_key_state(uint8_t keycode);
+static void    set_key_state(uint8_t keycode, bool state);
+static uint8_t get_mods();
+
+void init_keyboard() {
+    e0_mode = false;
+    kmemset(keystate, 0, sizeof(keystate));
+    register_interrupt_handler(IRQ1, keyboard_callback);
+}
+
+static bool get_key_state(uint8_t keycode) {
+    int i = keycode / 32;
+    int b = keycode % 32;
 
-static uint8_t last_code = 0;
-static bool    lctrl     = false;
-static bool    rctrl     = false;
-static bool    lalt      = false;
-static bool    ralt      = false;
-static bool    lshift    = false;
-static bool    rshift    = false;
-static bool    lsuper    = false;
-static bool    rsuper    = false;
+    return keystate[i] & (1 << b);
+}
+
+static void set_key_state(uint8_t keycode, bool state) {
+    int i = keycode / 32;
+    int b = keycode % 32;
+
+    if (state) {
+        keystate[i] |= (1 << b);
+    }
+    else {
+        keystate[i] &= ~(1 << b);
+    }
+}
+
+static uint8_t get_mods() {
+    uint8_t mods = 0;
+    // TODO handle 0xE0 to get right ctrl
+    if (get_key_state(KEY_LCTRL)) {
+        mods |= KEY_MOD_CTRL;
+    }
+    // TODO handle 0xE0 to get right alt
+    if (get_key_state(KEY_LALT)) {
+        mods |= KEY_MOD_ALT;
+    }
+    if (get_key_state(KEY_LSHIFT) || get_key_state(KEY_RSHIFT)) {
+        mods |= KEY_MOD_SHIFT;
+    }
+    // TODO handle 0xE0 to get right super
+    if (get_key_state(KEY_SUPER)) {
+        mods |= KEY_MOD_SUPER;
+    }
+    return mods;
+}
+
+static char keyboard_char(uint8_t code, bool shift) {
+    code = code & 0x7F;
+    if (shift) {
+        return shiftKeyMap[code];
+    }
+    return keyMap[code];
+}
 
 static void keyboard_callback(registers_t * regs) {
     /* The PIC leaves us the scancode in port 0x60 */
-    uint8_t          scancode  = port_byte_in(0x60);
+    uint8_t scancode = port_byte_in(0x60);
+    if (scancode == 0xE0) {
+        e0_mode = true;
+        return;
+    }
+    // printf("%02X ", scancode);
     uint8_t          keycode   = scancode;
     keyboard_event_t key_event = KEY_EVENT_PRESS;
+    uint8_t          mods      = get_mods();
     bool             press     = keycode < 0x80;
 
     if (press) {
-        if (keycode == last_code) {
+        if (get_key_state(keycode)) {
             key_event = KEY_EVENT_REPEAT;
         }
-        else {
-            if (keycode == KEY_LSHIFT) {
-                lshift = true;
-            }
-            if (keycode == KEY_RSHIFT) {
-                lshift = true;
-            }
-        }
-        last_code = keycode;
+        set_key_state(keycode, true);
     }
 
     else {
         keycode -= 0x80;
         key_event = KEY_EVENT_RELEASE;
-        last_code = 0;
-
-        if (keycode == KEY_LSHIFT) {
-            lshift = false;
-        }
-        if (keycode == KEY_RSHIFT) {
-            lshift = false;
-        }
+        set_key_state(keycode, false);
     }
 
-    char c = keyboard_char(keycode, lshift || rshift);
-
-    keyboard_mod_t mods = 0;
-    if (lctrl || rctrl) {
-        mods |= KEY_MOD_CTRL;
-    }
-    if (lalt || ralt) {
-        mods |= KEY_MOD_ALT;
-    }
-    if (lshift || rshift) {
-        mods |= KEY_MOD_SHIFT;
-    }
-    if (lsuper || rsuper) {
-        mods |= KEY_MOD_SUPER;
-    }
+    char c = keyboard_char(keycode, mods & KEY_MOD_SHIFT);
 
     ebus_event_t event;
     event.event_id     = EBUS_EVENT_KEY;
@@ -74,19 +108,5 @@ static void keyboard_callback(registers_t * regs) {
     event.key.keycode  = keycode;
     event.key.scancode = scancode;
     queue_event(&event);
-}
-
-void init_keyboard() {
-    register_interrupt_handler(IRQ1, keyboard_callback);
-}
-
-char keyMap[0xFF]      = {0, 0, '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '-', '+', '\b', '\t', 'q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p', '[', ']', '\n', 0, 'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', ';', '\'', '`', 0, '\\', 'z', 'x', 'c', 'v', 'b', 'n', 'm', ',', '.', '/', 0, 0, 0, ' ', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-char shiftKeyMap[0xFF] = {0, 0, '!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '_', '+', '\b', '\t', 'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P', '{', '}', '\n', 0, 'A', 'S', 'D', 'F', 'G', 'H', 'J', 'K', 'L', ':', '"', '~', 0, '|', 'Z', 'X', 'C', 'V', 'B', 'N', 'M', '<', '>', '?', 0, 0, 0, ' ', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-
-char keyboard_char(uint8_t code, bool shift) {
-    code = code & 0x7F;
-    if (shift) {
-        return shiftKeyMap[code];
-    }
-    return keyMap[code];
+    e0_mode = false;
 }

src/drivers/src/timer.c

@@ -4,7 +4,7 @@
 #include "cpu/ports.h"
 #include "ebus.h"
 #include "libc/datastruct/array.h"
-#include "libc/signal.h"
+#include "libc/proc.h"
 #include "libc/stdio.h"
 
 // https://wiki.osdev.org/PIT

src/ebus/CMakeLists.txt

@@ -1,4 +1,4 @@
 set(TARGET ebus)
 
 cross_target(${TARGET})
-target_link_libraries(${TARGET} libc)
+target_link_libraries(${TARGET} libc kernel)

src/ebus/include/ebus.h

@@ -24,22 +24,35 @@ enum EBUS_EVENT {
     EBUS_EVENT_ANY = 0,
     EBUS_EVENT_TIMER,
     EBUS_EVENT_KEY,
+    EBUS_EVENT_TASK_SWITCH,
+    EBUS_EVENT_TASK_KILL,
 };
 
 typedef struct _ebus_event {
     int event_id;
+    int source_pid;
     union {
         struct {
             int      id;
             uint32_t time;
         } timer;
         struct {
+            // raw = 0x83
+            // keycode = 0x03
+            // event = PRESS
+            // mods = SHIFT + ALT
             uint8_t  event;
             uint8_t  mods;
             char     c;
             uint32_t keycode;
             uint32_t scancode;
         } key;
+        struct {
+            uint32_t next_task_pid;
+        } task_switch;
+        struct {
+            uint32_t task_pid;
+        } task_kill;
     };
 } ebus_event_t;
 
@@ -56,8 +69,6 @@ typedef struct _ebus {
     arr_t handlers; // ebus_handler_t
     cb_t  queue;    // ebus_event_t
 
-    int enabled;
-
     int next_handler_id;
 } ebus_t;
 
@@ -77,7 +88,8 @@ int ebus_queue_size(ebus_t * bus);
 int  ebus_register_handler(ebus_t * bus, ebus_handler_t * handler);
 void ebus_unregister_handler(ebus_t * bus, int handler_id);
 
-void ebus_push(ebus_t * bus, ebus_event_t * event);
+int ebus_push(ebus_t * bus, ebus_event_t * event);
+int ebus_pop(ebus_t * bus, ebus_event_t * event_out);
 
 int ebus_cycle(ebus_t * bus);