Ignore:
Timestamp:
Mar 28, 2018, 2:40:29 PM (4 years ago)
Author:
alain
Message:

Fix various bugs

File:
1 edited

Legend:

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

    r436 r437  
    11/*
    2  * rpc.c - RPC related operations implementation.
     2 * rpc.c - RPC operations implementation.
    33 *
    4  * Author    Alain Greiner (2016,2017)
     4 * Author    Alain Greiner (2016,2017,2018)
    55 *
    66 * Copyright (c)  UPMC Sorbonne Universites
     
    5252if( cycle > CONFIG_DEBUG_RPC_MARSHALING )                                              \
    5353printk("\n[DBG] %s : enter thread %x on core[%x,%d] / cycle %d\n",                     \
    54 __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, CURRENT_THREAD->core->lid , cycle );
     54__FUNCTION__ , CURRENT_THREAD , local_cxy, CURRENT_THREAD->core->lid , cycle );
    5555
    5656#define RPC_DEBUG_EXIT                                                                 \
     
    5858if( cycle > CONFIG_DEBUG_RPC_MARSHALING )                                              \
    5959printk("\n[DBG] %s : exit thread %x on core[%x,%d] / cycle %d\n",                      \
    60 __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, CURRENT_THREAD->core->lid , cycle );
     60__FUNCTION__ , CURRENT_THREAD , local_cxy, CURRENT_THREAD->core->lid , cycle );
    6161
    6262#else
     
    129129uint32_t cycle = (uint32_t)hal_get_cycles();
    130130if( CONFIG_DEBUG_RPC_SEND < cycle )
    131 printk("\n[DBG] %s : thread %x enter for rpc[%d] / rpc_ptr %x / cycle %d\n",
    132 __FUNCTION__, CURRENT_THREAD, rpc->index, rpc, cycle );
     131printk("\n[DBG] %s : thread %x in cluster %x enter for rpc[%d] / rpc_ptr %x / cycle %d\n",
     132__FUNCTION__, CURRENT_THREAD, local_cxy, rpc->index, rpc, cycle );
    133133#endif
    134134
     
    174174cycle = (uint32_t)hal_get_cycles();
    175175if( CONFIG_DEBUG_RPC_SEND < cycle )
    176 printk("\n[DBG] %s : thread %x busy waiting / rpc[%d] / server = %x / cycle %d\n",
    177 __FUNCTION__, CURRENT_THREAD, rpc->index , server_cxy , cycle );
     176printk("\n[DBG] %s : thread %x in cluster %x busy waiting / rpc[%d] / cycle %d\n",
     177__FUNCTION__, CURRENT_THREAD, local_cxy, rpc->index , cycle );
    178178#endif
    179179
     
    183183cycle = (uint32_t)hal_get_cycles();
    184184if( CONFIG_DEBUG_RPC_SEND < cycle )
    185 printk("\n[DBG] %s : thread % resume / rpc[%d] / cycle %d\n",
    186 __FUNCTION__, CURRENT_THREAD, rpc->index, cycle );
     185printk("\n[DBG] %s : thread % in cluster %x resume / rpc[%d] / cycle %d\n",
     186__FUNCTION__, CURRENT_THREAD, local_cxy, rpc->index, cycle );
    187187#endif
    188188        }
     
    193193cycle = (uint32_t)hal_get_cycles();
    194194if( CONFIG_DEBUG_RPC_SEND < cycle )
    195 printk("\n[DBG] %s : thread %x block & deschedule / rpc[%d] / server = %x / cycle %d\n",
    196 __FUNCTION__, CURRENT_THREAD, rpc->index , server_cxy , cycle );
     195printk("\n[DBG] %s : thread %x in cluster %x deschedule / rpc[%d] / cycle %d\n",
     196__FUNCTION__, CURRENT_THREAD, local_cxy, rpc->index , cycle );
    197197#endif
    198198            thread_block( XPTR( local_cxy , this ) , THREAD_BLOCKED_RPC );
     
    202202cycle = (uint32_t)hal_get_cycles();
    203203if( CONFIG_DEBUG_RPC_SEND < cycle )
    204 printk("\n[DBG] %s : thread % resume / rpcr[%d] / cycle %d\n",
    205 __FUNCTION__, CURRENT_THREAD, rpc->index, cycle );
     204printk("\n[DBG] %s : thread % in cluster %x resume / rpcr[%d] / cycle %d\n",
     205__FUNCTION__, CURRENT_THREAD, local_cxy, rpc->index, cycle );
    206206#endif
    207207        }
     
    219219cycle = (uint32_t)hal_get_cycles();
    220220if( CONFIG_DEBUG_RPC_SEND < cycle )
    221 printk("\n[DBG] %s : non blocking rpc[%d] => thread return  / cycle %d\n",
     221printk("\n[DBG] %s : non blocking rpc[%d] => thread %x return  / cycle %d\n",
    222222__FUNCTION__, rpc->index, CURRENT_THREAD, cycle );
    223223#endif
     
    355355uint32_t cycle = (uint32_t)hal_get_cycles();
    356356if( CONFIG_DEBUG_RPC_SERVER < cycle )
    357 printk("\n[DBG] %s : RPC thread %x takes RPC fifo ownership / cluster %x / cycle %d\n",
     357printk("\n[DBG] %s : RPC thread %x in cluster %x takes RPC fifo ownership / cycle %d\n",
    358358__FUNCTION__, this, local_cxy, cycle );
    359359#endif
     
    378378                    desc_ptr = GET_PTR( desc_xp );
    379379
    380                         index    = desc_ptr->index;
    381                     blocking = desc_ptr->blocking;
     380                        index    = hal_remote_lw( XPTR( desc_cxy , &desc_ptr->index ) );
     381                    blocking = hal_remote_lw( XPTR( desc_cxy , &desc_ptr->blocking ) );
    382382
    383383#if CONFIG_DEBUG_RPC_SERVER
    384384cycle = (uint32_t)hal_get_cycles();
    385385if( CONFIG_DEBUG_RPC_SERVER < cycle )
    386 printk("\n[DBG] %s : RPC thread %x got rpc[%d] / rpc_ptr %x / cycle %d\n",
    387 __FUNCTION__, this, index, desc_ptr, cycle );
     386printk("\n[DBG] %s : RPC thread %x in cluster %x got rpc[%d] / rpc_ptr %x / cycle %d\n",
     387__FUNCTION__, this, local_cxy, index, desc_ptr, cycle );
    388388#endif
    389389                    // call the relevant server function
     
    393393cycle = (uint32_t)hal_get_cycles();
    394394if( CONFIG_DEBUG_RPC_SERVER < cycle )
    395 printk("\n[DBG] %s : RPC thread %x completes rpc %d in cluster %x / cycle %d\n",
    396 __FUNCTION__, this, index, local_cxy, cycle );
     395printk("\n[DBG] %s : RPC thread %x in cluster %x completes rpc[%d] / rpc_ptr %x / cycle %d\n",
     396__FUNCTION__, this, local_cxy, index, cycle );
    397397#endif
    398398                    // increment handled RPCs counter
     
    435435uint32_t cycle = (uint32_t)hal_get_cycles();
    436436if( CONFIG_DEBUG_RPC_SERVER < cycle )
    437 printk("\n[DBG] %s : RPC thread %x suicides in cluster %x / cycle %d\n",
     437printk("\n[DBG] %s : RPC thread %x in cluster %x suicides / cycle %d\n",
    438438__FUNCTION__, this, local_cxy, cycle );
    439439#endif
     
    450450uint32_t cycle = (uint32_t)hal_get_cycles();
    451451if( CONFIG_DEBUG_RPC_SERVER < cycle )
    452 printk("\n[DBG] %s : RPC thread %x deschedules in cluster %x / cycle %d\n",
     452printk("\n[DBG] %s : RPC thread %x in cluster %x deschedules / cycle %d\n",
    453453__FUNCTION__, this, local_cxy, cycle );
    454454#endif
     
    460460cycle = (uint32_t)hal_get_cycles();
    461461if( CONFIG_DEBUG_RPC_SERVER < cycle )
    462 printk("\n[DBG] %s : RPC thread %x resumes in cluster %x / cycle %d\n",
     462printk("\n[DBG] %s : RPC thread %x in cluster %x resumes / cycle %d\n",
    463463__FUNCTION__, this, local_cxy, cycle );
    464464#endif
     
    478478                                page_t  ** page )      // out
    479479{
    480 rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    481 __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    482 CURRENT_THREAD->core->lid , hal_time_stamp() );
    483480
    484481    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
     
    499496    *page = (page_t *)(intptr_t)rpc.args[1];
    500497
    501 rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    502 __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    503 CURRENT_THREAD->core->lid , hal_time_stamp() );
    504498}
    505499
     
    507501void rpc_pmem_get_pages_server( xptr_t xp )
    508502{
    509 rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    510 __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    511 CURRENT_THREAD->core->lid , hal_time_stamp() );
    512503
    513504    // get client cluster identifier and pointer on RPC descriptor
     
    524515    hal_remote_swd( XPTR( cxy , &desc->args[1] ) , (uint64_t)(intptr_t)page );
    525516
    526 rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    527 __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    528 CURRENT_THREAD->core->lid , hal_time_stamp() );
    529517}
    530518
     
    537525                                    page_t  * page )      // out
    538526{
    539 rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    540 __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    541 CURRENT_THREAD->core->lid , hal_time_stamp() );
    542527
    543528    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
     
    555540    rpc_send( cxy , &rpc );
    556541
    557 rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    558 __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    559 CURRENT_THREAD->core->lid , hal_time_stamp() );
    560542}
    561543
     
    563545void rpc_pmem_release_pages_server( xptr_t xp )
    564546{
    565 rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    566 __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    567 CURRENT_THREAD->core->lid , hal_time_stamp() );
    568547
    569548    // get client cluster identifier and pointer on RPC descriptor
     
    580559    kmem_free( &req );
    581560
    582 rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    583 __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    584 CURRENT_THREAD->core->lid , hal_time_stamp() );
    585561}
    586562
     
    601577                                   error_t   * error )              // out
    602578{
    603 rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    604 __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    605 CURRENT_THREAD->core->lid , hal_time_stamp() );
    606 
    607579    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
    608580
     
    625597    *error             = (error_t)rpc.args[4];     
    626598
    627 rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    628 __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    629 CURRENT_THREAD->core->lid , hal_time_stamp() );
    630599}
    631600
     
    633602void rpc_process_make_fork_server( xptr_t xp )
    634603{
    635 rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    636 __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    637 CURRENT_THREAD->core->lid , hal_time_stamp() );
    638604
    639605    xptr_t     ref_process_xp;     // extended pointer on reference parent process
     
    662628    hal_remote_swd( XPTR( client_cxy , &desc->args[4] ) , (uint64_t)error );
    663629
    664 rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    665 __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    666 CURRENT_THREAD->core->lid , hal_time_stamp() );
    667630}
    668631
     
    688651                                    error_t        * error )      // out
    689652{
    690 rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    691 __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    692 CURRENT_THREAD->core->lid , hal_time_stamp() );
    693 
    694653    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
    695654
     
    713672    *error     = (error_t)rpc.args[5];
    714673
    715 rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    716 __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    717 CURRENT_THREAD->core->lid , hal_time_stamp() );
    718674}
    719675
     
    721677void rpc_thread_user_create_server( xptr_t xp )
    722678{
    723 rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    724 __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    725 CURRENT_THREAD->core->lid , hal_time_stamp() );
    726679
    727680    pthread_attr_t * attr_ptr;   // pointer on attributes structure in client cluster
     
    764717    hal_remote_swd( XPTR( client_cxy , &desc->args[5] ) , (uint64_t)error );
    765718
    766 rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    767 __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    768 CURRENT_THREAD->core->lid , hal_time_stamp() );
    769719}
    770720
     
    781731                                      error_t * error )      // out
    782732{
    783 rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    784 __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    785 CURRENT_THREAD->core->lid , hal_time_stamp() );
    786 
    787733    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
    788734
     
    805751    *error     = (error_t)rpc.args[4];
    806752
    807 rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    808 __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    809 CURRENT_THREAD->core->lid , hal_time_stamp() );
    810753}
    811754
     
    813756void rpc_thread_kernel_create_server( xptr_t xp )
    814757{
    815 rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    816 __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    817 CURRENT_THREAD->core->lid , hal_time_stamp() );
    818 
    819758    thread_t       * thread_ptr;  // local pointer on thread descriptor
    820759    xptr_t           thread_xp;   // extended pointer on thread descriptor
     
    842781    hal_remote_swd( XPTR( client_cxy , &desc->args[2] ) , (uint64_t)thread_xp );
    843782
    844 rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    845 __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    846 CURRENT_THREAD->core->lid , hal_time_stamp() );
    847783}
    848784
     
    962898                                  error_t      * error )     // out
    963899{
    964     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    965     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    966     CURRENT_THREAD->core->lid , hal_time_stamp() );
    967 
    968900    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
    969901
     
    991923    *error    = (error_t)rpc.args[9];
    992924
    993     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    994     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    995     CURRENT_THREAD->core->lid , hal_time_stamp() );
    996925}
    997926
     
    1010939    error_t          error;
    1011940
    1012     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    1013     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1014     CURRENT_THREAD->core->lid , hal_time_stamp() );
    1015 
    1016941    // get client cluster identifier and pointer on RPC descriptor
    1017942    cxy_t        client_cxy  = GET_CXY( xp );
     
    1043968    hal_remote_swd( XPTR( client_cxy , &desc->args[9] ) , (uint64_t)error );
    1044969
    1045     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    1046     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1047     CURRENT_THREAD->core->lid , hal_time_stamp() );
    1048970}
    1049971
     
    1056978                                   struct vfs_inode_s * inode )
    1057979{
    1058     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    1059     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1060     CURRENT_THREAD->core->lid , hal_time_stamp() );
    1061 
    1062980    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
    1063981
     
    1074992    rpc_send( cxy , &rpc );
    1075993
    1076     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    1077     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1078     CURRENT_THREAD->core->lid , hal_time_stamp() );
    1079994}
    1080995
     
    1083998{
    1084999    vfs_inode_t * inode;
    1085 
    1086     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    1087     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1088     CURRENT_THREAD->core->lid , hal_time_stamp() );
    10891000
    10901001    // get client cluster identifier and pointer on RPC descriptor
     
    10981009    vfs_inode_destroy( inode );
    10991010
    1100     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    1101     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1102     CURRENT_THREAD->core->lid , hal_time_stamp() );
    11031011}
    11041012
     
    11151023                                   error_t              * error )       // out
    11161024{
    1117     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    1118     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1119     CURRENT_THREAD->core->lid , hal_time_stamp() );
     1025    RPC_DEBUG_ENTER
    11201026
    11211027    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
     
    11391045    *error     = (error_t)rpc.args[4];
    11401046
    1141     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    1142     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1143     CURRENT_THREAD->core->lid , hal_time_stamp() );
     1047    RPC_DEBUG_EXIT
    11441048}
    11451049
     
    11531057    error_t       error;
    11541058
     1059    RPC_DEBUG_ENTER
     1060
    11551061    char          name_copy[CONFIG_VFS_MAX_NAME_LENGTH];
    1156 
    1157     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    1158     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1159     CURRENT_THREAD->core->lid , hal_time_stamp() );
    11601062
    11611063    // get client cluster identifier and pointer on RPC descriptor
     
    11811083    hal_remote_swd( XPTR( client_cxy , &desc->args[4] ) , (uint64_t)error );
    11821084
    1183     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    1184     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1185     CURRENT_THREAD->core->lid , hal_time_stamp() );
     1085    RPC_DEBUG_EXIT
    11861086}
    11871087
     
    11951095                                    vfs_dentry_t * dentry )
    11961096{
    1197     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    1198     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1199     CURRENT_THREAD->core->lid , hal_time_stamp() );
    1200 
    12011097    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
    12021098
     
    12131109    rpc_send( cxy , &rpc );
    12141110
    1215     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    1216     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1217     CURRENT_THREAD->core->lid , hal_time_stamp() );
    12181111}
    12191112
     
    12221115{
    12231116    vfs_dentry_t * dentry;
    1224 
    1225     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    1226     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1227     CURRENT_THREAD->core->lid , hal_time_stamp() );
    12281117
    12291118    // get client cluster identifier and pointer on RPC descriptor
     
    12371126    vfs_dentry_destroy( dentry );
    12381127
    1239     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    1240     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1241     CURRENT_THREAD->core->lid , hal_time_stamp() );
    12421128}
    12431129
     
    12541140                                 error_t              * error )      // out
    12551141{
    1256     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    1257     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1258     CURRENT_THREAD->core->lid , hal_time_stamp() );
    1259 
    12601142    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
    12611143
     
    12771159    *error   = (error_t)rpc.args[3];
    12781160
    1279     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    1280     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1281     CURRENT_THREAD->core->lid , hal_time_stamp() );
    12821161}
    12831162
     
    12891168    xptr_t        file_xp;
    12901169    error_t       error;
    1291 
    1292     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    1293     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1294     CURRENT_THREAD->core->lid , hal_time_stamp() );
    12951170
    12961171    // get client cluster identifier and pointer on RPC descriptor
     
    13111186    hal_remote_swd( XPTR( client_cxy , &desc->args[3] ) , (uint64_t)error );
    13121187
    1313     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    1314     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1315     CURRENT_THREAD->core->lid , hal_time_stamp() );
    13161188}
    13171189
     
    13241196                                  vfs_file_t * file )
    13251197{
    1326     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    1327     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1328     CURRENT_THREAD->core->lid , hal_time_stamp() );
    1329 
    13301198    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
    13311199
     
    13421210    rpc_send( cxy , &rpc );
    13431211
    1344     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    1345     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1346     CURRENT_THREAD->core->lid , hal_time_stamp() );
    13471212}
    13481213
     
    13511216{
    13521217    vfs_file_t * file;
    1353 
    1354     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    1355     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1356     CURRENT_THREAD->core->lid , hal_time_stamp() );
    13571218
    13581219    // get client cluster identifier and pointer on RPC descriptor
     
    13661227    vfs_file_destroy( file );
    13671228
    1368     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    1369     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1370     CURRENT_THREAD->core->lid , hal_time_stamp() );
    13711229}
    13721230
     
    13821240                                error_t     * error )          // out
    13831241{
    1384     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    1385     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1386     CURRENT_THREAD->core->lid , hal_time_stamp() );
    1387 
    13881242    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
    13891243
     
    14051259    *error   = (error_t)rpc.args[3];
    14061260
    1407     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    1408     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1409     CURRENT_THREAD->core->lid , hal_time_stamp() );
    14101261}
    14111262
     
    14201271    char          name_copy[CONFIG_VFS_MAX_NAME_LENGTH];
    14211272
    1422     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    1423     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1424     CURRENT_THREAD->core->lid , hal_time_stamp() );
    1425 
    14261273    // get client cluster identifier and pointer on RPC descriptor
    14271274    cxy_t        client_cxy  = GET_CXY( xp );
     
    14431290    hal_remote_swd( XPTR( client_cxy , &desc->args[3] ) , (uint64_t)error );
    14441291
    1445     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    1446     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1447     CURRENT_THREAD->core->lid , hal_time_stamp() );
    14481292}
    14491293
     
    14571301                                     error_t     * error )     // out
    14581302{
    1459     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    1460     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1461     CURRENT_THREAD->core->lid , hal_time_stamp() );
    1462 
    14631303    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
    14641304
     
    14781318    *error   = (error_t)rpc.args[1];
    14791319
    1480     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    1481     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1482     CURRENT_THREAD->core->lid , hal_time_stamp() );
    14831320}
    14841321
     
    14891326    vfs_inode_t * inode;
    14901327
    1491     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    1492     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1493     CURRENT_THREAD->core->lid , hal_time_stamp() );
    1494 
    14951328    // get client cluster identifier and pointer on RPC descriptor
    14961329    cxy_t        client_cxy  = GET_CXY( xp );
     
    15061339    hal_remote_swd( XPTR( client_cxy , &desc->args[1] ) , (uint64_t)error );
    15071340
    1508     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    1509     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1510     CURRENT_THREAD->core->lid , hal_time_stamp() );
    15111341}
    15121342
     
    15231353                                   error_t  * error )    // out
    15241354{
    1525     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    1526     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1527     CURRENT_THREAD->core->lid , hal_time_stamp() );
    1528 
    15291355    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
    15301356
     
    15471373    *error   = (error_t)rpc.args[4];
    15481374
    1549     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    1550     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1551     CURRENT_THREAD->core->lid , hal_time_stamp() );
    15521375}
    15531376
     
    15611384    error_t       error;
    15621385
    1563     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    1564     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1565     CURRENT_THREAD->core->lid , hal_time_stamp() );
    1566 
    15671386    // get client cluster identifier and pointer on RPC descriptor
    15681387    cxy_t        client_cxy  = GET_CXY( xp );
     
    15811400    hal_remote_swd( XPTR( client_cxy , &desc->args[4] ) , (uint64_t)error );
    15821401
    1583     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    1584     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1585     CURRENT_THREAD->core->lid , hal_time_stamp() );
    15861402}
    15871403
     
    15971413                              error_t   * error )      // out
    15981414{
    1599     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    1600     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1601     CURRENT_THREAD->core->lid , hal_time_stamp() );
    1602 
    16031415    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
    16041416
     
    16201432    *error   = (error_t)rpc.args[3];
    16211433
    1622     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    1623     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1624     CURRENT_THREAD->core->lid , hal_time_stamp() );
    16251434}
    16261435
     
    16331442    xptr_t        vseg_xp;
    16341443    error_t       error;
    1635 
    1636     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    1637     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1638     CURRENT_THREAD->core->lid , hal_time_stamp() );
    16391444
    16401445    // get client cluster identifier and pointer on RPC descriptor
     
    16541459    hal_remote_swd( XPTR( client_cxy , &desc->args[3] ) , (uint64_t)error );
    16551460
    1656     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    1657     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1658     CURRENT_THREAD->core->lid , hal_time_stamp() );
    16591461}
    16601462
     
    16731475                             error_t   * error )   // out
    16741476{
    1675     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    1676     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1677     CURRENT_THREAD->core->lid , hal_time_stamp() );
    1678 
    16791477    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
    16801478
     
    16981496    *error = (error_t)rpc.args[5];
    16991497
    1700     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    1701     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1702     CURRENT_THREAD->core->lid , hal_time_stamp() );
    17031498}
    17041499
     
    17121507    ppn_t         ppn;
    17131508    error_t       error;
    1714 
    1715     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    1716     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1717     CURRENT_THREAD->core->lid , hal_time_stamp() );
    17181509
    17191510    // get client cluster identifier and pointer on RPC descriptor
     
    17341525    hal_remote_swd( XPTR( client_cxy , &desc->args[5] ) , (uint64_t)error );
    17351526
    1736     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    1737     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1738     CURRENT_THREAD->core->lid , hal_time_stamp() );
    17391527}
    17401528
     
    17481536                           xptr_t *   buf_xp )     // out
    17491537{
    1750     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    1751     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1752     CURRENT_THREAD->core->lid , hal_time_stamp() );
    1753 
    17541538    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
    17551539
     
    17691553    *buf_xp = (xptr_t)rpc.args[1];
    17701554
    1771     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    1772     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1773     CURRENT_THREAD->core->lid , hal_time_stamp() );
    17741555}
    17751556
     
    17771558void rpc_kcm_alloc_server( xptr_t xp )
    17781559{
    1779     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    1780     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1781     CURRENT_THREAD->core->lid , hal_time_stamp() );
    1782 
    17831560    // get client cluster identifier and pointer on RPC descriptor
    17841561    cxy_t        client_cxy  = GET_CXY( xp );
     
    17981575    hal_remote_swd( XPTR( client_cxy , &desc->args[1] ) , (uint64_t)buf_xp );
    17991576
    1800     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    1801     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1802     CURRENT_THREAD->core->lid , hal_time_stamp() );
    18031577}   
    18041578
     
    18121586                          uint32_t   kmem_type )   // in
    18131587{
    1814     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    1815     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1816     CURRENT_THREAD->core->lid , hal_time_stamp() );
    1817 
    18181588    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
    18191589
     
    18311601    rpc_send( cxy , &rpc );
    18321602
    1833     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    1834     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1835     CURRENT_THREAD->core->lid , hal_time_stamp() );
    18361603}
    18371604
     
    18391606void rpc_kcm_free_server( xptr_t xp )
    18401607{
    1841     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    1842     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1843     CURRENT_THREAD->core->lid , hal_time_stamp() );
    1844 
    18451608    // get client cluster identifier and pointer on RPC descriptor
    18461609    cxy_t        client_cxy  = GET_CXY( xp );
     
    18571620    kmem_free( &req );
    18581621
    1859     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    1860     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1861     CURRENT_THREAD->core->lid , hal_time_stamp() );
    18621622}   
    18631623
     
    18761636                                    error_t  * error )        // out
    18771637{
    1878     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    1879     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1880     CURRENT_THREAD->core->lid , hal_time_stamp() );
    1881 
    18821638    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
    18831639
     
    19021658    *error     = (error_t)rpc.args[6];
    19031659
    1904     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    1905     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1906     CURRENT_THREAD->core->lid , hal_time_stamp() );
    19071660}
    19081661
     
    19181671    uint32_t   size;
    19191672    error_t    error;
    1920 
    1921     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    1922     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1923     CURRENT_THREAD->core->lid , hal_time_stamp() );
    19241673
    19251674    // get client cluster identifier and pointer on RPC descriptor
     
    19591708    hal_remote_swd( XPTR( client_cxy , &desc->args[6] ) , (uint64_t)error );
    19601709
    1961     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    1962     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1963     CURRENT_THREAD->core->lid , hal_time_stamp() );
    19641710}
    19651711
     
    19741720                                 page_t         ** page )      // out
    19751721{
    1976     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    1977     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    1978     CURRENT_THREAD->core->lid , hal_time_stamp() );
    1979 
    19801722    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
    19811723
     
    19961738    *page = (page_t *)(intptr_t)rpc.args[2];
    19971739
    1998     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    1999     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    2000     CURRENT_THREAD->core->lid , hal_time_stamp() );
    20011740}
    20021741
     
    20041743void rpc_mapper_get_page_server( xptr_t xp )
    20051744{
    2006     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    2007     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    2008     CURRENT_THREAD->core->lid , hal_time_stamp() );
    2009 
    20101745    // get client cluster identifier and pointer on RPC descriptor
    20111746    cxy_t        cxy  = GET_CXY( xp );
     
    20221757    hal_remote_swd( XPTR( cxy , &desc->args[1] ) , (uint64_t)(intptr_t)page );
    20231758
    2024     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    2025     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    2026     CURRENT_THREAD->core->lid , hal_time_stamp() );
    20271759}
    20281760
     
    20431775                                 struct vseg_s   ** vseg )
    20441776{
    2045     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    2046     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    2047     CURRENT_THREAD->core->lid , hal_time_stamp() );
    2048 
    20491777    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
    20501778
     
    20711799    *vseg = (vseg_t *)(intptr_t)rpc.args[8];
    20721800
    2073     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    2074     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    2075     CURRENT_THREAD->core->lid , hal_time_stamp() );
    20761801}
    20771802
     
    20791804void rpc_vmm_create_vseg_server( xptr_t xp )
    20801805{
    2081     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    2082     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    2083     CURRENT_THREAD->core->lid , hal_time_stamp() );
    2084 
    20851806    // get client cluster identifier and pointer on RPC descriptor
    20861807    cxy_t        cxy  = GET_CXY( xp );
     
    21101831    hal_remote_swd( XPTR( cxy , &desc->args[8] ) , (uint64_t)(intptr_t)vseg );
    21111832
    2112     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    2113     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    2114     CURRENT_THREAD->core->lid , hal_time_stamp() );
    21151833}
    21161834
     
    21231841                               lid_t              lid)
    21241842{
    2125     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    2126     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    2127     CURRENT_THREAD->core->lid , hal_time_stamp() );
    2128 
    21291843    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
    21301844
     
    21411855    rpc_send( cxy , &rpc );
    21421856
    2143     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    2144     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    2145     CURRENT_THREAD->core->lid , hal_time_stamp() );
    21461857}
    21471858
     
    21491860void rpc_sched_display_server( xptr_t xp )
    21501861{
    2151     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    2152     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    2153     CURRENT_THREAD->core->lid , hal_time_stamp() );
    2154 
    21551862    // get client cluster identifier and pointer on RPC descriptor
    21561863    cxy_t        cxy  = GET_CXY( xp );
     
    21631870    sched_display( lid );
    21641871
    2165     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    2166     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    2167     CURRENT_THREAD->core->lid , hal_time_stamp() );
    21681872}
    21691873
     
    21761880                             process_t * process )
    21771881{
    2178     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    2179     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    2180     CURRENT_THREAD->core->lid , hal_time_stamp() );
    2181 
    21821882    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
    21831883
     
    21941894    rpc_send( cxy , &rpc );
    21951895
    2196     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    2197     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    2198     CURRENT_THREAD->core->lid , hal_time_stamp() );
    21991896}
    22001897
     
    22021899void rpc_vmm_set_cow_server( xptr_t xp )
    22031900{
    2204     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    2205     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    2206     CURRENT_THREAD->core->lid , hal_time_stamp() );
    2207 
    22081901    process_t * process;
    22091902
     
    22181911    vmm_set_cow( process );
    22191912
    2220     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    2221     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    2222     CURRENT_THREAD->core->lid , hal_time_stamp() );
    22231913}
    22241914
     
    22321922                             bool_t      detailed )
    22331923{
    2234     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    2235     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    2236     CURRENT_THREAD->core->lid , hal_time_stamp() );
    2237 
    22381924    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
    22391925
     
    22511937    rpc_send( cxy , &rpc );
    22521938
    2253     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    2254     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    2255     CURRENT_THREAD->core->lid , hal_time_stamp() );
    22561939}
    22571940
     
    22591942void rpc_vmm_display_server( xptr_t xp )
    22601943{
    2261     rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
    2262     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    2263     CURRENT_THREAD->core->lid , hal_time_stamp() );
    2264 
    22651944    process_t * process;
    22661945    bool_t      detailed;
     
    22771956    vmm_display( process , detailed );
    22781957
    2279     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    2280     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
    2281     CURRENT_THREAD->core->lid , hal_time_stamp() );
    2282 }
    2283 
    2284 
     1958}
     1959
     1960
Note: See TracChangeset for help on using the changeset viewer.