Add simple multiprocessing example and changed scheduling algorithm to RR

Author: scopeInfinity

src/kernel/process/allocation.c

@@ -123,21 +123,23 @@ static int create_infant_process_argv_stack(int user_ds, int user_sp,
     return user_sp;
 }
 
-static int get_cold_pid() {
-    int pid = -1;
+static int get_cold_pid_to_allocate() {
+    static int pid = 0;
+    pid = 0;  // BUG: What PID wrap around doesn't work?
     for (int i = 0; i < MAX_PROCESS; ++i) {
-        if(i==PID_KERNEL) continue;
-        if(processes[i].state == STATE_COLD) {
-            pid = i;
-            break;
+        pid = (pid+1)%MAX_PROCESS;
+        if (pid!=PID_KERNEL && processes[pid].state == STATE_COLD) {
+            // return a PID to allocate
+            return pid;
         }
     }
-    return pid;
+    // no free PID found.
+    return -1;
 }
 
 int process_create(unsigned int ppid, int argc, char *argv[]) {
     // returnd pid >= 0 if success
-    int pid = get_cold_pid();
+    int pid = get_cold_pid_to_allocate();
     if(pid < 0) return pid;
     struct Process *process = &processes[pid];
     // reset state

src/kernel/process/process.c

@@ -47,7 +47,6 @@ int syscall_1_process_wait(int pid, int blocked_on_pid) {
 int syscall_1_process_fork(int user_pid, int op) {
     switch (op) {
         case SYSCALL_PROCESS_SUB_FORK_MARK_READY:
-            // print_log("FORK REQUESTED:: %d", user_pid);
             return process_fork_mark_ready(user_pid);
         case SYSCALL_PROCESS_SUB_FORK_CHECK_READY:
             return process_fork_check_ready(user_pid);

src/kernel/process/scheduler.c

@@ -46,7 +46,7 @@ void process_scheduler_stash_state() {
 
 int process_scheduler_get_next_pid(int lastpid) {
     // execute one of the scheduling algorithm
-    return process_scheduler_largestpid(lastpid);
+    return process_scheduler_rr(lastpid);
 }
 
 static void handle_fork(unsigned int ppid, struct Process *process) {
@@ -120,8 +120,6 @@ void process_scheduler(int *_e_ip, int *_e_cs, int *_e_sp, int *_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);

src/usr/local/src/ls.c

@@ -1,7 +1,6 @@
 // list directory
 #include <stdio.h>
 #include <dirent.h>
-#include <process.h>
 
 void process() {
     struct DIR dir;
@@ -14,9 +13,6 @@ void process() {
 }
 
 int main(int argc,char *argv[]) {
-
-    int p = fork();
-    printf("fork() = %d\n", p);
     process();
     return 0;
 }

src/usr/local/src/multiprocessing.c

@@ -0,0 +1,25 @@
+// multiprocessing example
+#include <stdio.h>
+#include <process.h>
+
+
+int main(int argc,char *argv[]) {
+    printf("main process, executing fork()\n");
+    int pid = fork();
+    printf("fork()=%d\n", pid);
+    int am_i_child;
+    if(pid == 0) {
+        // child process
+        am_i_child=1;
+        printf("child process: says Hi\n");
+    } else {
+        am_i_child=0;
+        // parent process
+        printf("parent process: says Hi\n");
+        printf("will for child process to exit\n");
+        waitpid(pid);
+    }
+    printf("process exiting. Am I child process=%s\n", (am_i_child)?"Yes":"No");
+
+    return 0;
+}

src/usr/local/src/sh.c

@@ -86,8 +86,6 @@ int main(int argc, char *argv[]) {
     banner();
     cmd_help();
     int c = 0;
-    strcpy(command, "run ls");
-    handle_command(command);
     while (1) {
         printf("[%d] $ ", last_status_code);
         gets(command);