Changeset 436 for trunk/user


Ignore:
Timestamp:
Mar 7, 2018, 9:02:03 AM (4 years ago)
Author:
alain
Message:

1) improve the threads and process destruction mechanism.
2) introduce FIFOs in the soclib_tty driver.

Location:
trunk/user
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/user/init/init.c

    r435 r436  
    2020#include <pthread.h>
    2121
    22 #define DELAY_BETWEEN_FORK 100000
    23 
    2422//////////
    2523int main()
     
    2826    int     ret_fork;      // fork return value 
    2927    int     ret_exec;      // fork return value 
    30     int     received_pid;  // pid received from the wait syscall
     28    int     rcv_pid;       // pid received from the wait syscall
    3129    int     status;        // used by the wait syscall
    3230    char    string[64];
     
    4139        ret_fork = fork();
    4240
    43         if( ret_fork< 0 )   // error in fork
     41        if( ret_fork < 0 )   // error in fork
    4442        {
    4543            // INIT display error message on TXT0 terminal
    46             snprintf( string , 64 ,
    47             "INIT cannot fork child[%d]\n" , i );
     44            snprintf( string , 64 , "INIT cannot fork child[%d]" , i );
    4845            display_string( string );
    4946
    50             // INIT exit
     47            // INIT suicide
    5148            exit( 0 );
    5249        }
     
    5855            if ( ret_exec )   // error in exec             
    5956            {
    60                 // display error message on TXT0 terminal
     57                // CHILD[i] display error message on TXT0 terminal
    6158                snprintf( string , 64 ,
    62                 "CHILD[%d] cannot exec KSH[%d] / ret_exec = %d\n" , i , i , ret_exec );
     59                "CHILD[%d] cannot exec KSH[%d] / ret_exec = %d" , i , i , ret_exec );
    6360                display_string( string );
    6461            }
     
    6764        {
    6865             // INIT display CHILD[i] process PID
    69              snprintf( string , 64 ,
    70              "INIT forked CHILD[%d] / pid = %x\n", i , ret_fork );
     66             snprintf( string , 64 , "INIT created KSH[%d] / pid = %x", i , ret_fork );
    7167             display_string( string );
    7268        }
    73 
    7469    }
    7570
    7671    // This loop detects the termination of the KSH[i] processes,
    77     // to recreate these process when required.
     72    // and recreate a new KSH[i] process when required.
    7873    while( 1 )
    7974    {
    8075        // block on child processes termination
    81         received_pid = wait( &status );
     76        rcv_pid = wait( &status );
    8277
    8378        if( WIFSTOPPED( status ) )                         // stopped => unblock it
    8479        {
    8580            // display string to report unexpected KSH process block
    86             snprintf( string , 64 , "KSH process %x unexpectedly stopped" , received_pid );
     81            snprintf( string , 64 , "KSH process %x stopped => unblock it" , rcv_pid );
    8782            display_string( string );
    8883
    89         }
     84            // TODO : unblock KSH
     85
     86        }  // end KSH stopped handling
    9087
    9188        if( WIFSIGNALED( status ) || WIFEXITED( status ) )  // killed => recreate it
    9289        {
    9390            // display string to report unexpected KSH process termination
    94             snprintf( string , 64 , "KSH process %x unexpectedly terminated" , received_pid );
     91            snprintf( string , 64 , "KSH process %x terminated => recreate KSH", rcv_pid );
    9592            display_string( string );
    96         }
     93
     94            // INIT process fork a new CHILD process
     95            ret_fork = fork();
     96
     97            if( ret_fork < 0 )                          // error in fork
     98            {
     99                // INIT display error message on TXT0 terminal
     100                snprintf( string , 64 , "INIT cannot fork child");
     101                display_string( string );
     102
     103                // INIT suicide
     104                exit( 0 );
     105            }
     106            else if( ret_fork == 0 )                    // we are in CHILD process
     107            {
     108                // CHILD process exec process KSH
     109                ret_exec = exec( "/bin/user/ksh.elf" , NULL , NULL );
     110
     111                if ( ret_exec )   // error in exec             
     112                {
     113                    // CHILD display error message on TXT0 terminal
     114                    snprintf( string , 64 , "CHILD cannot exec KSH" );
     115                    display_string( string );
     116                }
     117            }
     118            else                                       // we are in INIT process
     119            {
     120                // INIT display new CHILD process PID
     121                snprintf( string , 64 , "INIT forked CHILD / pid = %x", ret_fork );
     122                display_string( string );
     123            }
     124        }  // end KSH kill handling
    97125    }
    98126
  • trunk/user/ksh/ksh.c

    r435 r436  
    1313
    1414#define CMD_MAX_SIZE   (256)    // max number of characters in one command
    15 #define LOG_DEPTH      (256)    // max number of registered commands
     15#define LOG_DEPTH      (32)     // max number of registered commands
    1616#define MAX_ARGS           (32)     // max number of arguments in a command
    1717#define FIFO_SIZE      (1024)   // FIFO depth for recursive ls
     
    228228}   // end cmd_cp()
    229229
     230/////////////////////////////////////////////////
     231static void cmd_display( int argc , char **argv )
     232{
     233    unsigned int  cxy;
     234    unsigned int  lid;
     235    unsigned int  pid;
     236    unsigned int  txt_id;
     237
     238    if( strcmp( argv[1] , "vmm" ) == 0 )
     239    {
     240        if( argc != 3 )
     241        {
     242                    printf("  usage: display vmm pid\n");
     243                    return;
     244            }
     245
     246            pid = atoi(argv[2]);
     247
     248        if( display_vmm( pid ) )
     249        {
     250            printf("  error: illegal arguments pid = %x\n", pid );
     251        }
     252    }
     253    else if( strcmp( argv[1] , "sched" ) == 0 )
     254    {
     255        if( argc != 4 )
     256        {
     257                    printf("  usage: display sched cxy lid\n");
     258                    return;
     259            }
     260
     261            cxy = atoi(argv[2]);
     262            lid = atoi(argv[3]);
     263
     264        if( display_sched( cxy , lid ) )
     265        {
     266            printf("  error: illegal arguments cxy = %x / lid = %d\n", cxy, lid );
     267        }
     268    }
     269    else if( strcmp( argv[1] , "process" ) == 0 )
     270    {
     271        if( argc != 3 )
     272        {
     273                    printf("  usage: display process cxy\n");
     274                    return;
     275            }
     276
     277            cxy = atoi(argv[2]);
     278
     279        if( display_cluster_processes( cxy ) )
     280        {
     281            printf("  error: illegal argument cxy = %x\n", cxy );
     282        }
     283    }
     284    else if( strcmp( argv[1] , "txt" ) == 0 )
     285    {
     286        if( argc != 3 )
     287        {
     288                    printf("  usage: display txt txt_id\n");
     289                    return;
     290            }
     291
     292            txt_id = atoi(argv[2]);
     293
     294        if( display_txt_processes( txt_id ) )
     295        {
     296            printf("  error: illegal argument txt_id = %x\n", txt_id );
     297        }
     298    }
     299    else if( strcmp( argv[1] , "vfs" ) == 0 )
     300    {
     301        if( argc != 2 )
     302        {
     303                    printf("  usage: display vfs\n");
     304                    return;
     305            }
     306
     307        display_vfs();
     308    }
     309    else if( strcmp( argv[1] , "chdev" ) == 0 )
     310    {
     311        if( argc != 2 )
     312        {
     313                    printf("  usage: display chdev\n");
     314                    return;
     315            }
     316
     317        display_chdev();
     318    }
     319    else
     320    {
     321        printf("  usage: display (vmm/sched/process/vfs/chdev/txt) [arg2] [arg3]\n");
     322    }
     323} // end cmd_display()
     324
    230325/////////////////////////////////////////
    231326static void cmd_fg(int argc, char **argv)
     
    250345                printf("  error: cannot find process %x\n", pid );
    251346        }
    252 }
     347}  // end cmd_fg()
    253348
    254349//////////////////////////////////////////////
     
    297392static void cmd_load( int argc , char **argv )
    298393{
    299         int                  ret;
    300     unsigned int         ksh_pid;
    301         char               * pathname;
    302     unsigned int         background;
     394        int                  ret_fork;           // return value from fork
     395        int                  ret_exec;           // return value from exec
     396    unsigned int         ksh_pid;            // KSH process PID
     397    unsigned int         new_pid;            // new process PID
     398    unsigned int         rcv_pid;            // terminating process PID
     399        char               * pathname;           // path to .elf file
     400    unsigned int         background;         // background execution if non zero
     401    int                  status;             // new process exit status
    303402
    304403        if( (argc < 2) || (argc > 3) ) 
     
    317416
    318417    // KSH process fork CHILD process
    319         ret = fork();
    320 
    321     if ( ret < 0 )      // it is a failure reported to parent
     418        ret_fork = fork();
     419
     420    if ( ret_fork < 0 )          // it is a failure reported to KSH
    322421    {
    323422        printf("  error: ksh process unable to fork\n");
    324423    }
    325     else if (ret == 0)  // it is the CHILD process
    326     {
    327         // give back to KSH process the terminal ownership
     424    else if (ret_fork == 0)      // it is the CHILD process
     425    {
     426        // give back to KSH terminal ownership if required
    328427        if( background ) fg( ksh_pid );
    329428
    330429        // CHILD process exec NEW process
    331         ret = exec( pathname , NULL , NULL );
    332 
    333         if( ret )
     430        ret_exec = exec( pathname , NULL , NULL );
     431
     432        if( ret_exec )
    334433        {
    335434            printf("  error: new process unable to exec <%s>\n", pathname );
    336435            exit(0);
     436        }   
     437        }
     438    else                        // it is the parent KSH : ret_fork is the new process PID
     439    {
     440        new_pid = ret_fork;
     441
     442        // wait new process completion
     443        rcv_pid = wait( &status );
     444
     445        if( rcv_pid == new_pid )
     446        {
     447            printf("\n\n   exit %s / status = %x\n\n", pathname, (status &0xFF) );
    337448        }
    338         }
     449        else
     450        {
     451            printf("\n\n   abnormal termination for %s \n\n", pathname );
     452        }
     453    }
     454                 
    339455}   // end cmd_load
    340456
     
    347463        for (i = 0; i < LOG_DEPTH; i++)
    348464    {
    349                 printf(" - %zu\t: %s\n", i, &log_entries[i].buf);
     465                printf(" - %d\t: %s\n", i, &log_entries[i].buf);
    350466        }
    351467}
     
    476592{
    477593        cmd_rm(argc, argv);
    478 }
    479 
    480 /////////////////////////////////////////////////
    481 static void cmd_display( int argc , char **argv )
    482 {
    483     unsigned int  cxy;
    484     unsigned int  lid;
    485     unsigned int  pid;
    486     unsigned int  txt_id;
    487 
    488     if( strcmp( argv[1] , "vmm" ) == 0 )
    489     {
    490         if( argc != 3 )
    491         {
    492                     printf("  usage: display vmm pid\n");
    493                     return;
    494             }
    495 
    496             pid = atoi(argv[2]);
    497 
    498         if( display_vmm( pid ) )
    499         {
    500             printf("  error: illegal arguments pid = %x\n", pid );
    501         }
    502     }
    503     else if( strcmp( argv[1] , "sched" ) == 0 )
    504     {
    505         if( argc != 4 )
    506         {
    507                     printf("  usage: display sched cxy lid\n");
    508                     return;
    509             }
    510 
    511             cxy = atoi(argv[2]);
    512             lid = atoi(argv[3]);
    513 
    514         if( display_sched( cxy , lid ) )
    515         {
    516             printf("  error: illegal arguments cxy = %x / lid = %d\n", cxy, lid );
    517         }
    518     }
    519     else if( strcmp( argv[1] , "process" ) == 0 )
    520     {
    521         if( argc != 3 )
    522         {
    523                     printf("  usage: display process cxy\n");
    524                     return;
    525             }
    526 
    527             cxy = atoi(argv[2]);
    528 
    529         if( display_cluster_processes( cxy ) )
    530         {
    531             printf("  error: illegal argument cxy = %x\n", cxy );
    532         }
    533     }
    534     else if( strcmp( argv[1] , "txt" ) == 0 )
    535     {
    536         if( argc != 3 )
    537         {
    538                     printf("  usage: display txt txt_id\n");
    539                     return;
    540             }
    541 
    542             txt_id = atoi(argv[2]);
    543 
    544         if( display_txt_processes( txt_id ) )
    545         {
    546             printf("  error: illegal argument txt_id = %x\n", txt_id );
    547         }
    548     }
    549     else if( strcmp( argv[1] , "vfs" ) == 0 )
    550     {
    551         if( argc != 2 )
    552         {
    553                     printf("  usage: display vfs\n");
    554                     return;
    555             }
    556 
    557         display_vfs();
    558     }
    559     else if( strcmp( argv[1] , "chdev" ) == 0 )
    560     {
    561         if( argc != 2 )
    562         {
    563                     printf("  usage: display chdev\n");
    564                     return;
    565             }
    566 
    567         display_chdev();
    568     }
    569     else
    570     {
    571         printf("  usage: display (vmm/sched/process/vfs/chdev/txt) [arg2] [arg3]\n");
    572     }
    573594}
    574595
     
    687708        // - ESCAPE : the character (ESC) has been found
    688709        // - BRAKET : the wo characters (ESC,[) have been found
     710
    689711        unsigned int state = NORMAL;
    690 
    691712
    692713// @@@
     
    694715// @@@
    695716
     717char string[64];
    696718   
    697719        while (1)
     
    738760                                {
    739761                                }
    740                                 else if (c == 0x1B)     // ESC => start an escape sequence
     762                                else if (c == (char)0x1B)       // ESC => start an escape sequence
    741763                                {
    742764                                        state = ESCAPE;
     
    838860                }
    839861        }
    840 }
    841 
     862}  // end main()
     863
  • trunk/user/pgcd/pgcd.c

    r434 r436  
    99
    1010#include <stdlib.h>
     11#include <stdio.h>
    1112
    1213
     
    1415void main()
    1516{
    16     int opx;
    17     int opy;
     17    int                opx;
     18    int                opy;
     19    unsigned long long cycle;
    1820
    19     printf( "*** Starting interactive pgcd ***\n\n" );
     21    get_cycle( &cycle );
     22    printf( "\n[PGCD] starts / cycle %d\n", (unsigned int)cycle );
    2023
    2124    while (1)
  • trunk/user/sort/sort.c

    r435 r436  
    265265
    266266    get_cycle( &cycle );
    267     printf("\n[SORT] completes barrier init at cycle %d continue ?\n", (unsigned int)cycle );
    268     getchar();
     267    printf("\n[SORT] completes barrier init at cycle %d\n", (unsigned int)cycle );
    269268
    270269    // Array to sort initialization
     
    356355    {
    357356        printf("\n[SORT] failure at cycle %d\n", (unsigned int)cycle );
    358         exit( 0 );
     357        exit( 1 );
    359358    }
    360359
Note: See TracChangeset for help on using the changeset viewer.