getpid(...) should fetch other process exit_code

Author: scopeInfinity

include/fuzzy/kernel/process/process.h

@@ -28,7 +28,7 @@ struct Process {
     unsigned int ss, cs, sp, ip;
     unsigned int *e;
 
-    int status_code;
+    int exit_code;
 
     unsigned int ppid;  // parent pid, 0 to root under kernel_core
 
@@ -78,7 +78,7 @@ extern void syscall_strncpy_kernel_to_user(int user_ds, char *dest_address, char
 extern void kernel_memncpy_absolute(int dst_ds, char *dst_address, int src_ds, char *src_address, size_t size);
 
 // operations
-int process_waitpid(unsigned int pid, unsigned int blocked_on_pid);
+int process_waitpid(unsigned int pid, unsigned int blocked_on_pid, int *exit_code);
 
 int process_fork_mark_ready(int pid);
 int process_fork_check_ready(int pid);

src/kernel/process/allocation.c

@@ -185,9 +185,9 @@ int process_create(unsigned int ppid, int argc, char *argv[]) {
     return pid;
 }
 
-void process_kill(unsigned int pid, int status) {
+void process_kill(unsigned int pid, int exit_code) {
     struct Process *process = &processes[pid];
-    process->status_code = status;
+    process->exit_code = exit_code;
     process->state = STATE_EXIT;
 }
 

src/kernel/process/process.c

@@ -35,13 +35,21 @@ int process_exec(int lba_index, int sector_count) {
     return -1;
 }
 
-int syscall_1_process_exit(int pid, int status) {
-    process_kill(pid, status);
+int syscall_1_process_exit(int pid, int exit_code) {
+    process_kill(pid, exit_code);
     return 0;
 }
 
-int syscall_1_process_wait(int pid, int blocked_on_pid) {
-    return process_waitpid(pid, blocked_on_pid);
+int syscall_1_process_wait(int user_ds, int pid, int blocked_on_pid, int *_us_exit_code) {
+    int exit_code;
+    int return_value = process_waitpid(pid, blocked_on_pid, &exit_code);
+    if(_us_exit_code != NULL) {
+        // forward exit_code only if user wants it
+        syscall_strncpy_kernel_to_user(
+            user_ds, _us_exit_code,
+            &exit_code, sizeof(exit_code));
+    }
+    return return_value;
 }
 
 int syscall_1_process_fork(int user_pid, int op) {
@@ -101,7 +109,7 @@ int syscall_1_process(int operation, int a0, int a1, int a2, int a3, int user_ds
             syscall_1_process_exit(user_pid, a0);
             return 0;
         case SYSCALL_PROCESS_SUB_WAIT:
-            return syscall_1_process_wait(user_pid, a0);
+            return syscall_1_process_wait(user_ds, user_pid, a0, a1);
         case SYSCALL_PROCESS_SUB_FORK:
             return syscall_1_process_fork(user_pid, a0);
         case SYSCALL_PROCESS_SUB_GET:

src/kernel/process/scheduler.c

@@ -110,14 +110,15 @@ void process_scheduler(int *_e_ip, int *_e_cs, int *_e_sp, int *_e_ss) {
     *_e_ss = e_ss;
 }
 
-int process_waitpid(unsigned int pid, unsigned int blocked_on_pid) {
+int process_waitpid(unsigned int pid, unsigned int blocked_on_pid, int *exit_code) {
     // 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) {
+        *exit_code = other_process->exit_code;
         return 0;  // no error, wait over
     }
     return 1; // no error, keep waiting

src/usr/include/process.h

@@ -24,4 +24,4 @@ int getpid();
 
 int fork();
 void yield();
-int waitpid(unsigned int blocked_on_pid);
+int waitpid(unsigned int blocked_on_pid, int *exit_code);

src/usr/lib/process.c

@@ -47,9 +47,9 @@ void yield() {
     __asm__("int $0x20");
 }
 
-int waitpid(unsigned int blocked_on_pid) {
+int waitpid(unsigned int blocked_on_pid, int *exit_code) {
     while(1) {
-        int status = SYSCALL_A2(SYSCALL_PROCESS, SYSCALL_PROCESS_SUB_WAIT, blocked_on_pid);
+        int status = SYSCALL_A3(SYSCALL_PROCESS, SYSCALL_PROCESS_SUB_WAIT, blocked_on_pid, exit_code);
         if(status < 0) {
             // err
             return status;

src/usr/local/src/multiprocessing.c

@@ -18,7 +18,7 @@ int main(int argc,char *argv[]) {
         // parent process
         printf("parent process: says Hi\n");
         printf("will for child process to exit\n");
-        waitpid(pid);
+        waitpid(pid, NULL);
     }
     printf("process exiting. Is correct process the child: %s\n", (am_i_child)?"Yes":"No");
 

src/usr/local/src/sh.c

@@ -18,6 +18,7 @@ int cmd_help() {
     printf(" > exit                       kill the current shell\n");
     printf(" > <filename> [arg1]...       execute executable program\n");
     printf(" > ls -h                      example to show ls usage\n");
+    last_status_code = 0;
     return 0;
 }
 
@@ -32,6 +33,11 @@ static char *copy_arg(char *dst, char *src) {
 }
 
 int cmd_run(char *cmd) {
+    if(cmd == NULL) {
+        // no command entered
+        last_status_code = 0;
+        return 0;
+    }
     char *argv[PROCESS_MAX_ARGC];
     char argv_data[PROCESS_MAX_ARGC][PROCESS_MAX_ARG_LEN] = {0};
 
@@ -51,7 +57,7 @@ int cmd_run(char *cmd) {
         // failed
         return pid;
     }
-    waitpid(pid);
+    waitpid(pid, &last_status_code);
     return 0;
 }
 
@@ -68,12 +74,11 @@ void handle_command(char *full_cmd) {
     char *cmd = strtok(full_cmd, COMMAND_DELIM);
 
     if (strcmp(cmd, "help")==0) {
-        last_status_code = cmd_help();
+        cmd_help();
     } else if (strcmp(cmd, "exit")==0) {
-        last_status_code = cmd_exit();
+        cmd_exit();
     } else {
-        last_status_code = cmd_run(cmd);
-        if (last_status_code < 0) {
+        if (cmd_run(cmd) < 0) {
             printf("failed to run '%s' command\n", cmd);
         }
     }