Cheap waitpid()

Author: scopeInfinity

Makefile

@@ -102,7 +102,7 @@ binaries: $(bt_stage1) $(bt_stage2) $(kernel_core) $(rm_static)
 SECTOR_COUNT_BT_STAGE1 = 1
 SECTOR_COUNT_SHARED_LIBRARY = 1
 SECTOR_COUNT_BT_STAGE2 = 12
-SECTOR_COUNT_KERNEL = 47
+SECTOR_COUNT_KERNEL = 48
 
 SECTOR_START_BT_STAGE1 = 0
 SECTOR_START_SHARED_LIBRARY = $(shell expr $(SECTOR_START_BT_STAGE1) + $(SECTOR_COUNT_BT_STAGE1) )

include/fuzzy/kernel/process/process.h

@@ -13,6 +13,11 @@ enum process_state{
     STATE_READY,
     STATE_RUNNING,
     STATE_EXIT,    // should be unallocated in next scheduling cycle
+    STATE_BLOCK,    // process is waiting on IO, process_wait, etc.
+};
+
+enum process_state_block {
+    STATE_BLOCK_PROCESS_WAIT,   // waiting for another process termination.
 };
 
 struct Process {
@@ -22,6 +27,16 @@ struct Process {
     unsigned int *e;
 
     int status_code;
+
+    unsigned int ppid;  // parent pid, 0 to root under kernel_core
+
+    enum process_state_block block_type;  // valid, if state == BLOCK
+    union {
+        struct {
+            unsigned int blocked_on_pid;
+            unsigned int blocking_pid;  // TODO: make list
+        } process_wait;
+    } block_data;    // valid if state == BLOCK
 };
 
 void process_scheduler_init();
@@ -35,11 +50,12 @@ int get_gdt_number_from_entry_id(int id);
 // allocation
 int get_idt_cs_entry(int process_id);
 int get_idt_ds_entry(int process_id);
-int get_idt_reverse_pid_lookup(int cs);
+int get_idt_reverse_pid_lookup_cs(int cs);
+int get_idt_reverse_pid_lookup_ds(int ds);
 
 // process create or kill
-int process_create(int argc, char *argv[]);
-void process_kill(int user_ds, int status);
+int process_create(unsigned int ppid, int argc, char *argv[]);
+void process_kill(unsigned int pid, int status);
 
 // scheduler
 
@@ -50,3 +66,6 @@ void process_scheduler(int *_e_ip, int *_e_cs, int *_e_sp, int *_e_ss);
 // user space <-> kernel space data transfer helper
 extern void syscall_strncpy_user_to_kernel(int user_ds, char *src_es_address, char *dest_ds_address, size_t size);
 extern void syscall_strncpy_kernel_to_user(int user_ds, char *dest_address, char *src_address, size_t size);
+
+// state logic
+int process_waitpid(unsigned int pid, unsigned int blocked_on_pid);

src/drivers/keyboard/keyboard.c

@@ -166,6 +166,14 @@ char keyboard_get_key_pressed_blocking() {
     return c;
 }
 
+char keyboard_get_key_pressed_poll() {
+    for (int i = 0; !keyboard_scanner_ascii_is_available() && i < 100; i++) {
+        keyboard_scanner_step();
+    }
+    char c = keyboard_scanner_ascii_get();
+    return c;
+}
+
 void keyboard_init() {
     unsigned char original_colors =  get_color_fgbg();
     sleep_mini(3000000);

src/drivers/keyboard/keyboard.h

@@ -2,4 +2,5 @@
 
 void keyboard_init();
 
-char keyboard_get_key_pressed_blocking();
+char keyboard_get_key_pressed_blocking();
+char keyboard_get_key_pressed_poll();

src/drivers/keyboard/scancode_handler.c

@@ -209,8 +209,10 @@ int keyboard_scanner_ascii_is_available() {
 }
 
 char keyboard_scanner_ascii_get() {
+    char c = last_ascii;
     last_ascii_available = 0;
-    return last_ascii;
+    last_ascii = 0;
+    return c;
 }
 
 void keyboard_scanner_handler_init() {

src/kernel/process/allocation.c

@@ -72,6 +72,7 @@ struct GDTEntry gdt_table[GDT_TABLE_SIZE];
 struct GDTReference gdtr;
 
 struct Process *get_process(int pid) {
+    if(pid<0 || pid>=MAX_PROCESS) return NULL;
     return &processes[pid];
 }
 
@@ -83,6 +84,7 @@ void process_scheduler_init() {
     // after the process scheduler starts
     // main thread kernel is ready to be killed.
     processes[PID_KERNEL].state=STATE_EXIT;
+    processes[PID_KERNEL].ppid=PID_KERNEL;
 
     populate_gdt_table(
         &gdtr, gdt_table, GDT_TABLE_SIZE,
@@ -121,7 +123,7 @@ static int create_infant_process_argv_stack(int user_ds, int user_sp,
     return user_sp;
 }
 
-int process_create(int argc, char *argv[]) {
+int process_create(unsigned int ppid, int argc, char *argv[]) {
     // returnd pid >= 0 if success
     int pid = -1;
     for (int i = 0; i < MAX_PROCESS; ++i) {
@@ -157,6 +159,7 @@ int process_create(int argc, char *argv[]) {
 
 
     // update process state
+    process->ppid = ppid;
     process->state = STATE_LOADING;
     process->cs = get_gdt_number_from_entry_id(idt_cs_entry);
     process->ip = 0;
@@ -167,8 +170,7 @@ int process_create(int argc, char *argv[]) {
     return pid;
 }
 
-void process_kill(int user_ds, int status) {
-    int pid = get_idt_reverse_pid_lookup_ds(user_ds);
+void process_kill(unsigned int pid, int status) {
     struct Process *process = &processes[pid];
     process->status_code = status;
     process->state = STATE_EXIT;

src/kernel/process/process.c

@@ -8,9 +8,10 @@
 #include <lib/utils/logging.h>
 #include <lib/utils/output.h>
 
-int process_spawn(int lba_index, int sector_count, int argc, char *argv[]) {
+int process_spawn(int lba_index, int sector_count,
+        unsigned int ppid, int argc, char *argv[]) {
     print_info("[process_spawn] create");
-    int pid = process_create(argc, argv);
+    int pid = process_create(ppid, argc, argv);
     if(pid<0) {
         print_log("Failed to reserved a new pid");
         return -1;
@@ -26,30 +27,25 @@ int process_spawn(int lba_index, int sector_count, int argc, char *argv[]) {
     struct Process *process = get_process(pid);
     process->state = STATE_READY;
     VERIFY_STACKGUARD();
-    return 0;
+    return pid;
 }
 
 int process_exec(int lba_index, int sector_count) {
     // Not yet implemented
     return -1;
 }
 
-int syscall_1_process_exit(int user_ds, int status) {
-    process_kill(user_ds, status);
+int syscall_1_process_exit(int pid, int status) {
+    process_kill(pid, status);
     return 0;
 }
 
-int syscall_1_process_spawn_lba_sc(int lba_start, int sector_count) {
-    int fake_argc = 1;
-    ARGV fake_argv={"fake_spawn", NULL};
-    return process_spawn(lba_start, sector_count, fake_argc, fake_argv);
-}
-
-int syscall_1_process_exec_lba_sc(int lba_start, int sector_count) {
-    return process_exec(lba_start, sector_count);
+int syscall_1_process_wait(int pid, int blocked_on_pid) {
+    return process_waitpid(pid, blocked_on_pid);
 }
 
-int syscall_1_process_spawn_fname(int user_ds, char *_us_filename, char *_us_argv[]) {
+int syscall_1_process_spawn_fname(unsigned int user_pid,
+        int user_ds, char *_us_filename, char *_us_argv[]) {
     // User must send all PROCESS_MAX_ARGC arguments.
     char *argv_with_uspointer[PROCESS_MAX_ARGC];
     char filename[FS_FFS_FILENAME_LIMIT];
@@ -74,20 +70,19 @@ int syscall_1_process_spawn_fname(int user_ds, char *_us_filename, char *_us_arg
     int lba_start = resolve_abs_lba(FFS_UNIQUE_PARITION_ID, entry.content.start_block_id);
     int sector_count = (entry.content.filesize + FS_BLOCK_SIZE -1)/FS_BLOCK_SIZE;
 
-    return process_spawn(lba_start, sector_count, argc, argv);
+    return process_spawn(lba_start, sector_count, user_pid, argc, argv);
 }
 
 int syscall_1_process(int operation, int a0, int a1, int a2, int a3, int user_ds) {
+    int user_pid = get_idt_reverse_pid_lookup_ds(user_ds);
     switch (operation) {
         case SYSCALL_PROCESS_SUB_EXIT:
-            syscall_1_process_exit(user_ds, a0);
+            syscall_1_process_exit(user_pid, a0);
             return 0;
-        case SYSCALL_PROCESS_SUB_SPAWN_LBA_SC:
-            return syscall_1_process_spawn_lba_sc(a0, a1);
-        case SYSCALL_PROCESS_SUB_EXEC_LBA_SC:
-            return syscall_1_process_exec_lba_sc(a0, a1);
+        case SYSCALL_PROCESS_SUB_WAIT:
+            return syscall_1_process_wait(user_pid, a0);
         case SYSCALL_PROCESS_SUB_SPAWN_FNAME:
-            return syscall_1_process_spawn_fname(user_ds, (char*)a0, (char**)a1);
+            return syscall_1_process_spawn_fname(user_pid, user_ds, (char*)a0, (char**)a1);
     }
     return -1;
 }

src/kernel/process/scheduler.c

@@ -74,6 +74,9 @@ void process_scheduler(int *_e_ip, int *_e_cs, int *_e_sp, int *_e_ss) {
         process->ss = e_ss;
         process->sp = e_sp;
     }
+    // last process can be
+    //  - RUNNING
+    //  - BLOCK  # TODO: implement
 
     struct Process *nprocess = get_process(npid);
     nprocess->state = STATE_RUNNING;
@@ -86,4 +89,19 @@ void process_scheduler(int *_e_ip, int *_e_cs, int *_e_sp, int *_e_ss) {
     *_e_cs = e_cs;
     *_e_sp = e_sp;
     *_e_ss = e_ss;
-}
+}
+
+int process_waitpid(unsigned int pid, unsigned int blocked_on_pid) {
+    // TODO: this implementation has flaws.
+    // We need to do better something.
+    // It currently allows blocking on any pid, and rely on syscall client
+    // for yield.
+    struct Process *other_process = get_process(blocked_on_pid);
+    if(other_process==NULL) {
+        return -1;  // err
+    }
+    if(other_process->state == STATE_COLD) {
+        return 0;  // no error, wait over
+    }
+    return 1; // no error, keep waiting
+}

src/kernel/syscall/syscall.c

@@ -14,7 +14,7 @@
 int SYSCALL_TABLE[SYSCALL_SIZE];
 
 int syscall_0_keyboard_getch(int a0,int a1,int a2,int a3, int user_ds) {
-    return keyboard_get_key_pressed_blocking();
+    return keyboard_get_key_pressed_poll();
 }
 
 extern int interrupt_handler_0x32_syscall_handler();

src/usr/include/process.h

@@ -1,9 +1,8 @@
 #pragma once
 
 #define SYSCALL_PROCESS_SUB_EXIT         0
-#define SYSCALL_PROCESS_SUB_SPAWN_LBA_SC 1
-#define SYSCALL_PROCESS_SUB_EXEC_LBA_SC  2
-#define SYSCALL_PROCESS_SUB_SPAWN_FNAME  3
+#define SYSCALL_PROCESS_SUB_WAIT         1
+#define SYSCALL_PROCESS_SUB_SPAWN_FNAME  2
 
 #define PROCESS_MAX_ARGC     6
 #define PROCESS_MAX_ARG_LEN  32
@@ -15,3 +14,4 @@ int spawnl(char *path, char *arg0, ...);
 int spawnv(char *path, char *argv[]);
 
 void yield();
+int waitpid(unsigned int blocked_on_pid);