Changeset 446


Ignore:
Timestamp:
Jun 19, 2018, 5:12:57 PM (3 years ago)
Author:
alain
Message:

miscelaneous...

Location:
trunk
Files:
17 edited

Legend:

Unmodified
Added
Removed
  • trunk/hal/tsar_mips32/drivers/soclib_tty.c

    r440 r446  
    124124
    125125#if DEBUG_HAL_TXT_RX
    126 uint32_t cycle = (uint32_t)hal_get_cycles();
    127 if( (DEBUG_HAL_TXT_RX < cycle) && (type == TXT_READ) )
     126uint32_t rx_cycle = (uint32_t)hal_get_cycles();
     127if( (DEBUG_HAL_TXT_RX < rx_cycle) && (type == TXT_READ) )
    128128printk("\n[DBG] %s : thread %x enter for RX / cycle %d\n",
    129 __FUNCTION__ , CURRENT_THREAD , cycle );
     129__FUNCTION__ , CURRENT_THREAD , rx_cycle );
    130130#endif
    131131
    132132#if DEBUG_HAL_TXT_TX
    133 uint32_t cycle = (uint32_t)hal_get_cycles();
    134 if( (DEBUG_HAL_TXT_TX < cycle) && (type == TXT_WRITE) )
     133uint32_t tx_cycle = (uint32_t)hal_get_cycles();
     134if( (DEBUG_HAL_TXT_TX < tx_cycle) && (type == TXT_WRITE) )
    135135printk("\n[DBG] %s : thread %x enter for TX / cycle %d\n",
    136 __FUNCTION__ , CURRENT_THREAD , cycle );
     136__FUNCTION__ , CURRENT_THREAD , tx_cycle );
    137137#endif
    138138
     
    224224   
    225225                // deschedule
    226                 sched_yield( "TTY_TX_FIFO_RX empty" );
     226                sched_yield( "TTY_RX_FIFO empty" );
    227227            }
    228228        }  // end while
     
    237237
    238238#if DEBUG_HAL_TXT_RX
    239 cycle = (uint32_t)hal_get_cycles();
    240 if( (DEBUG_HAL_TXT_RX < cycle) && (type == TXT_READ) )
     239rx_cycle = (uint32_t)hal_get_cycles();
     240if( (DEBUG_HAL_TXT_RX < rx_cycle) && (type == TXT_READ) )
    241241printk("\n[DBG] %s : thread %x exit after RX / cycle %d\n",
    242 __FUNCTION__ , CURRENT_THREAD , cycle );
     242__FUNCTION__ , CURRENT_THREAD , rx_cycle );
    243243#endif
    244244
    245245#if DEBUG_HAL_TXT_TX
    246 cycle = (uint32_t)hal_get_cycles();
    247 if( (DEBUG_HAL_TXT_TX < cycle) && (type == TXT_WRITE) )
     246tx_cycle = (uint32_t)hal_get_cycles();
     247if( (DEBUG_HAL_TXT_TX < tx_cycle) && (type == TXT_WRITE) )
    248248printk("\n[DBG] %s : thread %x exit after TX / cycle %d\n",
    249 __FUNCTION__ , CURRENT_THREAD , cycle );
     249__FUNCTION__ , CURRENT_THREAD , tx_cycle );
    250250#endif
    251251
     
    263263void __attribute__ ((noinline)) soclib_tty_isr( chdev_t * chdev )
    264264{
    265     thread_t   * server;       // pointer on TXT chdev server thread
    266     lid_t        server_lid;   // local index of core running the server thread
    267     uint32_t     channel;      // TXT chdev channel
    268     bool_t       is_rx;        // TXT chdev direction
    269     char         byte;         // byte value
    270     xptr_t       owner_xp;     // extended pointer on foreground process in owner cluster
    271     cxy_t        owner_cxy;   
    272     process_t  * owner_ptr;
    273     pid_t        owner_pid;
    274     tty_fifo_t * fifo;         // pointer on TTY_TX or TTY_RX FIFO
    275     cxy_t        tty_cxy;      // soclib_tty cluster
    276     uint32_t *   tty_ptr;      // soclib_tty segment base address
    277     uint32_t   * base;         // soclib_tty channel base address
    278     xptr_t       status_xp;    // extended pointer on TTY_STATUS register
    279     xptr_t       write_xp;     // extended pointer on TTY_WRITE register
    280     xptr_t       read_xp;      // extended pointer on TTY_READ register
     265    thread_t   * server;            // pointer on TXT chdev server thread
     266    lid_t        server_lid;        // local index of core running the server thread
     267    uint32_t     channel;           // TXT chdev channel
     268    bool_t       is_rx;             // TXT chdev direction
     269    char         byte;              // byte value
     270    xptr_t       owner_xp;          // extended pointer on TXT owner process
     271    cxy_t        owner_cxy;         // TXT owner process cluster
     272    process_t  * owner_ptr;         // local pointer on TXT owner process
     273    pid_t        owner_pid;         // TXT owner process identifier
     274    tty_fifo_t * fifo;              // pointer on TTY_TX or TTY_RX FIFO
     275    cxy_t        tty_cxy;           // soclib_tty cluster
     276    uint32_t   * tty_ptr;           // soclib_tty segment base address
     277    uint32_t   * base;              // soclib_tty channel base address
     278    xptr_t       status_xp;         // extended pointer on TTY_STATUS register
     279    xptr_t       write_xp;          // extended pointer on TTY_WRITE register
     280    xptr_t       read_xp;           // extended pointer on TTY_READ register
     281    xptr_t       parent_xp;         // extended pointer on parent process
     282    cxy_t        parent_cxy;        // parent process cluster
     283    process_t  * parent_ptr;        // local pointer on parent process
     284    xptr_t       children_lock_xp;  // extended pointer on children processes lock
     285    thread_t   * parent_main_ptr;   // extended pointer on parent process main thread
     286    xptr_t       parent_main_xp;    // local pointer on parent process main thread
    281287
    282288    // get TXT chdev channel, direction and server thread
     
    295301
    296302#if DEBUG_HAL_TXT_RX
    297 uint32_t cycle = (uint32_t)hal_get_cycles();
    298 if( (DEBUG_HAL_TXT_RX < cycle) && is_rx )
    299 printk("\n[DBG] %s : enter for RX / cycle %d\n", __FUNCTION__ , cycle );
     303uint32_t rx_cycle = (uint32_t)hal_get_cycles();
    300304#endif
    301305
    302306#if DEBUG_HAL_TXT_TX
    303 uint32_t cycle = (uint32_t)hal_get_cycles();
    304 if( (DEBUG_HAL_TXT_TX < cycle) && (is_rx == 0) )
    305 printk("\n[DBG] %s : enter for TX / cycle %d\n", __FUNCTION__ , cycle );
     307uint32_t tx_cycle = (uint32_t)hal_get_cycles();
    306308#endif
    307309
     
    329331            byte = (char)hal_remote_lb( read_xp );
    330332
    331             // filter special character ^Z
     333            // filter special character ^Z  => block TXT owner process
    332334            if( byte == 0x1A )
    333335            {
     336
     337#if DEBUG_HAL_TXT_RX
     338if( DEBUG_HAL_TXT_RX < rx_cycle )
     339printk("\n[DBG] %s : read ^Z character from TXT%d\n", __FUNCTION__, channel );
     340#endif
    334341                // get pointers on TXT owner process in owner cluster
    335342                owner_xp  = process_txt_get_owner( channel );
     
    339346                "TXT owner process not found\n" );
    340347
    341                 // get relevant infos on owner process
    342                 owner_cxy = GET_CXY( owner_xp );
    343                 owner_ptr = GET_PTR( owner_xp );
    344                 owner_pid = hal_remote_lw( XPTR( owner_cxy , &owner_ptr->pid ) );
    345 
    346                 // block owner process only if it is not INIT or KSH
    347                 if( process_get_ppid( owner_xp ) > 1 )
    348                 {
    349                     // send stop signal to owner process
    350                     process_sigaction( owner_pid , BLOCK_ALL_THREADS );
    351 
    352                     // atomically update owner process termination state
    353                     hal_remote_atomic_or( XPTR( owner_cxy , &owner_ptr->term_state ) ,
    354                                           PROCESS_TERM_STOP );
    355                     return;
    356                 }
    357             }
    358 
    359             // filter special character ^C
    360             if( byte == 0x03 )
    361             {
    362                 // get pointer on TXT owner process in owner cluster
    363                 owner_xp  = process_txt_get_owner( channel );
    364 
    365                 // check process exist
    366                 assert( (owner_xp != XPTR_NULL) , __FUNCTION__,
    367                 "TXT owner process not found\n" );
    368 
    369348                // get relevant infos on TXT owner process
    370349                owner_cxy = GET_CXY( owner_xp );
     
    372351                owner_pid = hal_remote_lw( XPTR( owner_cxy , &owner_ptr->pid ) );
    373352
    374                 // kill TXT owner process only if it is not INIT
     353                // block TXT owner process only if it is not the INIT process
    375354                if( owner_pid != 1 )
    376355                {
     356                    // get parent process descriptor pointers
     357                    parent_xp  = hal_remote_lwd( XPTR( owner_cxy , &owner_ptr->parent_xp ) );
     358                    parent_cxy = GET_CXY( parent_xp );
     359                    parent_ptr = GET_PTR( parent_xp );
     360
     361                    // get extended pointer on lock protecting children list in parent process
     362                    children_lock_xp = XPTR( parent_cxy , &parent_ptr->children_lock );
     363
     364                    // get pointers on the parent process main thread
     365                    parent_main_ptr = hal_remote_lpt(XPTR(parent_cxy,&parent_ptr->th_tbl[0]));
     366                    parent_main_xp  = XPTR( parent_cxy , parent_main_ptr );
     367
     368                    // transfer TXT ownership
     369                    process_txt_transfer_ownership( owner_xp );
     370
     371                    // block all threads in all clusters, but the main thread
     372                    process_sigaction( owner_pid , BLOCK_ALL_THREADS );
     373
     374                    // block the main thread
     375                    xptr_t main_xp = XPTR( owner_cxy , &owner_ptr->th_tbl[0] );
     376                    thread_block( main_xp , THREAD_BLOCKED_GLOBAL );
     377
     378                    // atomically update owner process termination state
     379                    hal_remote_atomic_or( XPTR( owner_cxy , &owner_ptr->term_state ) ,
     380                                          PROCESS_TERM_STOP );
     381
     382                    // take the children lock and unblock the parent process main thread
     383                    remote_spinlock_lock( children_lock_xp );
     384                    thread_unblock( parent_main_xp , THREAD_BLOCKED_WAIT );
     385                    remote_spinlock_unlock( children_lock_xp );
     386
     387                    return;
     388                }
     389            }
     390
     391            // filter special character ^C  => kill TXT owner process
     392            if( byte == 0x03 )
     393            {
     394
     395#if DEBUG_HAL_TXT_RX
     396if( DEBUG_HAL_TXT_RX < rx_cycle )
     397printk("\n[DBG] %s : read ^C character from TXT%d\n", __FUNCTION__, channel );
     398#endif
     399                // get pointer on TXT owner process in owner cluster
     400                owner_xp  = process_txt_get_owner( channel );
     401
     402                // check process exist
     403                assert( (owner_xp != XPTR_NULL) , __FUNCTION__,
     404                "TXT owner process not found\n" );
     405
     406                // get relevant infos on TXT owner process
     407                owner_cxy = GET_CXY( owner_xp );
     408                owner_ptr = GET_PTR( owner_xp );
     409                owner_pid = hal_remote_lw( XPTR( owner_cxy , &owner_ptr->pid ) );
     410
     411                // kill TXT owner process only if it is not the INIT process
     412                if( owner_pid != 1 )
     413                {
     414                    // get parent process descriptor pointers
     415                    parent_xp  = hal_remote_lwd( XPTR( owner_cxy , &owner_ptr->parent_xp ) );
     416                    parent_cxy = GET_CXY( parent_xp );
     417                    parent_ptr = GET_PTR( parent_xp );
     418
     419                    // get extended pointer on lock protecting children list in parent process
     420                    children_lock_xp = XPTR( parent_cxy , &parent_ptr->children_lock );
     421
     422                    // get pointers on the parent process main thread
     423                    parent_main_ptr = hal_remote_lpt(XPTR(parent_cxy,&parent_ptr->th_tbl[0]));
     424                    parent_main_xp  = XPTR( parent_cxy , parent_main_ptr );
     425
    377426                    // remove process from TXT list
    378427                    process_txt_detach( owner_xp );
     
    381430                    process_sigaction( owner_pid , DELETE_ALL_THREADS );
    382431               
    383                     // get pointer on target process main thread
     432                    // block main thread
    384433                    xptr_t main_xp = XPTR( owner_cxy , &owner_ptr->th_tbl[0] );
    385 
    386                     // block main thread
    387434                    thread_block( main_xp , THREAD_BLOCKED_GLOBAL );
    388435
     
    390437                    hal_remote_atomic_or( XPTR( owner_cxy , &owner_ptr->term_state ) ,
    391438                                          PROCESS_TERM_KILL );
     439
     440                    // take the children lock and unblock the parent process main thread
     441                    remote_spinlock_lock( children_lock_xp );
     442                    thread_unblock( parent_main_xp , THREAD_BLOCKED_WAIT );
     443                    remote_spinlock_unlock( children_lock_xp );
     444
    392445                    return;
    393446                }
     
    397450            if ( fifo->sts < TTY_FIFO_DEPTH )
    398451            {
     452
     453#if DEBUG_HAL_TXT_RX
     454if( DEBUG_HAL_TXT_RX < rx_cycle )
     455printk("\n[DBG] %s : read character %c from TXT%d\n", __FUNCTION__, byte, channel );
     456#endif
    399457                // store byte into FIFO
    400458                fifo->data[fifo->ptw] = (char)byte;
     
    430488        while( fifo->sts > 0 )
    431489        {
    432             // write one byte to TTY_WRITE register if empty / exit while if full
     490            // write one byte to TTY_WRITE register if empty / exit loop if full
    433491            if( (hal_remote_lw( status_xp ) & TTY_STATUS_TX_FULL) == 0 )
    434492            {
     
    436494                byte = fifo->data[fifo->ptr];
    437495
     496#if DEBUG_HAL_TXT_TX
     497if( DEBUG_HAL_TXT_TX < tx_cycle )
     498printk("\n[DBG] %s : write character %c to TXT%d\n", __FUNCTION__, byte, channel );
     499#endif
    438500                // update TX_FIFO state
    439501                fifo->ptr = (fifo->ptr + 1) % TTY_FIFO_DEPTH;
     
    453515        // send IPI to core running server thread
    454516        dev_pic_send_ipi( local_cxy , server_lid );
     517
    455518    }  // end TX
    456519
    457520    hal_fence();
    458 
    459 #if DEBUG_HAL_TXT_RX
    460 cycle = (uint32_t)hal_get_cycles();
    461 if( (DEBUG_HAL_TXT_RX < cycle) && is_rx )
    462 printk("\n[DBG] %s : exit after RX / cycle %d\n", __FUNCTION__, cycle );
    463 #endif
    464 
    465 #if DEBUG_HAL_TXT_TX
    466 cycle = (uint32_t)hal_get_cycles();
    467 if( (DEBUG_HAL_TXT_TX < cycle) && (is_rx == 0) )
    468 printk("\n[DBG] %s : exit after TX / cycle %d\n", __FUNCTION__, cycle );
    469 #endif
    470521
    471522#if (DEBUG_SYS_READ & 1)
  • trunk/kernel/kern/chdev.c

    r440 r446  
    198198    hal_disable_irq( &save_sr );
    199199
    200     // take the lock
     200    // take the lock protecting chdev waiting queue
    201201    remote_spinlock_lock( lock_xp );
    202202
     
    204204    thread_block( XPTR( local_cxy , CURRENT_THREAD ) , THREAD_BLOCKED_IO );
    205205
     206    // unblock server thread if required
    206207    if( hal_remote_lw( blocked_xp ) & THREAD_BLOCKED_IDLE )
    207208    thread_unblock( server_xp , THREAD_BLOCKED_IDLE );
  • trunk/kernel/kern/printk.c

    r445 r446  
    2828#include <remote_spinlock.h>
    2929#include <cluster.h>
     30#include <thread.h>
    3031#include <chdev.h>
    3132#include <printk.h>
     
    399400        chdev_t * txt0_ptr = GET_PTR( txt0_xp );
    400401
    401         // get extended pointer on remote TXT0 chdev lock
     402        // get extended pointer on remote TXT0 lock
    402403        xptr_t  lock_xp = XPTR( txt0_cxy , &txt0_ptr->wait_lock );
    403404
     
    406407
    407408        // call nolock_printk to print function_name
    408         nolock_printk("\n[PANIC] in %s : " , function_name );
     409        nolock_printk("\n[PANIC] on core[%x,%d] in %s : " ,
     410        local_cxy , CURRENT_THREAD->core->lid , function_name );
    409411
    410412        // call kernel_printf on TXT0, in busy waiting to print format
     
    417419
    418420        // suicide
    419         sys_exit( EXIT_FAILURE );
     421        while( 1 ) asm volatile ("nop");
    420422    }
    421423}
  • trunk/kernel/kern/process.c

    r445 r446  
    392392    cxy_t       parent_cxy;
    393393    xptr_t      children_lock_xp;
     394    xptr_t      children_nr_xp;
    394395
    395396    pid_t       pid = process->pid;
     
    421422        // get extended pointer on children_lock in parent process
    422423        children_lock_xp = XPTR( parent_cxy , &parent_ptr->children_lock );
     424        children_nr_xp   = XPTR( parent_cxy , &parent_ptr->children_nr );
    423425
    424426        // remove process from children_list
    425427        remote_spinlock_lock( children_lock_xp );
    426428        xlist_unlink( XPTR( local_cxy , &process->children_list ) );
     429            hal_remote_atomic_add( children_nr_xp , -1 );
    427430        remote_spinlock_unlock( children_lock_xp );
    428431    }
     
    12371240    thread_t       * new_thread;              // local pointer on new thread
    12381241    xptr_t           parent_xp;               // extended pointer on parent process
     1242    process_t      * parent_ptr;              // local pointer on parent process
     1243    cxy_t            parent_cxy;              // parent process cluster identifier
     1244    xptr_t           children_lock_xp;        // extended pointer on children lock in parent
     1245    xptr_t           children_root_xp;        // extended pointer on children root in parent
     1246    xptr_t           children_nr_xp;          // extended pointer on children number in parent
     1247    thread_t       * parent_main_ptr;         // local pointer on parent main thread
     1248    xptr_t           parent_main_xp;          // extended pointer on parent main thread
    12391249    pthread_attr_t   attr;                    // new thread attributes
    12401250    lid_t            lid;                     // selected core local index
    12411251        error_t          error;                   // value returned by called functions
    12421252   
    1243     // get old_thread / old_process / PID / parent_xp
     1253    // get old_thread, old_process & PID
    12441254    old_thread  = CURRENT_THREAD;
    12451255    old_process = old_thread->process;
    12461256    pid         = old_process->pid;
    1247     parent_xp   = old_process->parent_xp;
    1248    
     1257
    12491258        // get .elf pathname from exec_info
    1250         path        = exec_info->path;
     1259        path = exec_info->path;
    12511260
    12521261    // this function must be executed by a thread running in owner cluster
     
    12601269uint32_t cycle = (uint32_t)hal_get_cycles();
    12611270if( DEBUG_PROCESS_MAKE_EXEC < cycle )
    1262 printk("\n[DBG] %s : thread %x enters for process %x / %s / cycle %d\n",
    1263 __FUNCTION__, old_thread, pid, path, cycle );
    1264 #endif
     1271printk("\n[DBG] %s : thread %x in process %x enters / path %s / cycle %d\n",
     1272__FUNCTION__, old_thread->trdid, pid, path, cycle );
     1273#endif
     1274
     1275    // get parent process pointers
     1276    parent_xp   = old_process->parent_xp;
     1277    parent_cxy  = GET_CXY( parent_xp );
     1278    parent_ptr  = GET_PTR( parent_xp );
     1279   
     1280#if (DEBUG_PROCESS_MAKE_EXEC & 1)
     1281if( DEBUG_PROCESS_MAKE_EXEC < cycle )
     1282printk("\n[DBG] %s : thread %x in process %x get parent process %x in cluster %x\n",
     1283__FUNCTION__, old_thread->trdid, pid, parent_ptr, parent_cxy );
     1284#endif
     1285
     1286    // get extended pointers on parent children_root, children_lock and children_nr
     1287    children_root_xp = XPTR( parent_cxy , &parent_ptr->children_root );
     1288    children_lock_xp = XPTR( parent_cxy , &parent_ptr->children_lock );
     1289    children_nr_xp   = XPTR( parent_cxy , &parent_ptr->children_nr   );
     1290
     1291    // get pointers on the parent process main thread
     1292    parent_main_ptr = hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->th_tbl[0] ) );
     1293    parent_main_xp  = XPTR( parent_cxy , parent_main_ptr );
    12651294
    12661295     // allocate memory for new_process descriptor
     
    12981327cycle = (uint32_t)hal_get_cycles();
    12991328if( DEBUG_PROCESS_MAKE_EXEC < cycle )
    1300 printk("\n[DBG] %s : thread %x created new process %x / cycle %d \n",
    1301 __FUNCTION__ , old_thread , new_process , cycle );
     1329printk("\n[DBG] %s : thread %x in process %x created new process %x\n",
     1330__FUNCTION__ , old_thread->trdid, pid, new_process );
    13021331#endif
    13031332
     
    13581387#endif
    13591388
    1360     // get cluster and local pointer on parent process
    1361     process_t * parent_ptr = GET_PTR( parent_xp );
    1362     cxy_t       parent_cxy = GET_CXY( parent_xp );
    1363 
    1364     // get extended pointers on parent children_root, children_lock and children_nr
    1365     xptr_t root_xp = XPTR( parent_cxy , &parent_ptr->children_root );
    1366     xptr_t lock_xp = XPTR( parent_cxy , &parent_ptr->children_lock );
    1367     xptr_t nr_xp   = XPTR( parent_cxy , &parent_ptr->children_nr   );
    1368 
    13691389    // register new_process in parent children list
    1370     remote_spinlock_lock( lock_xp );
    1371         xlist_add_last( root_xp , XPTR( local_cxy , &new_process->children_list ) );
    1372         hal_remote_atomic_add( nr_xp , 1 );
    1373     remote_spinlock_unlock( lock_xp );
     1390    remote_spinlock_lock( children_lock_xp );
     1391        xlist_add_last( children_root_xp , XPTR( local_cxy , &new_process->children_list ) );
     1392        hal_remote_atomic_add( children_nr_xp , 1 );
     1393    remote_spinlock_unlock( children_lock_xp );
    13741394
    13751395    // activate new thread
     
    13791399    process_txt_detach( XPTR( local_cxy , old_process ) );
    13801400
    1381     // block this old_thread
     1401    // block old_thread
    13821402    thread_block( XPTR( local_cxy , old_thread ) , THREAD_BLOCKED_GLOBAL );
    13831403
    1384     // atomically update old_process descriptor term_state to ask
    1385     // the parent process (wait() function) to delete this old_thread
     1404    // atomically update old_process termination state
    13861405    hal_atomic_or( &old_process->term_state , PROCESS_TERM_EXIT );
     1406
     1407    // take the children lock and unblock the parent process main thread
     1408    remote_spinlock_lock( children_lock_xp );
     1409    thread_unblock( parent_main_xp , THREAD_BLOCKED_WAIT );
     1410    remote_spinlock_unlock( children_lock_xp );
    13871411
    13881412    hal_fence();
     
    16211645    if( txt_owner_xp == process_xp )
    16221646    {
    1623         nolock_printk("PID %X | PPID %X | STS %X | %s (FG) | %X | %d | %s\n",
     1647        nolock_printk("PID %X | PPID %X | TS %X | %s (FG) | %X | %d | %s\n",
    16241648        pid, ppid, state, txt_name, process_ptr, th_nr, elf_name );
    16251649    }
    16261650    else
    16271651    {
    1628         nolock_printk("PID %X | PPID %X | STS %X | %s (BG) | %X | %d | %s\n",
     1652        nolock_printk("PID %X | PPID %X | TS %X | %s (BG) | %X | %d | %s\n",
    16291653        pid, ppid, state, txt_name, process_ptr, th_nr, elf_name );
    16301654    }
     
    16761700    xptr_t      lock_xp;      // extended pointer on list lock in chdev
    16771701
    1678 #if DEBUG_PROCESS_TXT_ATTACH
     1702#if DEBUG_PROCESS_TXT
    16791703uint32_t cycle = (uint32_t)hal_get_cycles();
    1680 if( DEBUG_PROCESS_TXT_ATTACH < cycle )
     1704if( DEBUG_PROCESS_TXT < cycle )
    16811705printk("\n[DBG] %s : thread %x enter for process %x / txt_id = %d  / cycle %d\n",
    16821706__FUNCTION__, CURRENT_THREAD, process->pid, txt_id, cycle );
     
    17051729    remote_spinlock_unlock( lock_xp );
    17061730
    1707 #if DEBUG_PROCESS_TXT_ATTACH
    1708 cycle = (uint32_t)hal_get_cycles();
    1709 if( DEBUG_PROCESS_TXT_ATTACH < cycle )
     1731#if DEBUG_PROCESS_TXT
     1732cycle = (uint32_t)hal_get_cycles();
     1733if( DEBUG_PROCESS_TXT < cycle )
    17101734printk("\n[DBG] %s : thread %x exit for process %x / txt_id = %d / cycle %d\n",
    17111735__FUNCTION__, CURRENT_THREAD, process->pid, txt_id , cycle );
     
    17351759    "process descriptor not in owner cluster" );
    17361760
    1737 #if DEBUG_PROCESS_TXT_ATTACH
     1761#if DEBUG_PROCESS_TXT
    17381762uint32_t cycle = (uint32_t)hal_get_cycles();
    1739 if( DEBUG_PROCESS_TXT_ATTACH < cycle )
     1763if( DEBUG_PROCESS_TXT < cycle )
    17401764printk("\n[DBG] %s : thread %x enter for process %x / cycle %d\n",
    17411765__FUNCTION__, CURRENT_THREAD, process_pid, cycle );
     
    17611785    remote_spinlock_unlock( lock_xp );
    17621786
    1763 #if DEBUG_PROCESS_TXT_ATTACH
     1787#if DEBUG_PROCESS_TXT
    17641788cycle  = (uint32_t)hal_get_cycles();
    17651789uint32_t txt_id = hal_remote_lw( XPTR( chdev_cxy , &chdev_ptr->channel ) );
    1766 if( DEBUG_PROCESS_TXT_ATTACH < cycle )
     1790if( DEBUG_PROCESS_TXT < cycle )
    17671791printk("\n[DBG] %s : thread %x exit / process %x detached from TXT %d / cycle %d\n",
    17681792__FUNCTION__, CURRENT_THREAD, process_pid, txt_id, cycle );
     
    17931817    "process descriptor not in owner cluster\n" );
    17941818
    1795 #if DEBUG_PROCESS_TXT_ATTACH
     1819#if DEBUG_PROCESS_TXT
    17961820uint32_t cycle = (uint32_t)hal_get_cycles();
    1797 if( DEBUG_PROCESS_TXT_ATTACH < cycle )
     1821if( DEBUG_PROCESS_TXT < cycle )
    17981822printk("\n[DBG] %s : thread %x enter for process %x / cycle %d\n",
    17991823__FUNCTION__, CURRENT_THREAD, process_pid, cycle );
     
    18111835    hal_remote_swd( XPTR( txt_cxy , &txt_ptr->ext.txt.owner_xp ) , process_xp );
    18121836
    1813 #if DEBUG_PROCESS_TXT_ATTACH
    1814 cycle = (uint32_t)hal_get_cycles();
    1815 if( DEBUG_PROCESS_TXT_ATTACH < cycle )
     1837#if DEBUG_PROCESS_TXT
     1838cycle = (uint32_t)hal_get_cycles();
     1839if( DEBUG_PROCESS_TXT < cycle )
    18161840printk("\n[DBG] %s : thread %x exit for process %x / cycle %d\n",
    18171841__FUNCTION__, CURRENT_THREAD, process_pid, cycle );
     
    18501874    "process descriptor not in owner cluster\n" );
    18511875
    1852 #if DEBUG_PROCESS_TXT_ATTACH
     1876#if DEBUG_PROCESS_TXT
    18531877uint32_t cycle = (uint32_t)hal_get_cycles();
    1854 if( DEBUG_PROCESS_TXT_ATTACH < cycle )
     1878if( DEBUG_PROCESS_TXT < cycle )
    18551879printk("\n[DBG] %s : thread %x enter / process %x / cycle %d\n",
    18561880__FUNCTION__, CURRENT_THREAD, process_pid, cycle );
     
    18691893    txt_id   = hal_remote_lw ( XPTR( txt_cxy , &txt_ptr->channel ) );
    18701894
    1871 #if( DEBUG_PROCESS_TXT_ATTACH & 1 )
    1872 if( DEBUG_PROCESS_TXT_ATTACH < cycle )
     1895#if( DEBUG_PROCESS_TXT & 1 )
     1896if( DEBUG_PROCESS_TXT < cycle )
    18731897printk("\n[DBG] %s : file_ptr %x / txt_ptr %x / txt_id %d / owner_ptr = %x\n",
    18741898__FUNCTION__, GET_PTR(file_xp), txt_ptr, txt_id, GET_PTR(owner_xp) );
     
    18881912        {
    18891913
    1890 #if( DEBUG_PROCESS_TXT_ATTACH & 1 )
    1891 if( DEBUG_PROCESS_TXT_ATTACH < cycle )
     1914#if( DEBUG_PROCESS_TXT & 1 )
     1915if( DEBUG_PROCESS_TXT < cycle )
    18921916printk("\n[DBG] %s : process is not the KSH process => search the KSH\n", __FUNCTION__ );
    18931917#endif
     
    19071931                    hal_remote_swd( XPTR( txt_cxy , &txt_ptr->ext.txt.owner_xp ) , current_xp );
    19081932
    1909 #if DEBUG_PROCESS_TXT_ATTACH
    1910 cycle = (uint32_t)hal_get_cycles();
    1911 if( DEBUG_PROCESS_TXT_ATTACH < cycle )
     1933#if DEBUG_PROCESS_TXT
     1934cycle = (uint32_t)hal_get_cycles();
     1935if( DEBUG_PROCESS_TXT < cycle )
    19121936printk("\n[DBG] %s : thread %x exit / process %x to KSH process %x / cycle %d\n",
    19131937__FUNCTION__, CURRENT_THREAD, process_pid,
     
    19291953        {
    19301954
    1931 #if( DEBUG_PROCESS_TXT_ATTACH & 1 )
    1932 if( DEBUG_PROCESS_TXT_ATTACH < cycle )
     1955#if( DEBUG_PROCESS_TXT & 1 )
     1956if( DEBUG_PROCESS_TXT < cycle )
    19331957printk("\n[DBG] %s : process is the KSH process => search another\n", __FUNCTION__ );
    19341958#endif
     
    19491973                    hal_remote_swd( XPTR( txt_cxy , &txt_ptr->ext.txt.owner_xp ) , current_xp );
    19501974
    1951 #if DEBUG_PROCESS_TXT_ATTACH
    1952 cycle = (uint32_t)hal_get_cycles();
    1953 if( DEBUG_PROCESS_TXT_ATTACH < cycle )
     1975#if DEBUG_PROCESS_TXT
     1976cycle = (uint32_t)hal_get_cycles();
     1977if( DEBUG_PROCESS_TXT < cycle )
    19541978printk("\n[DBG] %s : thread %x exit / KSH process %x to process %x / cycle %d\n",
    19551979__FUNCTION__, CURRENT_THREAD, process_pid,
     
    19661990            hal_remote_swd( XPTR( txt_cxy , &txt_ptr->ext.txt.owner_xp ) , XPTR_NULL );
    19671991
    1968 #if DEBUG_PROCESS_TXT_ATTACH
    1969 cycle = (uint32_t)hal_get_cycles();
    1970 if( DEBUG_PROCESS_TXT_ATTACH < cycle )
     1992#if DEBUG_PROCESS_TXT
     1993cycle = (uint32_t)hal_get_cycles();
     1994if( DEBUG_PROCESS_TXT < cycle )
    19711995printk("\n[DBG] %s : thread %x exit / KSH process %x to nobody / cycle %d\n",
    19721996__FUNCTION__, CURRENT_THREAD, process_pid, cycle );
     
    19782002    {
    19792003
    1980 #if DEBUG_PROCESS_TXT_ATTACH
    1981 cycle = (uint32_t)hal_get_cycles();
    1982 if( DEBUG_PROCESS_TXT_ATTACH < cycle )
     2004#if DEBUG_PROCESS_TXT
     2005cycle = (uint32_t)hal_get_cycles();
     2006if( DEBUG_PROCESS_TXT < cycle )
    19832007printk("\n[DBG] %s : thread %x exit / process %x is not TXT owner / cycle %d\n",
    19842008__FUNCTION__, CURRENT_THREAD, process_pid, cycle );
  • trunk/kernel/kern/process.h

    r445 r446  
    405405                            struct thread_s ** child_thread_ptr );
    406406
     407
    407408/********************   File Management Operations   ****************************************/
    408409
     
    535536/*********************************************************************************************
    536537 * This function detach a process, identified by the <process_xp> argument,
    537  * from the list of process attached to a given TXT terminal. It transfer the TXT ownership,
    538  * if the detached process is the TXT owner.
    539  * The target process descriptor must be in the owner cluster, but the calling thread can
    540  * be running in any cluster.
     538 * from the list of process attached to a given TXT terminal. It transfer the TXT ownership
     539 * to another process, if the detached process is the TXT owner.
     540 * The process descriptor identified by the <process_xp> argument must be in the owner
     541 * cluster, but the calling thread can be running in any cluster.
    541542 *********************************************************************************************
    542543 * @ process_xp  : extended pointer on process descriptor.
  • trunk/kernel/kern/thread.c

    r443 r446  
    4242#include <ppm.h>
    4343#include <thread.h>
     44#include <rpc.h>
    4445
    4546//////////////////////////////////////////////////////////////////////////////////////
     
    799800uint32_t cycle = (uint32_t)hal_get_cycles();
    800801if( DEBUG_THREAD_BLOCK < cycle )
    801 printk("\n[DBG] %s : thread %x blocked thread %x / cause %x / cycle %d\n",
    802 __FUNCTION__ , CURRENT_THREAD , ptr , cause , cycle );
     802printk("\n[@@@] %s : thread %x  in cxy %x blocked thread %x in cxy %x / cause %x / cycle %d\n",
     803__FUNCTION__ , CURRENT_THREAD , local_cxy , ptr , cxy , cause , cycle );
    803804#endif
    804805
    805806#if (DEBUG_THREAD_BLOCK & 1)
    806807if( DEBUG_THREAD_BLOCK < cycle )
    807 sched_display( ptr->core->lid );
     808{
     809    if( cxy == local_cxy)
     810    {
     811        sched_display( ptr->core->lid );
     812    }
     813    else
     814    {
     815        core_t * core = hal_remote_lpt( XPTR( cxy , &ptr->core ) );
     816        lid_t    lid  = hal_remote_lw ( XPTR( cxy , &core->lid ) );
     817        rpc_sched_display_client( cxy , lid );
     818    }
     819}
    808820#endif
    809821
     
    825837uint32_t cycle = (uint32_t)hal_get_cycles();
    826838if( DEBUG_THREAD_BLOCK < cycle )
    827 printk("\n[DBG] %s : thread %x unblocked thread %x / cause %x / cycle %d\n",
    828 __FUNCTION__ , CURRENT_THREAD , ptr , cause , cycle );
     839printk("\n[@@@] %s : thread %x  in cxy %x unblocked thread %x in cxy %x / cause %x / cycle %d\n",
     840__FUNCTION__ , CURRENT_THREAD , local_cxy , ptr , cxy , cause , cycle );
    829841#endif
    830842
    831843#if (DEBUG_THREAD_BLOCK & 1)
    832844if( DEBUG_THREAD_BLOCK < cycle )
    833 sched_display( ptr->core->lid );
     845{
     846    if( cxy == local_cxy)
     847    {
     848        sched_display( ptr->core->lid );
     849    }
     850    else
     851    {
     852        core_t * core = hal_remote_lpt( XPTR( cxy , &ptr->core ) );
     853        lid_t    lid  = hal_remote_lw ( XPTR( cxy , &core->lid ) );
     854        rpc_sched_display_client( cxy , lid );
     855    }
     856}
    834857#endif
    835858
     
    838861
    839862}  // end thread_unblock()
    840 
    841 /*
    842 
    843 ////////////////////////////////////
    844 void thread_kill( xptr_t  target_xp,
    845                   bool_t  is_exit,
    846                   bool_t  is_forced )
    847 {
    848     reg_t       save_sr;                // for critical section
    849     bool_t      attached;               // target thread in attached mode
    850     bool_t      join_done;              // joining thread arrived first
    851     xptr_t      killer_xp;              // extended pointer on killer thread (this)
    852     thread_t  * killer_ptr;             // pointer on killer thread (this)
    853     cxy_t       target_cxy;             // target thread cluster     
    854     thread_t  * target_ptr;             // pointer on target thread
    855     xptr_t      joining_xp;             // extended pointer on joining thread
    856     thread_t  * joining_ptr;            // pointer on joining thread
    857     cxy_t       joining_cxy;            // joining thread cluster
    858     pid_t       target_pid;             // target process PID
    859     cxy_t       owner_cxy;              // target process owner cluster
    860     trdid_t     target_trdid;           // target thread identifier
    861     ltid_t      target_ltid;            // target thread local index
    862     xptr_t      process_state_xp;       // extended pointer on <term_state> in process
    863 
    864     xptr_t      target_flags_xp;        // extended pointer on target thread <flags>
    865     xptr_t      target_join_lock_xp;    // extended pointer on target thread <join_lock>
    866     xptr_t      target_join_xp_xp;      // extended pointer on target thread <join_xp>
    867     xptr_t      target_process_xp;      // extended pointer on target thread <process>
    868 
    869     process_t * target_process;         // pointer on target thread process
    870 
    871     // get target thread pointer and cluster
    872     target_cxy = GET_CXY( target_xp );
    873     target_ptr = GET_PTR( target_xp );
    874 
    875     // get killer thread pointers
    876     killer_ptr = CURRENT_THREAD;
    877     killer_xp  = XPTR( local_cxy , killer_ptr );
    878 
    879 #if DEBUG_THREAD_DELETE
    880 uint32_t cycle  = (uint32_t)hal_get_cycles;
    881 if( DEBUG_THREAD_DELETE < cycle )
    882 printk("\n[DBG] %s : thread %x enter for target thread %x / cycle %d\n",
    883 __FUNCTION__, killer_ptr, target_ptr, cycle );
    884 #endif
    885 
    886     // block the target thread
    887     thread_block( target_xp , THREAD_BLOCKED_GLOBAL );
    888 
    889     // get target thread attached mode
    890     target_flags_xp = XPTR( target_cxy , &target_ptr->flags );
    891     attached = ((hal_remote_lw( target_flags_xp ) & THREAD_FLAG_DETACHED) == 0);
    892 
    893     // synchronize with the joining thread
    894     // if the target thread is attached && not forced
    895 
    896     if( attached  && (is_forced == false) )
    897     {
    898         // build extended pointers on target thread join fields
    899         target_join_lock_xp  = XPTR( target_cxy , &target_ptr->join_lock );
    900         target_join_xp_xp    = XPTR( target_cxy , &target_ptr->join_xp );
    901 
    902         // enter critical section
    903         hal_disable_irq( &save_sr );
    904 
    905         // take the join_lock in target thread descriptor
    906         remote_spinlock_lock( target_join_lock_xp );
    907 
    908         // get join_done from target thread descriptor
    909         join_done = ((hal_remote_lw( target_flags_xp ) & THREAD_FLAG_JOIN_DONE) != 0);
    910    
    911         if( join_done )     // joining thread arrived first
    912         {
    913             // get extended pointer on joining thread
    914             joining_xp  = (xptr_t)hal_remote_lwd( target_join_xp_xp );
    915             joining_ptr = GET_PTR( joining_xp );
    916             joining_cxy = GET_CXY( joining_xp );
    917            
    918             // reset the join_done flag in target thread
    919             hal_remote_atomic_and( target_flags_xp , ~THREAD_FLAG_JOIN_DONE );
    920 
    921             // unblock the joining thread
    922             thread_unblock( joining_xp , THREAD_BLOCKED_JOIN );
    923 
    924             // release the join_lock in target thread descriptor
    925             remote_spinlock_unlock( target_join_lock_xp );
    926 
    927             // restore IRQs
    928             hal_restore_irq( save_sr );
    929         }
    930         else                // this thread arrived first
    931         {
    932             // set the kill_done flag in target thread
    933             hal_remote_atomic_or( target_flags_xp , THREAD_FLAG_KILL_DONE );
    934 
    935             // block this thread on BLOCKED_JOIN
    936             thread_block( killer_xp , THREAD_BLOCKED_JOIN );
    937 
    938             // set extended pointer on killer thread in target thread
    939             hal_remote_swd( target_join_xp_xp , killer_xp );
    940 
    941             // release the join_lock in target thread descriptor
    942             remote_spinlock_unlock( target_join_lock_xp );
    943 
    944             // deschedule
    945             sched_yield( "killer thread wait joining thread" );
    946 
    947             // restore IRQs
    948             hal_restore_irq( save_sr );
    949         }
    950     }  // end if attached
    951 
    952     // - if the target thread is the main thread
    953     //   => synchronize with the parent process main thread
    954     // - if the target thread is not the main thread
    955     //   => simply mark the target thread for delete
    956 
    957     // get pointer on target thread process
    958     target_process_xp  = XPTR( target_cxy , &target_ptr->process );
    959     target_process     = (process_t *)hal_remote_lpt( target_process_xp );
    960 
    961         // get target process owner cluster
    962         target_pid = hal_remote_lw( XPTR( target_cxy , &target_process->pid ) );
    963     owner_cxy = CXY_FROM_PID( target_pid );
    964 
    965     // get target thread local index
    966     target_trdid = hal_remote_lw( XPTR( target_cxy , &target_ptr->trdid ) );
    967     target_ltid  = LTID_FROM_TRDID( target_trdid );
    968 
    969     if( (owner_cxy == target_cxy) && (target_ltid == 0) )     // main thread
    970     {
    971         // get extended pointer on term_state in target process owner cluster
    972         process_state_xp = XPTR( owner_cxy , &target_process->term_state );
    973 
    974         // set termination info in target process owner 
    975         if( is_exit ) hal_remote_atomic_or( process_state_xp , PROCESS_TERM_EXIT );
    976         else          hal_remote_atomic_or( process_state_xp , PROCESS_TERM_KILL );
    977 
    978 #if DEBUG_THREAD_DELETE
    979 cycle  = (uint32_t)hal_get_cycles;
    980 if( DEBUG_THREAD_DELETE < cycle )
    981 printk("\n[DBG] %s : thread %x exit for thread %x / main thread / cycle %d\n",
    982 __FUNCTION__, killer_ptr, target_ptr, cycle );
    983 #endif
    984 
    985     }
    986     else                                                      // main thread
    987     {
    988         // set the REQ_DELETE flag in target thread descriptor
    989         hal_remote_atomic_or( target_flags_xp , THREAD_FLAG_REQ_DELETE );
    990 
    991 #if DEBUG_THREAD_DELETE
    992 cycle  = (uint32_t)hal_get_cycles;
    993 if( DEBUG_THREAD_DELETE < cycle )
    994 printk("\n[DBG] %s : thread %x exit for thread %x / not the main thread / cycle %d\n",
    995 __FUNCTION__, killer_ptr, target_ptr, cycle );
    996 #endif
    997 
    998     }
    999 
    1000 }  // end thread_kill()
    1001 
    1002 */
    1003863
    1004864//////////////////////////////////////
     
    1131991void thread_idle_func()
    1132992{
     993
     994#if DEBUG_THREAD_IDLE
     995uint32_t cycle;
     996#endif
     997
    1133998    while( 1 )
    1134999    {
     
    11401005        {
    11411006
    1142 #if DEBUG_THREAD_IDLE
    1143 uint32_t cycle  = (uint32_t)hal_get_cycles;
    1144 thread_t * this = CURRENT_THREAD;
    1145 if( DEBUG_THREAD_IDLE < cycle )
    1146 printk("\n[DBG] %s : idle thread %x on core[%x,%d] goes to sleep / cycle %d\n",
    1147 __FUNCTION__, this, local_cxy, this->core->lid, cycle );
    1148 #endif
    1149 
    1150             hal_core_sleep();
    1151 
    1152 #if DEBUG_THREAD_IDLE
     1007#if (DEBUG_THREAD_IDLE & 1)
    11531008cycle  = (uint32_t)hal_get_cycles;
    11541009if( DEBUG_THREAD_IDLE < cycle )
    1155 printk("\n[DBG] %s : idle thread %x on core[%x,%d] wake up / cycle %d\n",
     1010printk("\n[DBG] %s : idle thread on core[%x,%d] goes to sleep / cycle %d\n",
     1011__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, cycle );
     1012#endif
     1013
     1014            hal_core_sleep();
     1015
     1016#if (DEBUG_THREAD_IDLE & 1)
     1017cycle  = (uint32_t)hal_get_cycles;
     1018if( DEBUG_THREAD_IDLE < cycle )
     1019printk("\n[DBG] %s : idle thread on core[%x,%d] wake up / cycle %d\n",
    11561020__FUNCTION__, this, local_cxy, this->core->lid, cycle );
    11571021#endif
    11581022
    11591023        }
     1024
     1025#if DEBUG_THREAD_IDLE
     1026sched_display( CURRENT_THREAD->core->lid );
     1027#endif     
    11601028
    11611029        // search a runable thread
  • trunk/kernel/kern/thread.h

    r443 r446  
    9191#define THREAD_BLOCKED_RPC       0x0200  /*! thread wait RPC completion               */
    9292#define THREAD_BLOCKED_ISR       0x0400  /*! thread DEV wait ISR                      */
    93 #define THREAD_BLOCKED_WAIT      0x0800  /*! thread parent wait child termination     */
     93#define THREAD_BLOCKED_WAIT      0x0800  /*! thread wait child process termination    */
    9494
    9595/***************************************************************************************
  • trunk/kernel/kernel_config.h

    r445 r446  
    3636////////////////////////////////////////////////////////////////////////////////////////////
    3737
    38 
    39 
    4038#define DEBUG_CHDEV_CMD_RX             0
    4139#define DEBUG_CHDEV_CMD_TX             0
     
    9795#define DEBUG_PROCESS_GET_LOCAL_COPY   0
    9896#define DEBUG_PROCESS_INIT_CREATE      0
    99 #define DEBUG_PROCESS_MAKE_EXEC        1
     97#define DEBUG_PROCESS_MAKE_EXEC        0
    10098#define DEBUG_PROCESS_MAKE_FORK        0
    10199#define DEBUG_PROCESS_REFERENCE_INIT   0
     
    118116#define DEBUG_RPC_VMM_GET_VSEG         0
    119117
    120 #define DEBUG_SCHED_HANDLE_SIGNALS     2
    121 #define DEBUG_SCHED_YIELD              2    // dynamically activated by the trace() syscall
     118#define DEBUG_SCHED_HANDLE_SIGNALS     1
     119#define DEBUG_SCHED_YIELD              1    // must be activated by the trace() syscall
    122120
    123121#define DEBUG_SYSCALLS_ERROR           2
     
    127125#define DEBUG_SYS_EXIT                 1
    128126#define DEBUG_SYS_FG                   0
    129 #define DEBUG_SYS_FORK                 0
     127#define DEBUG_SYS_FORK                 1
    130128#define DEBUG_SYS_GET_CONFIG           0
    131129#define DEBUG_SYS_ISATTY               0
    132 #define DEBUG_SYS_KILL                 2
     130#define DEBUG_SYS_KILL                 1
    133131#define DEBUG_SYS_MMAP                 0
    134 #define DEBUG_SYS_READ                 0
     132#define DEBUG_SYS_READ                 2
    135133#define DEBUG_SYS_THREAD_CANCEL        0
    136134#define DEBUG_SYS_THREAD_CREATE        0
     
    139137#define DEBUG_SYS_THREAD_SLEEP         0
    140138#define DEBUG_SYS_THREAD_WAKEUP        0
    141 #define DEBUG_SYS_THREAD_YIELD         2
     139#define DEBUG_SYS_THREAD_YIELD         0
    142140#define DEBUG_SYS_TRACE                0
    143141#define DEBUG_SYS_WAIT                 0
    144 #define DEBUG_SYS_WRITE                0
     142#define DEBUG_SYS_WRITE                2
    145143
    146144#define DEBUG_SPINLOCKS                0
     
    154152#define DEBUG_THREAD_KERNEL_CREATE     0
    155153#define DEBUG_THREAD_KILL              0
    156 #define DEBUG_THREAD_USER_CREATE       2
     154#define DEBUG_THREAD_USER_CREATE       0
    157155#define DEBUG_THREAD_USER_FORK         0
    158 #define DEBUG_THREAD_BLOCK             0
     156#define DEBUG_THREAD_BLOCK             15000001
    159157
    160158#define DEBUG_VFS_INODE_CREATE         0
  • trunk/kernel/syscalls/sys_exit.c

    r445 r446  
    3636int sys_exit( uint32_t status )
    3737{
    38     reg_t       save_sr;       // required to enable IRQs
     38    reg_t       save_sr;           // required to enable IRQs
     39
     40    xptr_t      owner_xp;          // extended pointer on owner process
     41    cxy_t       owner_cxy;         // owner process cluster
     42    process_t * owner_ptr;         // local pointer on owner process
     43    thread_t  * main_ptr;          // local pointer on process main thread
     44    xptr_t      parent_xp;         // extended pointer on parent process
     45    cxy_t       parent_cxy;        // parent process cluster
     46    process_t * parent_ptr;        // local pointer on parent process
     47    xptr_t      children_lock_xp;  // extended pointer on children locki
     48    thread_t  * parent_main_ptr;   // local pointer on parent main thread
     49    xptr_t      parent_main_xp;    // extended pointer on parent main thread
     50    uint32_t    term_state;        // termination status for owner process
    3951
    4052    thread_t  * this    = CURRENT_THREAD;
     
    5264
    5365    // get owner process descriptor pointers
    54     xptr_t      owner_xp  = process->owner_xp;
    55     cxy_t       owner_cxy = GET_CXY( owner_xp );
    56     process_t * owner_ptr = GET_PTR( owner_xp );
     66    owner_xp  = process->owner_xp;
     67    owner_cxy = GET_CXY( owner_xp );
     68    owner_ptr = GET_PTR( owner_xp );
    5769
    58     // get pointers on the process main thread
    59     thread_t * main    = hal_remote_lpt( XPTR( owner_cxy , &owner_ptr->th_tbl[0] ) );
    60 
    61     // enable IRQs
    62     hal_enable_irq( &save_sr );
    63 
    64     // mark for delete all process threads in all clusters,
    65     // but the main thread and this calling thread
    66     process_sigaction( pid , DELETE_ALL_THREADS );
    67 
    68     // disable IRQs
    69     hal_restore_irq( save_sr );
    70 
    71 #if( DEBUG_SYS_EXIT & 1)
    72 if( tm_start > DEBUG_SYS_EXIT )
    73 printk("\n[DBG] %s : thread %x deleted threads / process %x\n",
    74 __FUNCTION__ , this, pid );
     70#if (DEBUG_SYS_EXIT & 1)
     71if( DEBUG_SYS_EXIT < tm_start )
     72printk("\n[DBG] %s : thread %x get owner process %x in cluster %x\n",
     73__FUNCTION__ , this, owner_ptr, owner_cxy );
    7574#endif
    7675
    77     // mark for delete this calling thread when it is not the main
    78     if( (owner_cxy != local_cxy) || (main != this) )
    79     {
     76    // get pointer on the process main thread
     77    main_ptr  = hal_remote_lpt( XPTR( owner_cxy , &owner_ptr->th_tbl[0] ) );
    8078
    81 #if( DEBUG_SYS_EXIT & 1)
    82 if( tm_start > DEBUG_SYS_EXIT )
    83 printk("\n[DBG] %s : calling thread %x marked iself for delete / process %x\n",
    84 __FUNCTION__ , this, pid );
     79    // get parent process descriptor pointers
     80    parent_xp  = process->parent_xp;
     81    parent_cxy = GET_CXY( parent_xp );
     82    parent_ptr = GET_PTR( parent_xp );
     83
     84#if (DEBUG_SYS_EXIT & 1)
     85if( DEBUG_SYS_EXIT < tm_start )
     86printk("\n[DBG] %s : thread %x get parent process %x in cluster %x\n",
     87__FUNCTION__ , this, parent_ptr, parent_cxy );
    8588#endif
    86         thread_delete( XPTR( local_cxy , this ) , pid , true );
    87     }
     89
     90    // get extended pointer on lock protecting children list in parent process
     91    children_lock_xp = XPTR( parent_cxy , &parent_ptr->children_lock );
     92
     93    // get pointers on the parent process main thread
     94    parent_main_ptr = hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->th_tbl[0] ) );
     95    parent_main_xp  = XPTR( parent_cxy , parent_main_ptr );
    8896
    8997    // remove process from TXT list
     
    96104#endif
    97105
    98     // block the main thread
    99     thread_block( XPTR( owner_cxy , main ) , THREAD_BLOCKED_GLOBAL );
     106    // mark for delete all process threads in all clusters,
     107    // but the main thread and this calling thread
     108    hal_enable_irq( &save_sr );
     109    process_sigaction( pid , DELETE_ALL_THREADS );
     110    hal_restore_irq( save_sr );
     111
     112#if( DEBUG_SYS_EXIT & 1)
     113if( tm_start > DEBUG_SYS_EXIT )
     114printk("\n[DBG] %s : thread %x deleted threads for process %x\n",
     115__FUNCTION__ , this, pid );
     116#endif
     117
     118    // mark for delete this calling thread when it is not the main
     119    if( (owner_cxy != local_cxy) || (main_ptr != this) )
     120    {
     121
     122#if( DEBUG_SYS_EXIT & 1)
     123if( tm_start > DEBUG_SYS_EXIT )
     124printk("\n[DBG] %s : calling thread %x marked iself for delete in process %x\n",
     125__FUNCTION__ , this, pid );
     126#endif
     127        thread_delete( XPTR( local_cxy , this ) , pid , true );
     128    }
     129
     130    // block this main thread
     131    thread_block( XPTR( owner_cxy , main_ptr ) , THREAD_BLOCKED_GLOBAL );
    100132
    101133#if( DEBUG_SYS_EXIT & 1)
     
    107139    // atomically update owner process descriptor term_state to ask
    108140    // the parent process sys_wait() function to delete the main thread
    109     hal_remote_atomic_or( XPTR( owner_cxy , &process->term_state ) ,
    110                           PROCESS_TERM_EXIT | (status & 0xFF) );
     141    term_state = (status & 0xFF) | PROCESS_TERM_EXIT;
     142    hal_remote_atomic_or( XPTR( owner_cxy , &owner_ptr->term_state ) , term_state );
    111143
    112144#if( DEBUG_SYS_EXIT & 1)
    113145if( tm_start > DEBUG_SYS_EXIT )
    114 printk("\n[DBG] %s : thread %x set exit status in process %x term_state\n",
    115 __FUNCTION__ , this, pid );
     146printk("\n[DBG] %s : thread %x set exit status in process %x / term_state %x\n",
     147__FUNCTION__ , this, pid, term_state );
     148#endif
     149
     150    // take the children lock and unblock the parent process main thread
     151    remote_spinlock_lock( children_lock_xp );
     152    thread_unblock( parent_main_xp , THREAD_BLOCKED_WAIT );
     153    remote_spinlock_unlock( children_lock_xp );
     154
     155#if( DEBUG_SYS_EXIT & 1)
     156if( tm_start > DEBUG_SYS_EXIT )
     157printk("\n[DBG] %s : thread %x in cluster %x unblock parent main thread %x in cluster %x\n",
     158__FUNCTION__ , this, local_cxy, parent_main_ptr, parent_cxy );
    116159#endif
    117160
  • trunk/kernel/syscalls/sys_fg.c

    r443 r446  
    3333#include <rpc.h>
    3434
    35 //////////////////////////
    36 int sys_fg( pid_t    pid )
     35///////////////////////
     36int sys_fg( pid_t pid )
    3737{
    3838    xptr_t      process_xp;     // extended pointer on reference process descriptor
     
    8585    hal_remote_swd( XPTR( chdev_cxy , &chdev_ptr->ext.txt.owner_xp ) , process_xp );
    8686
     87    // reset PROCESS_TERM_WAIT and PROCESS_TERM_STOP flags in process term_state
     88    hal_remote_atomic_and( XPTR( process_cxy , &process_ptr->term_state ),
     89                                 ~(PROCESS_TERM_WAIT | PROCESS_TERM_STOP) );
     90 
    8791    hal_fence();
    8892
  • trunk/kernel/syscalls/sys_kill.c

    r440 r446  
    3737              uint32_t sig_id )
    3838{
    39     xptr_t      owner_xp;      // extended pointer on target process in owner cluster
    40     cxy_t       owner_cxy;     // target process in owner cluster
    41     process_t * owner_ptr;     // local pointer on target process in owner cluster
    42     uint32_t    retval;        // return value for the switch
     39    reg_t       save_sr;           // required to enable IRQs
     40    xptr_t      owner_xp;          // extended pointer on process in owner cluster
     41    cxy_t       owner_cxy;         // process owner cluster
     42    process_t * owner_ptr;         // local pointer on process in owner cluster
     43    uint32_t    retval;            // return value for the switch
     44    xptr_t      parent_xp;         // extended pointer on parent process
     45    cxy_t       parent_cxy;        // parent process cluster
     46    process_t * parent_ptr;        // local pointer on parent process
     47    xptr_t      children_lock_xp;  // extended pointer on children lock in parent
     48    thread_t  * parent_main_ptr;   // local pointer on parent main thread
     49    xptr_t      parent_main_xp;    // extended pointer on parent main thread
    4350
    4451    thread_t  * this    = CURRENT_THREAD;
     
    5966    owner_ptr = GET_PTR( owner_xp );
    6067   
     68#if (DEBUG_SYS_KILL & 1)
     69if( DEBUG_SYS_KILL < tm_start )
     70printk("\n[DBG] %s : thread %x found process %x in cluster %x\n",
     71__FUNCTION__ , this, owner_ptr, owner_cxy );
     72#endif
     73
    6174    // check process found
    6275    if( owner_xp == XPTR_NULL)
     
    92105    }
    93106
     107    // get parent process descriptor pointers
     108    parent_xp  = (xptr_t)hal_remote_lwd( XPTR( owner_cxy , &owner_ptr->parent_xp ) );
     109    parent_cxy = GET_CXY( parent_xp );
     110    parent_ptr = GET_PTR( parent_xp );
     111
     112#if (DEBUG_SYS_KILL & 1)
     113if( DEBUG_SYS_KILL < tm_start )
     114printk("\n[DBG] %s : thread %x get parent process %x in cluster %x\n",
     115__FUNCTION__ , this, parent_ptr, parent_cxy );
     116#endif
     117
     118    // get extended pointer on lock protecting children list in parent process
     119    children_lock_xp = XPTR( parent_cxy , &parent_ptr->children_lock );
     120
     121    // get pointers on the parent process main thread
     122    parent_main_ptr = hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->th_tbl[0] ) );
     123    parent_main_xp  = XPTR( parent_cxy , parent_main_ptr );
     124
    94125    // analyse signal type / supported values are : 0, SIGSTOP, SIGCONT, SIGKILL
    95126    switch( sig_id )
     
    108139            process_sigaction( pid , BLOCK_ALL_THREADS );
    109140
    110             // get pointer on target process main thread
     141            // block the main thread
    111142            xptr_t main_xp = XPTR( owner_cxy , &owner_ptr->th_tbl[0] );
    112 
    113             // block main thread
    114143            thread_block( main_xp , THREAD_BLOCKED_GLOBAL );
    115144
     
    117146            hal_remote_atomic_or( XPTR( owner_cxy , &owner_ptr->term_state ) ,
    118147                                  PROCESS_TERM_STOP );
     148
     149            // take the children lock and unblock the parent process main thread
     150            remote_spinlock_lock( children_lock_xp );
     151            thread_unblock( parent_main_xp , THREAD_BLOCKED_WAIT );
     152            remote_spinlock_unlock( children_lock_xp );
     153
    119154            retval = 0;
    120155            break;
     
    137172            process_txt_detach( owner_xp );
    138173
    139             // mark for delete all process threads in all clusters, but the main
     174            // mark for delete all threads in all clusters, but the main
     175            hal_enable_irq( &save_sr );
    140176            process_sigaction( pid , DELETE_ALL_THREADS );
    141 
    142             // get pointer on target process main thread
     177            hal_restore_irq( save_sr );
     178
     179            // block main thread
    143180            xptr_t main_xp = XPTR( owner_cxy , &owner_ptr->th_tbl[0] );
    144 
    145             // block main thread
    146181            thread_block( main_xp , THREAD_BLOCKED_GLOBAL );
    147182
     
    150185            hal_remote_atomic_or( XPTR( owner_cxy , &owner_ptr->term_state ) ,
    151186                                  PROCESS_TERM_KILL );
     187
     188            // take the children lock and unblock the parent process main thread
     189            remote_spinlock_lock( children_lock_xp );
     190            thread_unblock( parent_main_xp , THREAD_BLOCKED_WAIT );
     191            remote_spinlock_unlock( children_lock_xp );
     192
    152193            retval = 0;
    153194            break;
  • trunk/kernel/syscalls/sys_read.c

    r443 r446  
    6363    reg_t        save_sr;     // required to enable IRQs during syscall
    6464
    65         thread_t  *  this    = CURRENT_THREAD;
    66         process_t *  process = this->process;
     65        thread_t  *  this             = CURRENT_THREAD;
     66        process_t *  process          = this->process;
     67    xptr_t       process_owner_xp = process->owner_xp;
    6768 
    6869#if DEBUG_SYS_READ
     
    165166                                count );
    166167    }
    167     else if( type == INODE_TYPE_DEV )  // check ownership & read from from device
     168    else if( type == INODE_TYPE_DEV )  // check ownership & read from device
    168169    {
    169170        // get cluster and pointers on TXT_RX chdev
     
    172173        chdev_t * chdev_ptr = GET_PTR( chdev_xp );
    173174
    174         volatile xptr_t    owner_xp;   
     175        volatile xptr_t    txt_owner_xp;   
     176        uint32_t           iter = 0;
    175177
    176178        while( 1 )
    177179        {
    178             // extended pointer on owner process
    179             owner_xp  = hal_remote_lwd( XPTR( chdev_cxy , &chdev_ptr->ext.txt.owner_xp ) );
     180            // extended pointer on TXT owner process
     181            txt_owner_xp  = hal_remote_lwd( XPTR( chdev_cxy , &chdev_ptr->ext.txt.owner_xp ) );
    180182
    181183            // check TXT_RX ownership
    182             if ( XPTR( local_cxy , process ) != owner_xp )
     184            if ( process_owner_xp != txt_owner_xp )
    183185            {
     186                if( (iter & 0xFFF) == 0 )
     187                printk("\n[WARNING] in %s : thread %x in process %x wait TXT_RX / cycle %d\n",
     188                __FUNCTION__, this->trdid, process->pid, (uint32_t)hal_get_cycles() );
     189
    184190                // deschedule without blocking
    185                 sched_yield( "wait TXT ownership" );
     191                sched_yield( "wait TXT_RX ownership" );
     192
     193                iter++;
    186194            }
    187195            else
     
    191199        }
    192200
     201printk("\n###### in %s : thread %x in process %x got TXT_RX ownership\n",
     202__FUNCTION__, this->trdid, process->pid );
     203               
    193204        // move count bytes from device
    194205        nbytes = devfs_user_move( true,             // from device to buffer
  • trunk/kernel/syscalls/sys_wait.c

    r443 r446  
    4141    cxy_t       child_cxy;
    4242    pid_t       child_pid;
    43     int         child_state;
     43    uint32_t    child_state;
    4444    thread_t  * child_thread;
    4545    reg_t       save_sr;
     
    5050
    5151#if DEBUG_SYS_WAIT
    52 uint64_t    tm_start;
    53 uint64_t    tm_end;
    54 tm_start = hal_get_cycles();
    55 if( DEBUG_SYS_WAIT < tm_start )
    56 printk("\n[DBG] %s : thread %x enter / process %x / cycle %d\n",
    57 __FUNCTION__, this, process->pid, (uint32_t)tm_start );
     52uint64_t    cycle = hal_get_cycles();
     53if( DEBUG_SYS_WAIT < cycle )
     54printk("\n[DBG] %s : thread %x in process %x enter / cycle %d\n",
     55__FUNCTION__, this, process->pid, (uint32_t)cycle );
    5856#endif
    5957
     
    8381    {
    8482
    85 #if DEBUG_SYSCALL_ERROR
     83#if DEBUG_SYSCALLS_ERROR
    8684printk("\n[ERROR] in %s : calling thread %x is not thread 0 in owner cluster %x\n",
    8785__FUNCTION__ , trdid , owner_cxy );
     
    112110            child_cxy = GET_CXY( child_xp );
    113111
    114             // get term_state from child owner process
    115             child_state = (int)hal_remote_lw ( XPTR(child_cxy,&child_ptr->term_state));
     112            // get PID, term_state, and main thread from child process
     113            child_pid    = hal_remote_lw (XPTR( child_cxy , &child_ptr->pid ));
     114            child_state  = hal_remote_lw ( XPTR(child_cxy , &child_ptr->term_state ) );
     115            child_thread = hal_remote_lpt(XPTR( child_cxy , &child_ptr->th_tbl[0] ));
    116116
     117#if (DEBUG_SYS_WAIT &1)
     118cycle = hal_get_cycles();
     119if( DEBUG_SYS_WAIT < cycle )
     120printk("\n[DBG] %s : thread %x in process %x check child %x / state %x\n",
     121__FUNCTION__, this, process->pid, child_pid, child_state );
     122#endif
    117123            // test if this child process is terminated,
    118124            // but termination not yet reported to parent process
     
    122128                 ((child_state & PROCESS_TERM_WAIT) == 0) )
    123129            {
    124                 // get pointer on child main thread and PID from child owner process
    125                 child_pid    = (pid_t)     hal_remote_lw (XPTR( child_cxy , &child_ptr->pid ));
    126                 child_thread = (thread_t *)hal_remote_lpt(XPTR( child_cxy ,
    127                                                                 &child_ptr->th_tbl[0] ));
    128 
    129                 // set the PROCESS_FLAG_WAIT in owner child process descriptor
     130                // set the PROCESS_FLAG_WAIT in child process descriptor
    130131                hal_remote_atomic_or( XPTR( child_cxy , &child_ptr->term_state ),
    131132                                      PROCESS_TERM_WAIT );
    132133
    133                 // set the THREAD_FLAG_REQ_DELETE in child main thread
     134                // set the THREAD_FLAG_REQ_DELETE in main thread if kill or exit
     135                if((child_state & PROCESS_TERM_EXIT) || (child_state & PROCESS_TERM_KILL))
    134136                hal_remote_atomic_or( XPTR( child_cxy , &child_thread->flags ) ,
    135137                                            THREAD_FLAG_REQ_DELETE );
     
    139141
    140142#if DEBUG_SYS_WAIT
    141 tm_end = hal_get_cycles();
    142 if( DEBUG_SYS_WAIT < tm_end )
    143 printk("\n[DBG] %s : thread %x exit / parent %x / child %x / cycle %d\n",
    144 __FUNCTION__, this, process->pid, child_pid, (uint32_t)tm_end );
     143cycle = hal_get_cycles();
     144if( DEBUG_SYS_WAIT < cycle )
     145{
     146    if     ( child_state & PROCESS_TERM_EXIT )
     147        printk("\n[DBG] %s : thread %x in process %x exit / child %x exit / cycle %d\n",
     148        __FUNCTION__, this, process->pid, child_pid, (uint32_t)cycle );
     149    if( child_state & PROCESS_TERM_KILL )
     150        printk("\n[DBG] %s : thread %x in process %x exit / child %x killed / cycle %d\n",
     151        __FUNCTION__, this, process->pid, child_pid, (uint32_t)cycle );
     152    if( child_state & PROCESS_TERM_STOP )
     153        printk("\n[DBG] %s : thread %x in process %x exit / child %x stopped / cycle %d\n",
     154        __FUNCTION__, this, process->pid, child_pid, (uint32_t)cycle );
     155}
    145156#endif
    146157                 // return child termination state  to parent process
     
    150161        }  // end loop on children
    151162       
     163        // block on WAIT condition
     164        thread_block( XPTR( local_cxy , this ) , THREAD_BLOCKED_WAIT );
     165
    152166        // release lock protecting children list
    153167        remote_spinlock_unlock( children_lock_xp );
    154168
    155         // deschedule without blocking
    156         sched_yield( "parent wait children termination" );
     169#if (DEBUG_SYS_WAIT & 1)
     170cycle = hal_get_cycles();
     171if( DEBUG_SYS_WAIT < cycle )
     172printk("\n[DBG] %s : thread %x in process %x block & deschedule / cycle %d\n",
     173__FUNCTION__, this, process->pid, (uint32_t)cycle );
     174#endif
     175
     176        // deschedule
     177        sched_yield( "parent process wait children processes termination" );
     178
     179#if (DEBUG_SYS_WAIT & 1)
     180cycle = hal_get_cycles();
     181if( DEBUG_SYS_WAIT < cycle )
     182printk("\n[DBG] %s : thread %x in process %x unblock & resume / cycle %d\n",
     183__FUNCTION__, this, process->pid, (uint32_t)cycle );
     184#endif
    157185
    158186    }  // end while
  • trunk/params-hard.mk

    r445 r446  
    22
    33ARCH      = /users/alain/soc/tsar-trunk-svn-2013/platforms/tsar_generic_iob
    4 X_SIZE    = 2
     4X_SIZE    = 1
    55Y_SIZE    = 2
    66NB_PROCS  = 1
    7 NB_TTYS   = 4
     7NB_TTYS   = 2
    88FBF_WIDTH = 128
    99IOC_TYPE  = IOC_BDV
  • trunk/user/idbg/idbg.c

    r445 r446  
    2020    printf( "\n[IDBG] starts at cycle %d\n", (unsigned int)cycle );
    2121
    22     while (1)
    23     {
    24 
    25         ///////
    26         idbg();
    27         ///////
    28     }
     22    ///////
     23    idbg();
     24    ///////
    2925
    3026    get_cycle( &cycle );
  • trunk/user/ksh/ksh.c

    r445 r446  
    44// Author :  Alain Greiner
    55///////////////////////////////////////////////////////////////////////////////
    6 // This single thread application implement a simple shell for ALMOS-MKH.
     6// This applications implement a minimal shell for ALMOS-MKH.
     7// This user process contains two POSIX threads:
     8// - the "main" thread contains the infinite loop implementing
     9//   the children processes termination monitoring (children processes
     10//   are created by the <load> command and attached to the KSH TXT terminal).
     11// - the "interactive" thread contains the infinite loop implementing
     12//   the command interpreter attached to the TXT terminal.
    713///////////////////////////////////////////////////////////////////////////////
    814
     
    5359unsigned int    ptr;                      // read pointer in log_entries[]
    5460
     61pthread_attr_t  attr;                     // monitor thread attributes
     62
    5563////////////////////////////////////////////////////////////////////////////////
    5664//         Shell  Commands
     
    100108        }
    101109
    102         // set terminating '0' XXX
     110        // set terminating '0'
    103111        buf[size-1] = 0;
    104112
     
    449457    else                        // it is the parent KSH : ret_fork is the new process PID
    450458    {
    451         // give back terminal ownership to KSH if new process created in background /
    452         // wait new process completion before returning to command interpreter otherwise
     459        // give back terminal ownership to KSH
     460        // when new process created in background
    453461        if( background )   fg( ksh_pid );
    454         else               wait( &status );
    455462
    456463        // return to command interpreter
     
    715722                }
    716723        }
    717 }
    718 
    719 ///////////////////////////////////
    720 int main( int argc , char *argv[] )
     724}  // end parse()
     725
     726/////////////////////////
     727static void interactive()
    721728{
    722729        char         c;                                           // read character
    723730        char         buf[CMD_MAX_SIZE];           // buffer for one command
    724         unsigned int count = 0;                           // pointer in buf
     731        unsigned int count;                               // pointer in buf
    725732        unsigned int i;                                           // index for loops
    726733
     
    732739        };
    733740
    734     // log buffer initialisation
    735         memset( &log_entries , 0, sizeof(log_entries));
    736         ptw   = 0;
    737         ptr   = 0;
    738 
    739         printf( "\n\n~~~ shell ~~~\n\n" );
    740 
    741         // command buffer initialisation
     741        // initialize command buffer
    742742        memset( buf, 0x20 , sizeof(buf) );
    743743        count = 0;
     
    760760
    761761// @@@
    762 // parse("load /bin/user/hello.elf");
     762parse("load /bin/user/idbg.elf");
    763763// @@@
    764764
     
    814814                                        state = ESCAPE;
    815815                                }
    816                                 else if (c == 0x03)     // ^C  => cancel current command
    817                                 {
    818                                         for (i = 0; i < count; i++) printf("\b \b");
    819                                         for (i = 0; i < sizeof(buf); i++) buf[i] = 0x20;
    820                                         count = 0;
    821                                 }
    822816                                else                                     // register character in command buffer
    823817                                {
     
    910904                }
    911905        }
     906}  // end interactive()
     907
     908///////////////////////////////////
     909int main( int argc , char *argv[] )
     910{
     911    unsigned int cxy;             // owner cluster identifier for this KSH process
     912    unsigned int lid;             // core identifier for this KSH main thread
     913    int          status;          // child process termination status
     914    int          pid;             // chils process identifier
     915    pthread_t    trdid;           // kernel allocated index for interactive thread
     916
     917    // initialize log buffer
     918        memset( &log_entries , 0, sizeof(log_entries));
     919        ptw   = 0;
     920        ptr   = 0;
     921
     922    get_core( &cxy , & lid );
     923        printf( "\n\n~~~ KSH on core[%x,%d] ~~~\n\n", cxy , lid );
     924
     925    // initialize interactive thread attributes
     926    attr.attributes = PT_ATTR_DETACH | PT_ATTR_CLUSTER_DEFINED;
     927    attr.cxy        = cxy;
     928
     929    // lauch the interactive thread
     930    pthread_create( &trdid,
     931                    &attr,
     932                    &interactive,   // entry function
     933                    NULL );
     934   
     935    // enter infinite loop monitoring children processes termination
     936    while( 1 )
     937    {
     938        pid = wait( &status );
     939
     940#if 0
     941        if     ( WIFEXITED  (status) ) printf("\n[KSH] process %x exited\n" , pid );
     942        else if( WIFSIGNALED(status) ) printf("\n[KSH] process %x killed\n" , pid );
     943        else if( WIFSTOPPED (status) ) printf("\n[KSH] process %x stopped\n", pid );
     944        else                           printf("\n[KSH] process %x strange\n", pid ); 
     945#endif
     946
     947    }
    912948}  // end main()
    913949
     950
  • trunk/user/pgcd/pgcd.c

    r445 r446  
    3333        if( (opx == 0) || (opy == 0) )
    3434        {
    35            printf("operands must be positive and larger than 0\n");
     35           printf("operands must be positive and larger than 0 => exit\n");
     36           exit( 0 );
    3637        }
    3738        else
Note: See TracChangeset for help on using the changeset viewer.