Changeset 434 for trunk/user

Timestamp:

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

Author:

alain

Message:

blap

Location:

trunk/user

Files:

• init/init.c (modified) (4 diffs)
• ksh/ksh.c (modified) (4 diffs)
• pgcd/pgcd.c (modified) (1 diff)
• sort/sort.c (modified) (5 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 ); 
     }

trunk/user/ksh/ksh.c

@@ -297 +297 @@
 static void cmd_load( int argc , char **argv )
 {
-        unsigned int         ret_pid;
-    unsigned int         new_pid;
+        int                  ret;
+    unsigned int         ksh_pid;
         char               * pathname;
     unsigned int         background;
@@ -304 +304 @@
         if( (argc < 2) || (argc > 3) )  
     {
-                printf("  usage: %s pathname [&] \n", argv[0] );
+                printf("  usage: %s pathname [&]\n", argv[0] );
                 return;
         }
@@ -311 +311 @@
 
     if( argc == 3 ) background = (argv[2][0] == '&');
-
-    // fork system call
-        ret_pid = fork();
-
-    if (ret_pid == 0)  // it is the child process 
-    {
-        // exec system call
-        if( exec( pathname , NULL , NULL ) )
+    else            background = 0;
+
+    // get KSH process PID
+    ksh_pid = getpid();
+
+    // KSH process fork CHILD process
+        ret = fork();
+
+    if ( ret < 0 )      // it is a failure reported to parent
+    {
+        printf("  error: ksh process unable to fork\n");
+    }
+    else if (ret == 0)  // it is the CHILD process 
+    {
+        // give back to KSH process the terminal ownership
+        if( background ) fg( ksh_pid );
+
+        // CHILD process exec NEW process
+        ret = exec( pathname , NULL , NULL );
+
+        if( ret )
         {
             printf("  error: new process unable to exec <%s>\n", pathname );
             exit(0);
         }
-
-        // get new process pid
-        new_pid = getpid();
-
-        // give new process terminal ownership
-        if( background == 0 ) fg( new_pid );
         } 
-    else if ( ret_pid < 0 )  // it is a failure reported to parent
-    {
-        printf("  error: unable to fork\n");
-    }
 }   // end cmd_load
 
@@ -624 +627 @@
                 if (!found)
         {
-                        printf("\n  undefined command %s\n", argv[0]);
+                        printf("  undefined command <%s>\n", argv[0]);
                 }
         }

trunk/user/pgcd/pgcd.c

@@ -16 +16 @@
     int opx;
     int opy;
-    char c;
 
     printf( "*** Starting interactive pgcd ***\n\n" ); 

trunk/user/sort/sort.c

@@ -240 +240 @@
     {
         printf("\n[SORT ERROR] number of cores must be power of 2\n");
-        pthread_exit( NULL );
+        exit( 0 );
     }
 
@@ -247 +247 @@
     {
         printf("\n[SORT ERROR] array size must be multiple of number of threads\n");
-        pthread_exit( NULL );
+        exit( 0 );
     }
 
@@ -261 +261 @@
     {
         printf("\n[SORT ERROR] cannot initialise barrier\n" );
-        pthread_exit( NULL );
+        exit( 0 );
     }
 
@@ -309 +309 @@
                     {
                         printf("\n[SORT ERROR] creating thread %x\n", thread_uid );
-                        pthread_exit( NULL );
+                        exit( 0 );
                     }
          
@@ -350 +350 @@
     {
         printf("\n[SORT] success at cycle %d\n", (unsigned int)cycle );
-        pthread_exit( NULL );
+        exit( 0 );
     }
     else
     {
         printf("\n[SORT] failure at cycle %d\n", (unsigned int)cycle );
-        pthread_exit( NULL );
+        exit( 0 );
     }