Ignore:
Timestamp:
Jan 4, 2018, 10:05:47 AM (7 years ago)
Author:
alain
Message:

Improve sys_exec.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/kernel/kern/rpc.c

    r415 r416  
    9494///////////////////////////////////////
    9595void rpc_send( cxy_t        server_cxy,
    96                rpc_desc_t * rpc,
    97                bool_t       block )
     96               rpc_desc_t * rpc )
    9897{
    9998    error_t    error;
    … …  
    106105    rpc->lid       = core->lid;
    107106
    108 printk("\n   @@@ enter %s : rpc_desc_cxy = %x / rpc_desc_ptr = %x / index = %d / &index = %x\n",
    109 __FUNCTION__ , local_cxy , rpc , rpc->index , &rpc->index);
    110  
    111107    // build an extended pointer on the RPC descriptor
    112108        xptr_t   desc_xp = XPTR( local_cxy , rpc );
    … …  
    137133        dev_pic_send_ipi( server_cxy , core->lid );
    138134
    139     // wait RPC completion if blocking
     135    // wait RPC completion before returning if blocking RPC
    140136    // - busy waiting policy during kernel_init, or if threads cannot yield
    141137    // - block and deschedule in all other cases
    142     if ( block )
     138    if ( rpc->blocking )
    143139    {
    144140        if( (this->type == THREAD_IDLE) || (thread_can_yield() == false) ) // busy waiting
    … …  
    178174        dev_pic_ack_ipi();
    179175    }
    180    
    181 printk("\n   @@@ exit %s : rpc_desc_cxy = %x / rpc_desc_ptr = %x / index = %d / &index = %x\n",
    182 __FUNCTION__ , local_cxy , rpc , rpc->index , &rpc->index);
    183  
    184176}  // end rpc_send()
    185177
    … …  
    244236                    hal_atomic_add( &LOCAL_CLUSTER->rpc_threads , 1 );
    245237
    246 grpc_dmsg("\n[DBG] %s : core [%x,%d] creates a new RPC thread %x / cycle %d\n",
    247 __FUNCTION__ , local_cxy , core->lid , thread->trdid , hal_time_stamp() );
     238grpc_dmsg("\n[DBG] %s : core [%x,%d] creates a new RPC thread %x / trdid %x / cycle %d\n",
     239__FUNCTION__ , local_cxy , core->lid , thread , thread->trdid , hal_time_stamp() );
    248240
    249241            }
    250242        }
    251243    }
    252 
    253 //@@@
    254 sched_display( 0 );
    255 //@@@
    256244
    257245grpc_dmsg("\n[DBG] %s : core[%x,%d] / interrupted thread %s deschedules / cycle %d\n",
    … …  
    279267    rpc_desc_t * desc_ptr;    // RPC request local pointer
    280268    uint32_t     index;       // RPC request index
    281     uint32_t     responses;   // number of responses received by client
    282269    thread_t   * thread_ptr;  // local pointer on client thread
    283270    lid_t        core_lid;    // local index of client core
     271    bool_t       blocking;    // blocking RPC when true
    284272 
    285273    // makes RPC thread not preemptable
    … …  
    319307                    desc_ptr = (rpc_desc_t *)GET_PTR( desc_xp );
    320308
    321                     // get rpc index from RPC descriptor
    322                         index = hal_remote_lw( XPTR( desc_cxy , &desc_ptr->index ) );
    323 
    324 printk("\n   @@@ in %s : rpc_desc_cxy = %x / rpc_desc_ptr = %x / index = %d / &index = %x\n",
    325 __FUNCTION__ , desc_cxy , desc_ptr , index , &desc_ptr->index );
    326  
     309                    // get RPC <index> & <blocking> fields from RPC descriptor
     310                        index    = hal_remote_lw( XPTR( desc_cxy , &desc_ptr->index ) );
     311                    blocking = hal_remote_lw( XPTR( desc_cxy , &desc_ptr->blocking ) );
     312
    327313grpc_dmsg("\n[DBG] %s : core[%x,%d] / RPC thread %x / starts rpc %d / cycle %d\n",
    328314__FUNCTION__ , local_cxy , this->core->lid , this->trdid , index , (uint32_t)hal_get_cycles() );
    … …  
    334320__FUNCTION__ , local_cxy , this->core->lid , this->trdid , index , hal_time_stamp() );
    335321
    336                     // increment handled RPC counter
     322                    // increment handled RPCs counter
    337323                        count++;
    338324
    339                     // decrement response counter in RPC descriptor
    340                     responses = hal_remote_atomic_add(XPTR( desc_cxy, &desc_ptr->response ), -1);
    341 
    342                     // unblock client thread  and send IPI to client core if last response
    343                     if( responses == 1 )
    344                     {
    345                         // get pointer on client thread and unblock it
     325                    // decrement response counter in RPC descriptor if blocking
     326                    if( blocking )
     327                    {
     328                        // decrement responses counter in RPC descriptor
     329                        hal_remote_atomic_add(XPTR( desc_cxy, &desc_ptr->response ), -1);
     330
     331                        // unblock client thread
    346332                        thread_ptr = (thread_t *)hal_remote_lpt(XPTR(desc_cxy,&desc_ptr->thread));
    347333                        thread_unblock( XPTR(desc_cxy,thread_ptr) , THREAD_BLOCKED_RPC );
    … …  
    363349            // release rpc_fifo ownership if not lost
    364350            if( rpc_fifo->owner == this->trdid ) rpc_fifo->owner = 0;
    365         }
     351
     352        }  // end if RPC fifo
    366353
    367354        // sucide if too many RPC threads in cluster
    … …  
    412399    rpc.index    = RPC_PMEM_GET_PAGES;
    413400    rpc.response = 1;
     401    rpc.blocking = true;
    414402
    415403    // set input arguments in RPC descriptor
    … …  
    417405
    418406    // register RPC request in remote RPC fifo (blocking function)
    419     rpc_send( cxy , &rpc  , true );
     407    rpc_send( cxy , &rpc );
    420408
    421409    // get output arguments from RPC descriptor
    … …  
    470458    rpc.index    = RPC_PMEM_RELEASE_PAGES;
    471459    rpc.response = 1;
     460    rpc.blocking = true;
    472461
    473462    // set input arguments in RPC descriptor
    … …  
    475464
    476465    // register RPC request in remote RPC fifo (blocking function)
    477     rpc_send( cxy , &rpc  , true );
     466    rpc_send( cxy , &rpc );
    478467
    479468rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    … …  
    526515    rpc.index    = RPC_PROCESS_MAKE_EXEC;
    527516    rpc.response = 1;
     517    rpc.blocking = true;
    528518
    529519    // set input arguments in RPC descriptor 
    … …  
    531521
    532522    // register RPC request in remote RPC fifo (blocking function)
    533     rpc_send( cxy , &rpc  , true );
     523    rpc_send( cxy , &rpc );
    534524
    535525    // get output arguments from RPC descriptor
    … …  
    597587    rpc.index    = RPC_PROCESS_MAKE_FORK;
    598588    rpc.response = 1;
     589    rpc.blocking = true;
    599590
    600591    // set input arguments in RPC descriptor 
    … …  
    603594
    604595    // register RPC request in remote RPC fifo (blocking function)
    605     rpc_send( cxy , &rpc  , true );
     596    rpc_send( cxy , &rpc );
    606597
    607598    // get output arguments from RPC descriptor
    … …  
    658649///////////////////////////////////////////////////
    659650void rpc_process_make_exit_client( cxy_t       cxy,
    660                                    process_t * process,
     651                                   pid_t       pid,
    661652                                   uint32_t    status )
    662653{
    … …  
    671662    rpc.index    = RPC_PROCESS_MAKE_EXIT;
    672663    rpc.response = 1;
     664    rpc.blocking = true;
    673665
    674666    // set input arguments in RPC descriptor 
    675     rpc.args[0] = (uint64_t)(intptr_t)process;
     667    rpc.args[0] = (uint64_t)pid;
    676668    rpc.args[1] = (uint64_t)status;
    677669
    678670    // register RPC request in remote RPC fifo (blocking function)
    679     rpc_send( cxy , &rpc , true );
     671    rpc_send( cxy , &rpc );
    680672
    681673rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    … …  
    691683CURRENT_THREAD->core->lid , hal_time_stamp() );
    692684
    693     process_t * process;
    694     uint32_t    status; 
     685    pid_t     pid;
     686    uint32_t  status; 
    695687
    696688    // get client cluster identifier and pointer on RPC descriptor
    … …  
    699691
    700692    // get arguments from RPC descriptor
    701     process = (process_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
    702     status  = (uint32_t)             hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
     693    pid    = (uint32_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
     694    status = (uint32_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
    703695
    704696    // call local kernel function
    705     process_make_exit( process , status );
     697    process_make_exit( pid , status );
    706698
    707699rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    … …  
    716708///////////////////////////////////////////////////
    717709void rpc_process_make_kill_client( cxy_t       cxy,
    718                                    process_t * process,
     710                                   pid_t       pid,
    719711                                   uint32_t    sig_id )
    720712{
    … …  
    729721    rpc.index    = RPC_PROCESS_MAKE_KILL;
    730722    rpc.response = 1;
     723    rpc.blocking = true;
    731724
    732725    // set input arguments in RPC descriptor 
    733     rpc.args[0] = (uint64_t)(intptr_t)process;
     726    rpc.args[0] = (uint64_t)pid;
    734727    rpc.args[1] = (uint64_t)sig_id;
    735728
    736729    // register RPC request in remote RPC fifo (blocking function)
    737     rpc_send( cxy , &rpc , true );
     730    rpc_send( cxy , &rpc );
    738731
    739732rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    … …  
    749742CURRENT_THREAD->core->lid , hal_time_stamp() );
    750743
    751     process_t * process;
     744    pid_t       pid;
    752745    uint32_t    sig_id;
    753746
    … …  
    757750
    758751    // get arguments from RPC descriptor
    759     process = (process_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
    760     sig_id  = (uint32_t)             hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
     752    pid    = (uint32_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
     753    sig_id = (uint32_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
    761754
    762755    // call local kernel function
    763     process_make_exit( process , sig_id );
     756    process_make_exit( pid , sig_id );
    764757
    765758rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    … …  
    791784    rpc.index     = RPC_THREAD_USER_CREATE;
    792785    rpc.response  = 1;
     786    rpc.blocking = true;
    793787
    794788    // set input arguments in RPC descriptor
    … …  
    799793
    800794    // register RPC request in remote RPC fifo (blocking function)
    801     rpc_send( cxy , &rpc , true );
     795    rpc_send( cxy , &rpc );
    802796
    803797    // get output arguments from RPC descriptor
    … …  
    883877    rpc.index    = RPC_THREAD_KERNEL_CREATE;
    884878    rpc.response = 1;
     879    rpc.blocking = true;
    885880
    886881    // set input arguments in RPC descriptor
    … …  
    890885   
    891886    // register RPC request in remote RPC fifo (blocking function)
    892     rpc_send( cxy , &rpc , true );
     887    rpc_send( cxy , &rpc );
    893888
    894889    // get output arguments from RPC descriptor
    … …  
    956951    rpc.index    = RPC_THREAD_KILL;
    957952    rpc.response = 1;
     953    rpc.blocking = true;
    958954
    959955    // set input arguments in RPC descriptor
    … …  
    961957   
    962958    // register RPC request in remote RPC fifo (blocking function)
    963     rpc_send( cxy , &rpc , true );
     959    rpc_send( cxy , &rpc );
    964960
    965961rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    … …  
    997993/////////////////////////////////////////////////////////////////////////////////////////
    998994
    999 ///////////////////////////////////////////////////
    1000 void rpc_process_sigaction_client( cxy_t       cxy,
    1001                                    process_t * process,        // in
    1002                                    uint32_t    sigaction,      // in
    1003                                    xptr_t      rsp_xp,         // in
    1004                                    xptr_t      client_xp )     // in
    1005 {
    1006 sigaction_dmsg("\n[DBG] %s : enter for %s (%d) / thread %x on core[%x,%d] / cycle %d\n",
    1007 __FUNCTION__ , process_action_str( sigaction ) , sigaction , CURRENT_THREAD ,
    1008 local_cxy , CURRENT_THREAD->core->lid , hal_time_stamp() );
    1009 
    1010     // initialise RPC descriptor header
    1011     rpc_desc_t  rpc;
    1012     rpc.index    = RPC_PROCESS_SIGACTION;
    1013 
    1014     // set input arguments in RPC descriptor 
    1015     rpc.args[0] = (uint64_t)(intptr_t)process;
    1016     rpc.args[1] = (uint64_t)sigaction;
    1017     rpc.args[2] = (uint64_t)rsp_xp;
    1018     rpc.args[3] = (uint64_t)client_xp;
    1019 
    1020     // register RPC request in remote RPC fifo (non blocking)
    1021     rpc_send( cxy , &rpc , false );
    1022 
    1023 sigaction_dmsg("\n[DBG] %s : exit for %s (%d) / thread %x on core[%x,%d] / cycle %d\n",
    1024 __FUNCTION__ , process_action_str( sigaction ) , sigaction , CURRENT_THREAD ,
    1025 local_cxy , CURRENT_THREAD->core->lid , hal_time_stamp() );
     995////////////////////////////////////////////////////
     996void rpc_process_sigaction_client( cxy_t        cxy,
     997                                   rpc_desc_t * rpc_ptr )
     998{
     999sigaction_dmsg("\n[DBG] %s : enter to %s process %x in cluster %x / cycle %d\n",
     1000__FUNCTION__ , process_action_str( (uint32_t)rpc_ptr->args[0] ) ,
     1001((process_t *)(intptr_t)rpc_ptr->args[1])->pid , cxy , (uint32_t)hal_get_cycles() );
     1002
     1003    // register RPC request in remote RPC fifo
     1004    rpc_send( cxy , rpc_ptr );
     1005
     1006sigaction_dmsg("\n[DBG] %s : exit after %s process %x in cluster %x / cycle %d\n",
     1007__FUNCTION__ , process_action_str( (uint32_t)rpc_ptr->args[0] ) ,
     1008((process_t *)(intptr_t)rpc_ptr->args[1])->pid , cxy , (uint32_t)hal_get_cycles() );
    10261009} 
    10271010
    … …  
    10291012void rpc_process_sigaction_server( xptr_t xp )
    10301013{
    1031     process_t * process;
    1032     uint32_t    action; 
    1033     xptr_t      rsp_xp;
    1034     xptr_t      client_xp;
    1035 
    1036     // get client cluster identifier and pointer on RPC descriptor
    1037     cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
    1038     rpc_desc_t * desc        = (rpc_desc_t *)GET_PTR( xp );
     1014    process_t  * process;          // pointer on local process descriptor
     1015    uint32_t     action;           // sigaction index
     1016    thread_t   * client_ptr;       // local pointer on client thread in client cluster
     1017    cxy_t        client_cxy;       // client cluster identifier
     1018    xptr_t       client_xp;        // extended pointer on client thread
     1019    core_t     * client_core;      // local pointer on core running the client thread
     1020    rpc_desc_t * rpc;              // local pointer on rpc descriptor in client cluster
     1021
     1022    // get client cluster identifier and pointer on RPC descriptor
     1023    client_cxy = (cxy_t)GET_CXY( xp );
     1024    rpc        = (rpc_desc_t *)GET_PTR( xp );
    10391025
    10401026    // get arguments from RPC descriptor
    1041     process   = (process_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
    1042     action    = (uint32_t)             hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
    1043     rsp_xp    = (xptr_t)               hal_remote_lwd( XPTR( client_cxy , &desc->args[2] ) );
    1044     client_xp = (xptr_t)               hal_remote_lwd( XPTR( client_cxy , &desc->args[3] ) );
    1045    
    1046 sigaction_dmsg("\n[DBG] %s : enter for %s (%d) / thread %x on core[%x,%d] / cycle %d\n",
    1047 __FUNCTION__ , process_action_str( action ) , action , CURRENT_THREAD ,
    1048 local_cxy , CURRENT_THREAD->core->lid , hal_time_stamp() );
     1027    action      = (uint32_t)             hal_remote_lwd( XPTR( client_cxy , &rpc->args[0] ) );
     1028    process     = (process_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &rpc->args[1] ) );
     1029    client_ptr  = (thread_t *)hal_remote_lpt( XPTR( client_cxy , &rpc->thread ) );
     1030
     1031    // build extended pointer on client thread
     1032    client_xp = XPTR( client_cxy , client_ptr );
     1033
     1034sigaction_dmsg("\n[DBG] %s : enter to %s process %x / cycle %d\n",
     1035__FUNCTION__ , process_action_str( action ) , process->pid , (uint32_t)hal_get_cycles() );
    10491036
    10501037    // call relevant kernel function
    1051     if      (action == DELETE_ALL_THREADS  ) process_delete ( process , rsp_xp , client_xp );
    1052     else if (action == BLOCK_ALL_THREADS   ) process_block  ( process , rsp_xp , client_xp );
    1053     else if (action == UNBLOCK_ALL_THREADS ) process_unblock( process , rsp_xp , client_xp );
    1054 
    1055 sigaction_dmsg("\n[DBG] %s : exit for %s (%d) / thread %x on core[%x,%d] / cycle %d\n",
    1056 __FUNCTION__ , process_action_str( action ) , action , CURRENT_THREAD ,
    1057 local_cxy , CURRENT_THREAD->core->lid , hal_time_stamp() );
     1038    if      (action == DELETE_ALL_THREADS  ) process_delete ( process , client_xp );
     1039    else if (action == BLOCK_ALL_THREADS   ) process_block  ( process , client_xp );
     1040    else if (action == UNBLOCK_ALL_THREADS ) process_unblock( process             );
     1041
     1042    // decrement the responses counter in RPC descriptor,
     1043    // unblock the client thread only if it is the last response.
     1044    if( hal_remote_atomic_add( XPTR( client_cxy , &rpc->response ) , -1 ) == 1 )
     1045    {
     1046        client_core = (core_t *)hal_remote_lpt( XPTR( client_cxy , &client_ptr->core ) );
     1047        thread_unblock( client_xp , THREAD_BLOCKED_RPC );
     1048        dev_pic_send_ipi( client_cxy , client_core->lid );
     1049    }
     1050
     1051sigaction_dmsg("\n[DBG] %s : exit after %s process %x / cycle %d\n",
     1052__FUNCTION__ , process_action_str( action ) , process->pid , (uint32_t)hal_get_cycles() );
    10581053}
    10591054
    … …  
    10851080    rpc.index    = RPC_VFS_INODE_CREATE;
    10861081    rpc.response = 1;
     1082    rpc.blocking = true;
    10871083
    10881084    // set input arguments in RPC descriptor
    … …  
    10971093
    10981094    // register RPC request in remote RPC fifo (blocking function)
    1099     rpc_send( cxy , &rpc , true );
     1095    rpc_send( cxy , &rpc );
    11001096
    11011097    // get output values from RPC descriptor
    … …  
    11781174    rpc.index    = RPC_VFS_INODE_DESTROY;
    11791175    rpc.response = 1;
     1176    rpc.blocking = true;
    11801177
    11811178    // set input arguments in RPC descriptor
    … …  
    11831180   
    11841181    // register RPC request in remote RPC fifo (blocking function)
    1185     rpc_send( cxy , &rpc , true );
     1182    rpc_send( cxy , &rpc );
    11861183
    11871184    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    … …  
    12361233    rpc.index    = RPC_VFS_DENTRY_CREATE;
    12371234    rpc.response = 1;
     1235    rpc.blocking = true;
    12381236
    12391237    // set input arguments in RPC descriptor
    … …  
    12431241
    12441242    // register RPC request in remote RPC fifo (blocking function)
    1245     rpc_send( cxy , &rpc , true );
     1243    rpc_send( cxy , &rpc );
    12461244
    12471245    // get output values from RPC descriptor
    … …  
    13151313    rpc.index    = RPC_VFS_DENTRY_DESTROY;
    13161314    rpc.response = 1;
     1315    rpc.blocking = true;
    13171316
    13181317    // set input arguments in RPC descriptor
    … …  
    13201319   
    13211320    // register RPC request in remote RPC fifo (blocking function)
    1322     rpc_send( cxy , &rpc , true );
     1321    rpc_send( cxy , &rpc );
    13231322
    13241323    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    … …  
    13731372    rpc.index    = RPC_VFS_FILE_CREATE;
    13741373    rpc.response = 1;
     1374    rpc.blocking = true;
    13751375
    13761376    // set input arguments in RPC descriptor
    … …  
    13791379
    13801380    // register RPC request in remote RPC fifo (blocking function)
    1381     rpc_send( cxy , &rpc , true );
     1381    rpc_send( cxy , &rpc );
    13821382
    13831383    // get output values from RPC descriptor
    … …  
    14421442    rpc.index    = RPC_VFS_FILE_DESTROY;
    14431443    rpc.response = 1;
     1444    rpc.blocking = true;
    14441445
    14451446    // set input arguments in RPC descriptor
    … …  
    14471448   
    14481449    // register RPC request in remote RPC fifo (blocking function)
    1449     rpc_send( cxy , &rpc , true );
     1450    rpc_send( cxy , &rpc );
    14501451
    14511452    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    … …  
    14991500    rpc.index    = RPC_VFS_INODE_LOAD;
    15001501    rpc.response = 1;
     1502    rpc.blocking = true;
    15011503
    15021504    // set input arguments in RPC descriptor
    … …  
    15061508
    15071509    // register RPC request in remote RPC fifo (blocking function)
    1508     rpc_send( cxy , &rpc , true );
     1510    rpc_send( cxy , &rpc );
    15091511
    15101512    // get output values from RPC descriptor
    … …  
    15731575    rpc.index    = RPC_VFS_MAPPER_LOAD_ALL;
    15741576    rpc.response = 1;
     1577    rpc.blocking = true;
    15751578
    15761579    // set input arguments in RPC descriptor
    … …  
    15781581
    15791582    // register RPC request in remote RPC fifo (blocking function)
    1580     rpc_send( cxy , &rpc , true );
     1583    rpc_send( cxy , &rpc );
    15811584
    15821585    // get output values from RPC descriptor
    … …  
    16381641    rpc.index    = RPC_FATFS_GET_CLUSTER;
    16391642    rpc.response = 1;
     1643    rpc.blocking = true;
    16401644
    16411645    // set input arguments in RPC descriptor
    … …  
    16451649
    16461650    // register RPC request in remote RPC fifo
    1647     rpc_send( cxy , &rpc , true );
     1651    rpc_send( cxy , &rpc );
    16481652
    16491653    // get output argument from rpc descriptor
    … …  
    17111715    rpc.index    = RPC_VMM_GET_VSEG;
    17121716    rpc.response = 1;
     1717    rpc.blocking = true;
    17131718
    17141719    // set input arguments in RPC descriptor
    … …  
    17171722
    17181723    // register RPC request in remote RPC fifo (blocking function)
    1719     rpc_send( cxy , &rpc , true );
     1724    rpc_send( cxy , &rpc );
    17201725
    17211726    // get output argument from rpc descriptor
    … …  
    17861791    rpc.index    = RPC_VMM_GET_PTE;
    17871792    rpc.response = 1;
     1793    rpc.blocking = true;
    17881794
    17891795    // set input arguments in RPC descriptor
    … …  
    17931799
    17941800    // register RPC request in remote RPC fifo (blocking function)
    1795     rpc_send( cxy , &rpc , true );
     1801    rpc_send( cxy , &rpc );
    17961802
    17971803    // get output argument from rpc descriptor
    … …  
    18601866    rpc.index    = RPC_THREAD_USER_CREATE;
    18611867    rpc.response = 1;
     1868    rpc.blocking = true;
    18621869
    18631870    // set input arguments in RPC descriptor
    … …  
    18651872
    18661873    // register RPC request in remote RPC fifo (blocking function)
    1867     rpc_send( cxy , &rpc , true );
     1874    rpc_send( cxy , &rpc );
    18681875
    18691876    // get output arguments from RPC descriptor
    … …  
    19231930    rpc.index    = RPC_THREAD_USER_CREATE;
    19241931    rpc.response = 1;
     1932    rpc.blocking = true;
    19251933
    19261934    // set input arguments in RPC descriptor
    … …  
    19291937
    19301938    // register RPC request in remote RPC fifo (blocking function)
    1931     rpc_send( cxy , &rpc , true );
     1939    rpc_send( cxy , &rpc );
    19321940
    19331941    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    … …  
    19861994    rpc.index    = RPC_MAPPER_MOVE_BUFFER;
    19871995    rpc.response = 1;
     1996    rpc.blocking = true;
    19881997
    19891998    // set input arguments in RPC descriptor
    … …  
    19962005
    19972006    // register RPC request in remote RPC fifo (blocking function)
    1998     rpc_send( cxy , &rpc , true );
     2007    rpc_send( cxy , &rpc );
    19992008
    20002009    // get output values from RPC descriptor
    … …  
    20832092    rpc.index    = RPC_MAPPER_GET_PAGE;
    20842093    rpc.response = 1;
     2094    rpc.blocking = true;
    20852095
    20862096    // set input arguments in RPC descriptor
    … …  
    20892099
    20902100    // register RPC request in remote RPC fifo (blocking function)
    2091     rpc_send( cxy , &rpc , true );
     2101    rpc_send( cxy , &rpc );
    20922102
    20932103    // get output values from RPC descriptor
    … …  
    21512161    rpc.index    = RPC_VMM_CREATE_VSEG;
    21522162    rpc.response = 1;
     2163    rpc.blocking = true;
    21532164
    21542165    // set input arguments in RPC descriptor
    … …  
    21632174
    21642175    // register RPC request in remote RPC fifo (blocking function)
    2165     rpc_send( cxy , &rpc , true );
     2176    rpc_send( cxy , &rpc );
    21662177
    21672178    // get output values from RPC descriptor
    … …  
    22302241    rpc.index    = RPC_SCHED_DISPLAY;
    22312242    rpc.response = 1;
     2243    rpc.blocking = true;
    22322244
    22332245    // set input arguments in RPC descriptor
    … …  
    22352247
    22362248    // register RPC request in remote RPC fifo (blocking function)
    2237     rpc_send( cxy , &rpc , true );
     2249    rpc_send( cxy , &rpc );
    22382250
    22392251    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
    … …  
    22822294    rpc.index    = RPC_VMM_SET_COW;
    22832295    rpc.response = 1;
     2296    rpc.blocking = true;
    22842297
    22852298    // set input arguments in RPC descriptor
    … …  
    22872300
    22882301    // register RPC request in remote RPC fifo (blocking function)
    2289     rpc_send( cxy , &rpc , true );
     2302    rpc_send( cxy , &rpc );
    22902303
    22912304    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
Note: See TracChangeset for help on using the changeset viewer.