Changeset 434 for trunk/user/init/init.c

Timestamp:

Feb 14, 2018, 3:41:31 PM (7 years ago)

Author:

alain

Message:

blap

File:

• trunk/user/init/init.c (modified) (4 diffs)

trunk/user/init/init.c

@@ -5 +5 @@
 ///////////////////////////////////////////////////////////////////////////////////////
 // This single thread application implement the "init" process for ALMOS-MKH. 
-// - It uses the fork/exec syscalls to create N KSH child processes 
-//   (one child process per user terminal), and register the corresponding PIDs
-//   in the ksh_pid[] array. Then it calls the wait() function to block.
-// - It is reactivated when any child KSH process is terminated by a SIGKILL signal,
-//   or stopped by a SIGSTOP signal. In case of SIGKILL, it scan all registered KSH 
-//   processes and re-creates each killed KSH process, using a new fork/exec.
-// It includes the hard_config.h file to get the NB_TXT_CHANNELS parameter.
+// It uses the fork/exec syscalls to create N KSH child processes 
+// (one child process per user terminal).
+// It includes the hard_config.h file to get th NB_TXT_CHANNELS parameter.
+//
+// TODO : Register the PIDs for all KSH[i] in a ksh_pid[] array. 
+// Then calls the wait() function to block, and reactivate any child KSH process
+// that has been deleted, using a new fork/exec.
 ///////////////////////////////////////////////////////////////////////////////////////
 
@@ -20 +20 @@
 #include <pthread.h>
 
-#define NB_KSH  (NB_TXT_CHANNELS - 1)
-
+#define DELAY_BETWEEN_FORK 100000
 
 //////////
@@ -27 +26 @@
 {
     int     i;
-    int     ret;           // fork return value  
-    int     child_pid;
-    int     status;        // used by the wait function
+    int     ret_fork;      // fork return value  
+    int     ret_exec;      // fork return value  
+    int     received_pid;  // pid received from the wait syscall
+    int     status;        // used by the wait syscall
     char    string[64];
 
@@ -36 +36 @@
 
     // create the KSH processes (one per user terminal)
-    for( i = 0 ; i <  NB_KSH ; i++ )
+    for( i = 1 ; i <  NB_TXT_CHANNELS ; i++ )
     {
-        // INIT process fork process CHILD
-        ret = fork();
 
-        if( ret < 0 )                            // error in fork
+snprintf( string , 64 , "@@@ before fork / iter = %d\n" , i );
+display_string( string );
+
+        // INIT process fork process CHILD[i]
+        ret_fork = fork();
+
+snprintf( string , 64 , "@@@ after fork / iter = %d / ret_fork = %d\n" , i , ret_fork );
+display_string( string );
+
+        if( ret_fork< 0 )   // error in fork
         {
-            // display error message on TXT0 terminal 
-            display_string( "init process cannot fork\n" );
-
-            // INIT process exit
-            exit( 1 );
-        }
-        else if( ret > 0 )                     // we are in INIT process
-        {
-            // INIT display string on kernel TXT0
-            snprintf( string , 64 , "INIT created KSH[%d]\n" , i );
+            // INIT display error message on TXT0 terminal 
+            snprintf( string , 64 , "init cannot fork child[%d]\n" , i );
             display_string( string );
 
-            // INIT process deschedule
-            pthread_yield();
+            // INIT exit
+            exit( 0 );
         }
-        else                                   // we are in CHILD process
+        else if( ret_fork == 0 )                    // we are in CHILD[i] process
         {
-            // CHILD process exec process KSH
-            if ( exec( "/bin/user/ksh.elf" , NULL , NULL ) )  // CHILD failure
+            // CHILD[i] process exec process KSH[i]
+            ret_exec = exec( "/bin/user/ksh.elf" , NULL , NULL ); 
+
+            if ( ret_exec )   // error in exec              
             {
                 // display error message on TXT0 terminal
-                display_string( "child process cannot exec process ksh\n" );
+                snprintf( string , 64 , "child[%d] cannot exec ksh[%d]\n" , i , i );
+                display_string( string );
 
-                // CHILD process exit
-                exit( 1 );
-            }
-            else                                             // child success
-            {
-                // CHILD process deschedule
-                pthread_yield();
+                // CHILD[i] exit
+                // exit( 0 );
             }
         }
-    } 
+        else                                      // we are in INIT process
+        {
+             // INIT display CHILD[i] process PID
+             snprintf( string , 64 , "INIT forked CHILD[%d] / pid = %x\n", i , ret_fork ); 
+             display_string( string );
 
+             // INIT delay
+             int     x;
+             for( x=0 ; x<DELAY_BETWEEN_FORK ; x++) asm volatile ("nop");
+
+/*
+             // INIT wait exec completion by CHILD[i]
+             while( 1 )
+             {
+                 // get terminating process PID
+                 received_pid = wait( &status );
+
+                 if( received_pid == ret_fork ) break;
+                 else
+                 {
+                     snprintf( string , 64 , 
+                     "expected_pid %d / received_pid %d" , ret_fork , received_pid  );
+                     display_string( string );
+                 }
+             }
+
+*/
+             // INIT display string on kernel TXT0
+             snprintf( string , 64 , "INIT created KSH[%d]\n", i );
+             display_string( string );
 // @@@
-display_string( "@@@  INIT process created all KSH processes\n" );
 display_process( 0 );
 display_sched( 0 , 0 );
 // @@@
+        }
+
+    } 
 
     // This blocking loop is only for debug, because KSH[i] processes
-    // should never be killed, and INIT should never exit the wait() function.
+    // should never be killed, and INIT should never return from the wait() function.
     while( 1 )
     {
         // block on child process termination
-        child_pid = wait( &status ); 
+        received_pid = wait( &status ); 
 
-        // build a string to report unexpected KSH process termination
-        snprintf( string , 64 , "KSH process %x unexpectedly terminated" , child_pid );
-
-        // display string on kernel TXT0 (INIT has no TXT terminal)
+        // display string to report unexpected KSH process termination
+        snprintf( string , 64 , "KSH process %x unexpectedly terminated" , received_pid );
         display_string( string ); 
     }