Ignore:
Timestamp:
Nov 10, 2018, 2:16:38 PM (3 years ago)
Author:
alain
Message:

Cosmetic: improve debug.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/kernel/kern/process.c

    r583 r593  
    123123uint32_t cycle = (uint32_t)hal_get_cycles();
    124124if( DEBUG_PROCESS_REFERENCE_INIT )
    125 printk("\n[DBG] %s : thread %x in process %x enter to initalialize process %x / cycle %d\n",
     125printk("\n[%s] thread %x in process %x enter to initalialize process %x / cycle %d\n",
    126126__FUNCTION__, CURRENT_THREAD->trdid, parent_pid , pid , cycle );
    127127#endif
     
    142142cycle = (uint32_t)hal_get_cycles();
    143143if( DEBUG_PROCESS_REFERENCE_INIT )
    144 printk("\n[DBG] %s : thread %x in process %x / vmm empty for process %x / cycle %d\n",
     144printk("\n[%s] thread %x in process %x / vmm empty for process %x / cycle %d\n",
    145145__FUNCTION__, CURRENT_THREAD->trdid, parent_pid , pid, cycle );
    146146#endif
     
    162162cycle = (uint32_t)hal_get_cycles();
    163163if( DEBUG_PROCESS_REFERENCE_INIT )
    164 printk("\n[DBG] %s : thread %x in process %x / process %x attached to TXT%d / cycle %d\n",
     164printk("\n[%s] thread %x in process %x / process %x attached to TXT%d / cycle %d\n",
    165165__FUNCTION__, CURRENT_THREAD->trdid, parent_pid, pid, txt_id, cycle );
    166166#endif
     
    183183cycle = (uint32_t)hal_get_cycles();
    184184if( DEBUG_PROCESS_REFERENCE_INIT )
    185 printk("\n[DBG] %s : thread %x in process %x / stdin open for process %x / cycle %d\n",
     185printk("\n[%s] thread %x in process %x / stdin open for process %x / cycle %d\n",
    186186__FUNCTION__, CURRENT_THREAD->trdid, parent_pid, pid, cycle );
    187187#endif
     
    201201cycle = (uint32_t)hal_get_cycles();
    202202if( DEBUG_PROCESS_REFERENCE_INIT )
    203 printk("\n[DBG] %s : thread %x in process %x / stdout open for process %x / cycle %d\n",
     203printk("\n[%s] thread %x in process %x / stdout open for process %x / cycle %d\n",
    204204__FUNCTION__, CURRENT_THREAD->trdid, parent_pid, pid, cycle );
    205205#endif
     
    219219cycle = (uint32_t)hal_get_cycles();
    220220if( DEBUG_PROCESS_REFERENCE_INIT )
    221 printk("\n[DBG] %s : thread %x in process %x / stderr open for process %x / cycle %d\n",
     221printk("\n[%s] thread %x in process %x / stderr open for process %x / cycle %d\n",
    222222__FUNCTION__, CURRENT_THREAD->trdid, parent_pid, pid, cycle );
    223223#endif
     
    260260cycle = (uint32_t)hal_get_cycles();
    261261if( DEBUG_PROCESS_REFERENCE_INIT )
    262 printk("\n[DBG] %s : thread %x in process %x / set fd_array for process %x / cycle %d\n",
     262printk("\n[%s] thread %x in process %x / set fd_array for process %x / cycle %d\n",
    263263__FUNCTION__, CURRENT_THREAD->trdid, parent_pid, pid , cycle );
    264264#endif
     
    301301cycle = (uint32_t)hal_get_cycles();
    302302if( DEBUG_PROCESS_REFERENCE_INIT )
    303 printk("\n[DBG] %s : thread %x in process %x exit for process %x / cycle %d\n",
     303printk("\n[%s] thread %x in process %x exit for process %x / cycle %d\n",
    304304__FUNCTION__, CURRENT_THREAD->trdid, parent_pid, pid, cycle );
    305305#endif
     
    328328uint32_t cycle = (uint32_t)hal_get_cycles();
    329329if( DEBUG_PROCESS_COPY_INIT )
    330 printk("\n[DBG] %s : thread %x in process %x enter for process %x / cycle %d\n",
     330printk("\n[%s] thread %x in process %x enter for process %x / cycle %d\n",
    331331__FUNCTION__, this->trdid, this->process->pid, local_process->pid, cycle );
    332332#endif
     
    383383cycle = (uint32_t)hal_get_cycles();
    384384if( DEBUG_PROCESS_COPY_INIT )
    385 printk("\n[DBG] %s : thread %x in process %x exit for process %x / cycle %d\n",
     385printk("\n[%s] thread %x in process %x exit for process %x / cycle %d\n",
    386386__FUNCTION__, this->trdid, this->process->pid, local_process->pid, cycle );
    387387#endif
     
    402402    pid_t       pid = process->pid;
    403403
    404         assert( (process->th_nr == 0) ,
    405     "process %x in cluster %x has still active threads", pid , local_cxy );
     404// check no more threads
     405assert( (process->th_nr == 0) , "process %x in cluster %x contains threads", pid , local_cxy );
    406406
    407407#if DEBUG_PROCESS_DESTROY
    408408uint32_t cycle = (uint32_t)hal_get_cycles();
    409409if( DEBUG_PROCESS_DESTROY )
    410 printk("\n[DBG] %s : thread %x in process %x enter for process %x in cluster %x / cycle %d\n",
     410printk("\n[%s] thread %x in process %x enter for process %x in cluster %x / cycle %d\n",
    411411__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, pid, local_cxy, cycle );
    412412#endif
     
    457457cycle = (uint32_t)hal_get_cycles();
    458458if( DEBUG_PROCESS_DESTROY )
    459 printk("\n[DBG] %s : thread %x in process %x exit / process %x in cluster %x / cycle %d\n",
     459printk("\n[%s] thread %x in process %x exit / process %x in cluster %x / cycle %d\n",
    460460__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, pid, local_cxy, cycle );
    461461#endif
     
    506506uint32_t cycle = (uint32_t)hal_get_cycles();
    507507if( DEBUG_PROCESS_SIGACTION < cycle )
    508 printk("\n[DBG] %s : thread[%x,%x] enter to %s process %x / cycle %d\n",
     508printk("\n[%s] thread[%x,%x] enter to %s process %x / cycle %d\n",
    509509__FUNCTION__ , client->process->pid, client->trdid,
    510510process_action_str( type ) , pid , cycle );
     
    518518    lpid      = LPID_FROM_PID( pid );
    519519
    520     // get root of list of copies, lock, and number of copies from owner cluster
     520    // get root of list of copies and lock from owner cluster
    521521    root_xp   = XPTR( owner_cxy , &cluster->pmgr.copies_root[lpid] );
    522522    lock_xp   = XPTR( owner_cxy , &cluster->pmgr.copies_lock[lpid] );
     
    527527         (type == UNBLOCK_ALL_THREADS )), "illegal action type" );
    528528             
    529     // The client thread send parallel RPCs to all remote clusters containing
     529    // This client thread send parallel RPCs to all remote clusters containing
    530530    // target process copies, wait all responses, and then handles directly
    531531    // the threads in local cluster, when required.
     
    561561        process_ptr = GET_PTR( process_xp );
    562562
    563         if( process_cxy == local_cxy )    // process is local
     563// printk("\n@@@ in %s : process_cxy %x / process_ptr %x / pid %x\n",
     564// __FUNCTION__, process_cxy, process_ptr, hal_remote_l32( XPTR( process_cxy , &process_ptr->pid ) ) );
     565
     566        if( process_cxy == local_cxy )    // process copy is local
    564567        {
    565568            local = process_ptr;
    566569        }
    567         else                              // process is remote
     570        else                              // process copy is remote
    568571        {
    569572            // update number of remote process copies
     
    575578#if DEBUG_PROCESS_SIGACTION
    576579if( DEBUG_PROCESS_SIGACTION < cycle )
    577 printk("\n[DBG] %s : thread[%x,%x] send RPC to cluster %x for process %x\n",
     580printk("\n[%s] thread[%x,%x] send RPC to cluster %x for process %x\n",
    578581__FUNCTION__, client->process->pid, client->trdid, process_cxy, pid );
    579582#endif
     
    607610#if DEBUG_PROCESS_SIGACTION
    608611if( DEBUG_PROCESS_SIGACTION < cycle )
    609 printk("\n[DBG] %s : thread[%x,%x] handles local process %x in cluster %x\n",
     612printk("\n[%s] thread[%x,%x] handles local process %x in cluster %x\n",
    610613__FUNCTION__, client->process->pid, client->trdid, pid , local_cxy );
    611614#endif
     
    618621cycle = (uint32_t)hal_get_cycles();
    619622if( DEBUG_PROCESS_SIGACTION < cycle )
    620 printk("\n[DBG] %s : thread[%x,%x] exit after %s process %x / cycle %d\n",
     623printk("\n[%s] thread[%x,%x] exit after %s process %x / cycle %d\n",
    621624__FUNCTION__, client->process->pid, client->trdid,
    622625process_action_str( type ), pid, cycle );
     
    633636    cxy_t               owner_cxy;      // target process owner cluster
    634637    uint32_t            count;          // requests counter
    635     volatile uint32_t   ack_count;      // scheduler acknowledge counter
     638    volatile uint32_t   ack_count;      // acknowledges counter
    636639
    637640    // get calling thread pointer
     
    642645uint32_t cycle = (uint32_t)hal_get_cycles();
    643646if( DEBUG_PROCESS_SIGACTION < cycle )
    644 printk("\n[DBG] %s : thread[%x,%x] enter for process %x in cluster %x / cycle %d\n",
     647printk("\n[%s] thread[%x,%x] enter for process %x in cluster %x / cycle %d\n",
    645648__FUNCTION__, this->process->pid, this->trdid, pid, local_cxy , cycle );
    646649#endif
     
    657660    // loop on target process local threads
    658661    // we use both "ltid" and "count" because it can exist "holes" in th_tbl
     662    // - if the calling thread and the target thread are not running on the same
     663    //   core, we ask the target scheduler to acknowlege the blocking
     664    //   to be sure that the target thread is not running.
     665    // - if the calling thread and the target thread are running on the same core,
     666    //   we don't need confirmation from scheduler.
     667           
    659668    for( ltid = 0 , count = 0 , ack_count = 0 ; count < process->th_nr ; ltid++ )
    660669    {
     
    668677            thread_block( XPTR( local_cxy , target ) , THREAD_BLOCKED_GLOBAL );
    669678 
    670             // - if the calling thread and the target thread are running on the same core,
    671             //   we don't need confirmation from scheduler,
    672             // - if the calling thread and the target thread are not running on the same
    673             //   core, we ask the target scheduler to acknowlege the blocking
    674             //   to be sure that the target thread is not running.
    675            
    676679            if( this->core->lid != target->core->lid )
    677680            {
     
    691694    rwlock_rd_release( &process->th_lock );
    692695
    693     // busy waiting acknowledges
    694     // TODO this could be improved...
     696    // wait other threads acknowledges  TODO this could be improved...
    695697    while( 1 )
    696698    {
     
    705707cycle = (uint32_t)hal_get_cycles();
    706708if( DEBUG_PROCESS_SIGACTION < cycle )
    707 printk("\n[DBG] %s : thread[%x,%x] exit for process %x in cluster %x / cycle %d\n",
    708 __FUNCTION__, this, this->process->pid, pid, local_cxy , cycle );
     709printk("\n[%s] thread[%x,%x] exit for process %x in cluster %x / cycle %d\n",
     710__FUNCTION__, this->process->pid, this->trdid, pid, local_cxy , cycle );
    709711#endif
    710712
     
    729731
    730732#if DEBUG_PROCESS_SIGACTION
    731 pid_t pid = process->pid;
    732733uint32_t cycle = (uint32_t)hal_get_cycles();
    733734if( DEBUG_PROCESS_SIGACTION < cycle )
    734 printk("\n[DBG] %s : thread[%x,%x] enter in cluster %x for process %x / cycle %d\n",
     735printk("\n[%s] thread[%x,%x] enter in cluster %x for process %x / cycle %d\n",
    735736__FUNCTION__, this->process->pid, this->trdid, local_cxy, process->pid, cycle );
    736737#endif
    737738
    738739// check target process is an user process
    739 assert( ( LPID_FROM_PID( process->pid ) != 0 ),
    740 "target process must be an user process" );
     740assert( (LPID_FROM_PID( process->pid ) != 0), "process %x not an user process", process->pid );
    741741
    742742    // get lock protecting process th_tbl[]
     
    770770cycle = (uint32_t)hal_get_cycles();
    771771if( DEBUG_PROCESS_SIGACTION < cycle )
    772 printk("\n[DBG] %s : thread[%x,%x] exit for process %x in cluster %x / cycle %d\n",
    773 __FUNCTION__, this->process->pid, this->trdid, pid, local_cxy , cycle );
     772printk("\n[%s] thread[%x,%x] exit for process %x in cluster %x / cycle %d\n",
     773__FUNCTION__, this->process->pid, this->trdid, process->pid, local_cxy , cycle );
    774774#endif
    775775
     
    791791uint32_t cycle = (uint32_t)hal_get_cycles();
    792792if( DEBUG_PROCESS_SIGACTION < cycle )
    793 printk("\n[DBG] %s : thread[%x,%x] enter for process %x in cluster %x / cycle %d\n",
     793printk("\n[%s] thread[%x,%x] enter for process %x in cluster %x / cycle %d\n",
    794794__FUNCTION__, this->process->pid, this->trdid, pid, local_cxy , cycle );
    795795#endif
     
    823823cycle = (uint32_t)hal_get_cycles();
    824824if( DEBUG_PROCESS_SIGACTION < cycle )
    825 printk("\n[DBG] %s : thread[%x,%x] exit for process %x in cluster %x / cycle %d\n",
     825printk("\n[%s] thread[%x,%x] exit for process %x in cluster %x / cycle %d\n",
    826826__FUNCTION__, this->process->pid, this->trdid, pid, local_cxy, cycle );
    827827#endif
     
    842842uint32_t cycle = (uint32_t)hal_get_cycles();
    843843if( DEBUG_PROCESS_GET_LOCAL_COPY < cycle )
    844 printk("\n[DBG] %s : thread[%x,%x] enter for process %x in cluster %x / cycle %d\n",
     844printk("\n[%s] thread[%x,%x] enter for process %x in cluster %x / cycle %d\n",
    845845__FUNCTION__, this->process->pid, this->trdid, pid, local_cxy, cycle );
    846846#endif
     
    889889cycle = (uint32_t)hal_get_cycles();
    890890if( DEBUG_PROCESS_GET_LOCAL_COPY < cycle )
    891 printk("\n[DBG] %s : thread[%x,%x] exit in cluster %x / process %x / cycle %d\n",
     891printk("\n[%s] thread[%x,%x] exit in cluster %x / process %x / cycle %d\n",
    892892__FUNCTION__, this->process->pid, this->trdid, local_cxy, process_ptr, cycle );
    893893#endif
     
    12051205pid_t      pid   = this->process->pid;
    12061206if( DEBUG_PROCESS_MAKE_FORK < cycle )
    1207 printk("\n[DBG] %s : thread[%x,%x] enter / cluster %x / cycle %d\n",
     1207printk("\n[%s] thread[%x,%x] enter / cluster %x / cycle %d\n",
    12081208__FUNCTION__, pid, trdid, local_cxy, cycle );
    12091209#endif
     
    12311231cycle = (uint32_t)hal_get_cycles();
    12321232if( DEBUG_PROCESS_MAKE_FORK < cycle )
    1233 printk("\n[DBG] %s : thread[%x,%x] allocated process %x / cycle %d\n",
     1233printk("\n[%s] thread[%x,%x] allocated process %x / cycle %d\n",
    12341234__FUNCTION__, pid, trdid, new_pid, cycle );
    12351235#endif
     
    12431243cycle = (uint32_t)hal_get_cycles();
    12441244if( DEBUG_PROCESS_MAKE_FORK < cycle )
    1245 printk("\n[DBG] %s : thread[%x,%x] initialized child_process %x / cycle %d\n",
     1245printk("\n[%s] thread[%x,%x] initialized child_process %x / cycle %d\n",
    12461246__FUNCTION__, pid, trdid, new_pid, cycle );
    12471247#endif
     
    12631263cycle = (uint32_t)hal_get_cycles();
    12641264if( DEBUG_PROCESS_MAKE_FORK < cycle )
    1265 printk("\n[DBG] %s : thread[%x,%x] copied VMM from parent to child / cycle %d\n",
     1265printk("\n[%s] thread[%x,%x] copied VMM from parent to child / cycle %d\n",
    12661266__FUNCTION__, pid, trdid, cycle );
    12671267#endif
     
    12761276cycle = (uint32_t)hal_get_cycles();
    12771277if( DEBUG_PROCESS_MAKE_EXEC < cycle )
    1278 printk("\n[DBG] %s : thread[%x,%x] / child takes TXT ownership / cycle %d\n",
     1278printk("\n[%s] thread[%x,%x] / child takes TXT ownership / cycle %d\n",
    12791279__FUNCTION__ , pid, trdid, cycle );
    12801280#endif
     
    13051305cycle = (uint32_t)hal_get_cycles();
    13061306if( DEBUG_PROCESS_MAKE_FORK < cycle )
    1307 printk("\n[DBG] %s : thread[%x,%x] created main thread %x / cycle %d\n",
     1307printk("\n[%s] thread[%x,%x] created main thread %x / cycle %d\n",
    13081308__FUNCTION__, pid, trdid, thread, cycle );
    13091309#endif
     
    13271327cycle = (uint32_t)hal_get_cycles();
    13281328if( DEBUG_PROCESS_MAKE_FORK < cycle )
    1329 printk("\n[DBG] %s : thread[%x,%x] set COW in parent and child / cycle %d\n",
     1329printk("\n[%s] thread[%x,%x] set COW in parent and child / cycle %d\n",
    13301330__FUNCTION__, pid, trdid, cycle );
    13311331#endif
     
    13491349cycle = (uint32_t)hal_get_cycles();
    13501350if( DEBUG_PROCESS_MAKE_FORK < cycle )
    1351 printk("\n[DBG] %s : thread[%x,%x] exit / created process %x / cycle %d\n",
     1351printk("\n[%s] thread[%x,%x] exit / created process %x / cycle %d\n",
    13521352__FUNCTION__, pid, trdid, new_pid, cycle );
    13531353#endif
     
    13831383uint32_t cycle = (uint32_t)hal_get_cycles();
    13841384if( DEBUG_PROCESS_MAKE_EXEC < cycle )
    1385 printk("\n[DBG] %s : thread[%x,%x] enters for %s / cycle %d\n",
     1385printk("\n[%s] thread[%x,%x] enters for %s / cycle %d\n",
    13861386__FUNCTION__, pid, thread->trdid, path, cycle );
    13871387#endif
     
    14051405cycle = (uint32_t)hal_get_cycles();
    14061406if( DEBUG_PROCESS_MAKE_EXEC < cycle )
    1407 printk("\n[DBG] %s : thread[%x,%x] opened file <%s> / cycle %d\n",
     1407printk("\n[%s] thread[%x,%x] opened file <%s> / cycle %d\n",
    14081408__FUNCTION__, pid, thread->trdid, path, cycle );
    14091409#endif
     
    14151415cycle = (uint32_t)hal_get_cycles();
    14161416if( DEBUG_PROCESS_MAKE_EXEC < cycle )
    1417 printk("\n[DBG] %s : thread[%x,%x] deleted all threads / cycle %d\n",
     1417printk("\n[%s] thread[%x,%x] deleted all threads / cycle %d\n",
    14181418__FUNCTION__, pid, thread->trdid, cycle );
    14191419#endif
     
    14251425cycle = (uint32_t)hal_get_cycles();
    14261426if( DEBUG_PROCESS_MAKE_EXEC < cycle )
    1427 printk("\n[DBG] %s : thread[%x,%x] reset VMM / cycle %d\n",
     1427printk("\n[%s] thread[%x,%x] reset VMM / cycle %d\n",
    14281428__FUNCTION__, pid, thread->trdid, cycle );
    14291429#endif
     
    14421442cycle = (uint32_t)hal_get_cycles();
    14431443if( DEBUG_PROCESS_MAKE_EXEC < cycle )
    1444 printk("\n[DBG] %s : thread[%x,%x] / kentry/args/envs vsegs registered / cycle %d\n",
     1444printk("\n[%s] thread[%x,%x] / kentry/args/envs vsegs registered / cycle %d\n",
    14451445__FUNCTION__, pid, thread->trdid, cycle );
    14461446#endif
     
    14601460cycle = (uint32_t)hal_get_cycles();
    14611461if( DEBUG_PROCESS_MAKE_EXEC < cycle )
    1462 printk("\n[DBG] %s : thread[%x,%x] / code/data vsegs registered / cycle %d\n",
     1462printk("\n[%s] thread[%x,%x] / code/data vsegs registered / cycle %d\n",
    14631463__FUNCTION__, pid, thread->trdid, cycle );
    14641464#endif
     
    14921492uint32_t cycle = (uint32_t)hal_get_cycles();
    14931493if( DEBUG_PROCESS_ZERO_CREATE < cycle )
    1494 printk("\n[DBG] %s : enter / cluster %x / cycle %d\n",
     1494printk("\n[%s] enter / cluster %x / cycle %d\n",
    14951495__FUNCTION__, local_cxy, cycle );
    14961496#endif
     
    15391539cycle = (uint32_t)hal_get_cycles();
    15401540if( DEBUG_PROCESS_ZERO_CREATE < cycle )
    1541 printk("\n[DBG] %s : exit / cluster %x / cycle %d\n",
     1541printk("\n[%s] exit / cluster %x / cycle %d\n",
    15421542__FUNCTION__, local_cxy, cycle );
    15431543#endif
     
    15601560uint32_t cycle = (uint32_t)hal_get_cycles();
    15611561if( DEBUG_PROCESS_INIT_CREATE < cycle )
    1562 printk("\n[DBG] %s : thread %x in process %x enter / cycle %d\n",
     1562printk("\n[%s] thread %x in process %x enter / cycle %d\n",
    15631563__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, cycle );
    15641564#endif
     
    15891589#if(DEBUG_PROCESS_INIT_CREATE & 1)
    15901590if( DEBUG_PROCESS_INIT_CREATE < cycle )
    1591 printk("\n[DBG] %s : thread %x in process %x initialized process descriptor\n",
     1591printk("\n[%s] thread %x in process %x initialized process descriptor\n",
    15921592__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid );
    15931593#endif
     
    16081608#if(DEBUG_PROCESS_INIT_CREATE & 1)
    16091609if( DEBUG_PROCESS_INIT_CREATE < cycle )
    1610 printk("\n[DBG] %s : thread %x in process %x open .elf file decriptor\n",
     1610printk("\n[%s] thread %x in process %x open .elf file decriptor\n",
    16111611__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid );
    16121612#endif
     
    16211621#if(DEBUG_PROCESS_INIT_CREATE & 1)
    16221622if( DEBUG_PROCESS_INIT_CREATE < cycle )
    1623 printk("\n[DBG] %s : thread %x in process %x registered code/data vsegs in VMM\n",
     1623printk("\n[%s] thread %x in process %x registered code/data vsegs in VMM\n",
    16241624__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid );
    16251625#endif
     
    16411641#if(DEBUG_PROCESS_INIT_CREATE & 1)
    16421642if( DEBUG_PROCESS_INIT_CREATE < cycle )
    1643 printk("\n[DBG] %s : thread %x in process %x registered init process in parent\n",
     1643printk("\n[%s] thread %x in process %x registered init process in parent\n",
    16441644__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid );
    16451645#endif
     
    16681668#if(DEBUG_PROCESS_INIT_CREATE & 1)
    16691669if( DEBUG_PROCESS_INIT_CREATE < cycle )
    1670 printk("\n[DBG] %s : thread %x in process %x created main thread\n",
     1670printk("\n[%s] thread %x in process %x created main thread\n",
    16711671__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid );
    16721672#endif
     
    16801680cycle = (uint32_t)hal_get_cycles();
    16811681if( DEBUG_PROCESS_INIT_CREATE < cycle )
    1682 printk("\n[DBG] %s : thread %x in process %x exit / cycle %d\n",
     1682printk("\n[%s] thread %x in process %x exit / cycle %d\n",
    16831683__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, cycle );
    16841684#endif
     
    18671867uint32_t cycle = (uint32_t)hal_get_cycles();
    18681868if( DEBUG_PROCESS_TXT < cycle )
    1869 printk("\n[DBG] %s : thread %x in process %x attached process %x to TXT %d / cycle %d\n",
     1869printk("\n[%s] thread %x in process %x attached process %x to TXT %d / cycle %d\n",
    18701870__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid,
    18711871process->pid, txt_id , cycle );
     
    19221922uint32_t txt_id = hal_remote_l32( XPTR( chdev_cxy , &chdev_ptr->channel ) );
    19231923if( DEBUG_PROCESS_TXT < cycle )
    1924 printk("\n[DBG] %s : thread %x in process %x detached process %x from TXT %d / cycle %d\n",
     1924printk("\n[%s] thread %x in process %x detached process %x from TXT %d / cycle %d\n",
    19251925__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid,
    19261926process_pid, txt_id, cycle );
     
    19641964uint32_t txt_id = hal_remote_l32( XPTR( txt_cxy , &txt_ptr->channel ) );
    19651965if( DEBUG_PROCESS_TXT < cycle )
    1966 printk("\n[DBG] %s : thread %x in process %x give TXT %d to process %x / cycle %d\n",
     1966printk("\n[%s] thread %x in process %x give TXT %d to process %x / cycle %d\n",
    19671967__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, txt_id, process_pid, cycle );
    19681968#endif
     
    20452045uint32_t ksh_pid = hal_remote_l32( XPTR( current_cxy , &current_ptr->pid ) );
    20462046if( DEBUG_PROCESS_TXT < cycle )
    2047 printk("\n[DBG] %s : thread %x in process %x release TXT %d to KSH %x / cycle %d\n",
     2047printk("\n[%s] thread %x in process %x release TXT %d to KSH %x / cycle %d\n",
    20482048__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, txt_id, ksh_pid, cycle );
    20492049process_txt_display( txt_id );
     
    20822082uint32_t new_pid = hal_remote_l32( XPTR( current_cxy , &current_ptr->pid ) );
    20832083if( DEBUG_PROCESS_TXT < cycle )
    2084 printk("\n[DBG] %s : thread %x in process %x release TXT %d to process %x / cycle %d\n",
     2084printk("\n[%s] thread %x in process %x release TXT %d to process %x / cycle %d\n",
    20852085__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, txt_id, new_pid, cycle );
    20862086process_txt_display( txt_id );
     
    20992099cycle = (uint32_t)hal_get_cycles();
    21002100if( DEBUG_PROCESS_TXT < cycle )
    2101 printk("\n[DBG] %s : thread %x in process %x release TXT %d to nobody / cycle %d\n",
     2101printk("\n[%s] thread %x in process %x release TXT %d to nobody / cycle %d\n",
    21022102__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, txt_id, cycle );
    21032103process_txt_display( txt_id );
     
    21122112cycle = (uint32_t)hal_get_cycles();
    21132113if( DEBUG_PROCESS_TXT < cycle )
    2114 printk("\n[DBG] %s : thread %x in process %d does nothing (not TXT owner) / cycle %d\n",
     2114printk("\n[%s] thread %x in process %d does nothing (not TXT owner) / cycle %d\n",
    21152115__FUNCTION__, CURRENT_THREAD->trdid, process_pid, cycle );
    21162116process_txt_display( txt_id );
Note: See TracChangeset for help on using the changeset viewer.