source: trunk/kernel/kern/rpc.c @ 315

Last change on this file since 315 was 315, checked in by alain, 5 years ago

Redefine the fuctions ppm_base2page() / ppm_page2base() / ppm_page2ppn() / ppm_ppn2page() / ppm_base2ppn() / ppm_ppn2base(),
to use explicitely extended pointers.

File size: 67.8 KB
Line 
1/*
2 * rpc.c - RPC related operations implementation.
3 *
4 * Author    Alain Greiner (2016,2017)
5 *
6 * Copyright (c)  UPMC Sorbonne Universites
7 *
8 * This file is part of ALMOS-MKH.
9 *
10 * ALMOS-MKH is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; version 2.0 of the License.
13 *
14 * ALMOS-MKH is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17 * General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with ALMOS-MKH; if not, write to the Free Software Foundation,
21 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22 */
23
24#include <kernel_config.h>
25#include <hal_types.h>
26#include <hal_atomic.h>
27#include <hal_remote.h>
28#include <hal_irqmask.h>
29#include <hal_special.h>
30#include <printk.h>
31#include <remote_sem.h>
32#include <core.h>
33#include <mapper.h>
34#include <chdev.h>
35#include <bits.h>
36#include <thread.h>
37#include <cluster.h>
38#include <process.h>
39#include <vfs.h>
40#include <fatfs.h>
41#include <signal.h>
42#include <rpc.h>
43
44/////////////////////////////////////////////////////////////////////////////////////////
45//      array of function pointers  (must be consistent with enum in rpc.h)
46/////////////////////////////////////////////////////////////////////////////////////////
47
48rpc_server_t * rpc_server[RPC_MAX_INDEX] =
49{
50    &rpc_pmem_get_pages_server,         // 0
51    &rpc_process_pid_alloc_server,      // 1
52    &rpc_process_exec_server,           // 2
53    &rpc_process_kill_server,           // 3
54    &rpc_thread_user_create_server,     // 4
55    &rpc_thread_kernel_create_server,   // 5
56    &rpc_signal_rise_server,            // 6                       
57    &rpc_undefined,                     // 7
58    &rpc_undefined,                     // 8
59    &rpc_undefined,                     // 9
60
61    &rpc_vfs_inode_create_server,       // 10 
62    &rpc_vfs_inode_destroy_server,      // 11 
63    &rpc_vfs_dentry_create_server,      // 12 
64    &rpc_vfs_dentry_destroy_server,     // 13 
65    &rpc_vfs_file_create_server,        // 14
66    &rpc_vfs_file_destroy_server,       // 15
67    &rpc_vfs_inode_load_server,         // 16
68    &rpc_vfs_mapper_load_all_server,    // 17
69    &rpc_fatfs_get_cluster_server,      // 18
70    &rpc_undefined,                     // 19
71
72    &rpc_vmm_get_ref_vseg_server,       // 20
73    &rpc_vmm_get_pte_server,            // 21
74    &rpc_kcm_alloc_server,              // 22
75    &rpc_kcm_free_server,               // 23
76    &rpc_mapper_move_buffer_server,     // 24
77    &rpc_mapper_get_page_server,        // 25
78    &rpc_undefined,                     // 26
79    &rpc_undefined,                     // 27
80    &rpc_undefined,                     // 28
81    &rpc_undefined,                     // 29
82};
83
84//////////////////////////////////////////////
85void __attribute__((noinline)) rpc_undefined()
86{
87    printk("\n[PANIC] ‰s called in cluster %x\n", __FUNCTION__ , local_cxy );
88    hal_core_sleep();
89}
90
91/////////////////////////////////////////////////////////////////////////////////////////
92// [0]           Marshaling functions attached to RPC_PMEM_GET_PAGES
93/////////////////////////////////////////////////////////////////////////////////////////
94
95///////////////////////////////////////////////
96void rpc_pmem_get_pages_client( cxy_t      cxy,
97                                uint32_t   order,      // in
98                                page_t  ** page )      // out
99{
100    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
101
102    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
103
104    // initialise RPC descriptor header
105    rpc_desc_t  rpc;
106    rpc.index    = RPC_PMEM_GET_PAGES;
107    rpc.response = 1;
108
109    // set input arguments in RPC descriptor
110    rpc.args[0] = (uint64_t)order;
111
112    // register RPC request in remote RPC fifo (blocking function)
113    rpc_send_sync( cxy , &rpc );
114
115    // get output arguments from RPC descriptor
116    *page    = (page_t *)(intptr_t)rpc.args[1];
117
118    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
119}
120
121///////////////////////////////////////////
122void rpc_pmem_get_pages_server( xptr_t xp )
123{
124    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
125
126    // get client cluster identifier and pointer on RPC descriptor
127    cxy_t        cxy  = (cxy_t)GET_CXY( xp );
128    rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
129
130    // get input arguments from client RPC descriptor
131    uint32_t order = hal_remote_lw( XPTR( cxy , &desc->args[0] ) );
132   
133    // call local pmem allocator
134    page_t * page = ppm_alloc_pages( order ); 
135
136    // set output arguments into client RPC descriptor
137    hal_remote_swd( XPTR( cxy , &desc->args[1] ) , (uint64_t)(intptr_t)page );
138
139    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
140}
141
142/////////////////////////////////////////////////////////////////////////////////////////
143// [1]           Marshaling functions attached to RPC_PROCESS_PID_ALLOC
144/////////////////////////////////////////////////////////////////////////////////////////
145
146//////////////////////////////////////////////////
147void rpc_process_pid_alloc_client( cxy_t       cxy, 
148                                   process_t * process,  // in
149                                   error_t   * error,    // out
150                                   pid_t     * pid )     // out
151{
152    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
153
154    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
155
156    // initialise RPC descriptor header
157    rpc_desc_t  rpc;
158    rpc.index    = RPC_PROCESS_PID_ALLOC;
159    rpc.response = 1;
160
161    // set input arguments in RPC descriptor
162    rpc.args[0] = (uint64_t)(intptr_t)process;
163
164    // register RPC request in remote RPC fifo (blocking function)
165    rpc_send_sync( cxy , &rpc );
166
167    // get output arguments RPC descriptor
168    *pid    = (pid_t)rpc.args[1];
169    *error  = (error_t)rpc.args[2];     
170
171    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
172}
173
174//////////////////////////////////////////////
175void rpc_process_pid_alloc_server( xptr_t xp )
176{
177    process_t * process;   // input  : client process descriptor
178    error_t     error;     // output : error status
179    pid_t       pid;       // output : process identifier
180
181    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
182
183    // get client cluster identifier and pointer on RPC descriptor
184    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
185    rpc_desc_t * desc        = (rpc_desc_t *)GET_PTR( xp );
186
187    // get input argument from client RPC descriptor
188    process = (process_t*)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
189   
190    // call local pid allocator
191    xptr_t xp_process = XPTR( client_cxy , process );
192    error = cluster_pid_alloc( xp_process , &pid ); 
193
194    // set output arguments into client RPC descriptor
195    hal_remote_sw( XPTR( client_cxy , &desc->args[0] ) , (uint64_t)error );
196    hal_remote_sw( XPTR( client_cxy , &desc->args[1] ) , (uint64_t)pid );
197
198    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
199}
200
201
202/////////////////////////////////////////////////////////////////////////////////////////
203// [2]           Marshaling functions attached to RPC_PROCESS_EXEC
204/////////////////////////////////////////////////////////////////////////////////////////
205
206////////////////////////////////////////////////
207void rpc_process_exec_client( cxy_t         cxy,
208                              exec_info_t * info,     // in
209                              error_t     * error )   // out
210{
211    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
212
213    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
214
215    // initialise RPC descriptor header
216    rpc_desc_t  rpc;
217    rpc.index    = RPC_PROCESS_EXEC;
218    rpc.response = 1;
219
220    // set input arguments in RPC descriptor 
221    rpc.args[0] = (uint64_t)(intptr_t)info;
222
223    // register RPC request in remote RPC fifo (blocking function)
224    rpc_send_sync( cxy , &rpc );
225
226    // get output arguments from RPC descriptor
227    *error  = (error_t)rpc.args[1];     
228
229    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
230}
231
232/////////////////////////////////////////
233void rpc_process_exec_server( xptr_t xp )
234{
235    exec_info_t * ptr;       // local pointer on remote exec_info structure
236    exec_info_t   info;      // local copy of exec_info structure
237    error_t       error;     // local error error status
238
239    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
240
241    // get client cluster identifier and pointer on RPC descriptor
242    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
243    rpc_desc_t * desc        = (rpc_desc_t *)GET_PTR( xp );
244
245    // get pointer on exec_info structure in client cluster from RPC descriptor
246    ptr = (exec_info_t*)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
247
248    // copy exec_info structure from client buffer to server buffer
249    hal_remote_memcpy( XPTR( client_cxy , ptr ),
250                       XPTR( local_cxy , &info ),
251                       sizeof(exec_info_t) );
252
253    // call local kernel function
254    error = process_make_exec( &info ); 
255
256    // set output argument into client RPC descriptor
257    hal_remote_swd( XPTR( client_cxy , &desc->args[1] ) , (uint64_t)error );
258
259    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
260}
261
262
263/////////////////////////////////////////////////////////////////////////////////////////
264// [3]           Marshaling functions attached to RPC_PROCESS_KILL
265/////////////////////////////////////////////////////////////////////////////////////////
266
267///////////////////////////////////////////////////
268void rpc_process_kill_client( process_t * process ) 
269{
270    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
271
272    // only reference cluster can send this RPC
273    assert( (GET_CXY( process->ref_xp ) == local_cxy) , __FUNCTION__ ,
274            "caller must be reference process cluster\n");
275
276    // get local process index in reference cluster
277    lpid_t lpid = LPID_FROM_PID( process->pid );
278
279    // get local process manager pointer
280    pmgr_t * pmgr = &LOCAL_CLUSTER->pmgr;
281
282    // get number of copies
283    uint32_t copies = pmgr->copies_nr[lpid];
284
285    // initialise RPC descriptor
286    rpc_desc_t  rpc;
287    rpc.index    = RPC_PROCESS_KILL;
288    rpc.response = copies;
289    rpc.args[0]  = (uint64_t)process->pid;
290
291    // loop on list of copies to send RPC
292    xptr_t  iter;
293    XLIST_FOREACH( XPTR( local_cxy , &pmgr->copies_root[lpid] ) , iter )
294    {
295        // get cluster_identifier for current copy
296        cxy_t  target_cxy = GET_CXY( iter );
297
298        // register RPC request in remote RPC fifo ... but the reference
299        if( target_cxy != local_cxy ) rpc_send_sync( target_cxy , &rpc );
300    }
301
302    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
303} 
304
305/////////////////////////////////////////
306void rpc_process_kill_server( xptr_t xp )
307{
308    pid_t       pid;
309    process_t * process; 
310
311    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
312
313    // get client cluster identifier and pointer on RPC descriptor
314    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
315    rpc_desc_t * desc        = (rpc_desc_t *)GET_PTR( xp );
316
317    // get pid argument from RPC descriptor
318    pid = (pid_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
319
320    // get process pointer to call local kernel function
321    process = cluster_get_local_process_from_pid( pid );
322
323    if( process == NULL )  // process not found => do nothing
324    {
325        printk("\n[WARNING] in %s : process %x not found in cluster %x\n",
326               __FUNCTION__ , pid , local_cxy );
327    }
328    else                   // destroy process
329    {
330        process_kill( process ); 
331    }
332
333    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
334} 
335
336
337/////////////////////////////////////////////////////////////////////////////////////////
338// [4]           Marshaling functions attached to RPC_THREAD_USER_CREATE               
339/////////////////////////////////////////////////////////////////////////////////////////
340
341/////////////////////////////////////////////////////////
342void rpc_thread_user_create_client( cxy_t            cxy, 
343                                    pid_t            pid,         // in
344                                    void           * start_func,  // in
345                                    void           * start_arg,   // in
346                                    pthread_attr_t * attr,        // in
347                                    xptr_t         * thread_xp,   // out
348                                    error_t        * error )      // out
349{
350    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
351
352    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
353
354    // initialise RPC descriptor header
355    rpc_desc_t  rpc;
356    rpc.index    = RPC_THREAD_USER_CREATE;
357    rpc.response = 1;
358
359    // set input arguments in RPC descriptor
360    rpc.args[0] = (uint64_t)pid;
361    rpc.args[1] = (uint64_t)(intptr_t)start_func;
362    rpc.args[2] = (uint64_t)(intptr_t)start_arg;
363    rpc.args[3] = (uint64_t)(intptr_t)attr;
364
365    // register RPC request in remote RPC fifo
366    rpc_send_sync( cxy , &rpc );
367
368    // get output arguments from RPC descriptor
369    *thread_xp = (xptr_t)rpc.args[4];
370    *error     = (error_t)rpc.args[5];
371
372    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
373}
374
375///////////////////////////////////////////////
376void rpc_thread_user_create_server( xptr_t xp )
377{
378    pthread_attr_t * attr_ptr;   // pointer on attributes structure in client cluster
379    pthread_attr_t   attr_copy;  // attributes structure  copy in server cluster
380    thread_t       * thread_ptr; // local pointer on thread descriptor
381    xptr_t           thread_xp;  // extended pointer on thread descriptor
382
383    pid_t            pid;        // process identifier
384    void           * start_func;
385    void           * start_arg;
386    error_t          error;
387
388    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
389
390    // get client cluster identifier and pointer on RPC descriptor
391    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
392    rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
393
394    // get pointer on attributes structure in client cluster from RPC descriptor
395
396    // get input arguments from RPC descriptor
397    pid        = (pid_t)                     hal_remote_lwd(XPTR(client_cxy , &desc->args[0]));
398    start_func = (void *)(intptr_t)          hal_remote_lwd(XPTR(client_cxy , &desc->args[1]));
399    start_arg  = (void *)(intptr_t)          hal_remote_lwd(XPTR(client_cxy , &desc->args[2]));
400    attr_ptr   = (pthread_attr_t *)(intptr_t)hal_remote_lwd(XPTR(client_cxy , &desc->args[3]));
401
402    // makes a local copy of attributes structure
403    hal_remote_memcpy( XPTR( local_cxy , &attr_copy ),
404                       XPTR( client_cxy , attr_ptr ), 
405                       sizeof(pthread_attr_t) );
406   
407    assert( (attr_copy.cxy == local_cxy) , __FUNCTION__ , "bad target cluster\n" );
408
409    // call kernel function
410    error = thread_user_create( pid,
411                                start_func,
412                                start_arg,
413                                &attr_copy,
414                                &thread_ptr );
415
416    // set output arguments
417    thread_xp = XPTR( local_cxy , thread_ptr );
418    hal_remote_swd( XPTR( client_cxy , &desc->args[1] ) , (uint64_t)error );
419    hal_remote_swd( XPTR( client_cxy , &desc->args[2] ) , (uint64_t)thread_xp );
420
421    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
422}
423
424/////////////////////////////////////////////////////////////////////////////////////////
425// [5]           Marshaling functions attached to RPC_THREAD_KERNEL_CREATE
426/////////////////////////////////////////////////////////////////////////////////////////
427
428////////////////////////////////////////////////////
429void rpc_thread_kernel_create_client( cxy_t     cxy,
430                                      uint32_t  type,        // in
431                                      void    * func,        // in
432                                      void    * args,        // in
433                                      xptr_t  * thread_xp,   // out
434                                      error_t * error )      // out
435{
436    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
437
438    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
439
440    // initialise RPC descriptor header
441    rpc_desc_t  rpc;
442    rpc.index    = RPC_THREAD_KERNEL_CREATE;
443    rpc.response = 1;
444
445    // set input arguments in RPC descriptor
446    rpc.args[0] = (uint64_t)type;
447    rpc.args[1] = (uint64_t)(intptr_t)func;
448    rpc.args[2] = (uint64_t)(intptr_t)args;
449   
450    // register RPC request in remote RPC fifo
451    rpc_send_sync( cxy , &rpc );
452
453    // get output arguments from RPC descriptor
454    *thread_xp = (xptr_t)rpc.args[3];
455    *error     = (error_t)rpc.args[4];
456
457    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
458}
459
460/////////////////////////////////////////////////
461void rpc_thread_kernel_create_server( xptr_t xp )
462{
463    thread_t       * thread_ptr;  // local pointer on thread descriptor
464    xptr_t           thread_xp;   // extended pointer on thread descriptor
465    lid_t            core_lid;    // core local index
466    error_t          error;   
467
468    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
469
470    // get client cluster identifier and pointer on RPC descriptor
471    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
472    rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
473
474    // get attributes from RPC descriptor
475    uint32_t  type = (uint32_t)       hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
476    void    * func = (void*)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
477    void    * args = (void*)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[2] ) );
478
479    // select one core
480    core_lid = cluster_select_local_core();
481
482    // call local kernel function
483    error = thread_kernel_create( &thread_ptr , type , func , args , core_lid );
484
485    // set output arguments
486    thread_xp = XPTR( local_cxy , thread_ptr );
487    hal_remote_swd( XPTR( client_cxy , &desc->args[1] ) , (uint64_t)error );
488    hal_remote_swd( XPTR( client_cxy , &desc->args[2] ) , (uint64_t)thread_xp );
489
490    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
491}
492
493/////////////////////////////////////////////////////////////////////////////////////////
494// [6]           Marshaling functions attached to RPC_SIGNAL_RISE
495/////////////////////////////////////////////////////////////////////////////////////////
496
497/////////////////////////////////////////////
498void rpc_signal_rise_client( cxy_t       cxy,
499                             process_t * process,    // in
500                             uint32_t    sig_id )    // in
501{
502    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
503
504    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
505
506    // initialise RPC descriptor header
507    rpc_desc_t  rpc;
508    rpc.index    = RPC_SIGNAL_RISE;
509    rpc.response = 1;
510
511    // set input arguments in RPC descriptor
512    rpc.args[0] = (uint64_t)(intptr_t)process;
513    rpc.args[1] = (uint64_t)sig_id;
514   
515    // register RPC request in remote RPC fifo
516    rpc_send_sync( cxy , &rpc );
517
518    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
519}
520
521////////////////////////////////////////                             
522void rpc_signal_rise_server( xptr_t xp )
523{
524    process_t  * process;  // local pointer on process descriptor
525    uint32_t     sig_id;   // signal index
526
527    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
528
529    // get client cluster identifier and pointer on RPC descriptor
530    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
531    rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
532
533    // get attributes from RPC descriptor
534    process = (process_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
535    sig_id  = (uint32_t)             hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
536
537    // call local kernel function
538    signal_rise( process , sig_id );
539
540    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
541}
542
543/////////////////////////////////////////////////////////////////////////////////////////
544// [10]          Marshaling functions attached to RPC_VFS_INODE_CREATE
545/////////////////////////////////////////////////////////////////////////////////////////
546
547/////////////////////////////////////////////////////
548void rpc_vfs_inode_create_client( cxy_t          cxy,     
549                                  xptr_t         dentry_xp,  // in
550                                  uint32_t       fs_type,    // in
551                                  uint32_t       inode_type, // in
552                                  void         * extend,     // in
553                                  uint32_t       attr,       // in
554                                  uint32_t       rights,     // in
555                                  uint32_t       uid,        // in
556                                  uint32_t       gid,        // in
557                                  xptr_t       * inode_xp,   // out
558                                  error_t      * error )     // out
559{
560    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
561
562    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
563
564    // initialise RPC descriptor header
565    rpc_desc_t  rpc;
566    rpc.index    = RPC_VFS_INODE_CREATE;
567    rpc.response = 1;
568
569    // set input arguments in RPC descriptor
570    rpc.args[0] = (uint64_t)dentry_xp;
571    rpc.args[1] = (uint64_t)fs_type;
572    rpc.args[2] = (uint64_t)inode_type;
573    rpc.args[3] = (uint64_t)(intptr_t)extend;
574    rpc.args[4] = (uint64_t)attr;
575    rpc.args[5] = (uint64_t)rights;
576    rpc.args[6] = (uint64_t)uid;
577    rpc.args[7] = (uint64_t)gid;
578
579    // register RPC request in remote RPC fifo (blocking function)
580    rpc_send_sync( cxy , &rpc );
581
582    // get output values from RPC descriptor
583    *inode_xp = (xptr_t)rpc.args[8];
584    *error    = (error_t)rpc.args[9];
585
586    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
587}
588
589/////////////////////////////////////////////
590void rpc_vfs_inode_create_server( xptr_t xp )
591{
592    xptr_t           dentry_xp;
593    uint32_t         fs_type;
594    uint32_t         inode_type;
595    void           * extend;
596    uint32_t         attr;
597    uint32_t         rights;
598    uint32_t         uid;
599    uint32_t         gid;
600    xptr_t           inode_xp;
601    error_t          error;
602
603    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
604
605    // get client cluster identifier and pointer on RPC descriptor
606    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
607    rpc_desc_t * desc        = (rpc_desc_t *)GET_PTR( xp );
608
609    // get input arguments from client rpc descriptor
610    dentry_xp  = (xptr_t)          hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
611    fs_type    = (uint32_t)        hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
612    inode_type = (uint32_t)        hal_remote_lwd( XPTR( client_cxy , &desc->args[2] ) );
613    extend     = (void *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[3] ) );
614    attr       = (uint32_t)        hal_remote_lwd( XPTR( client_cxy , &desc->args[4] ) );
615    rights     = (uint32_t)        hal_remote_lwd( XPTR( client_cxy , &desc->args[5] ) );
616    uid        = (uid_t)           hal_remote_lwd( XPTR( client_cxy , &desc->args[6] ) );
617    gid        = (gid_t)           hal_remote_lwd( XPTR( client_cxy , &desc->args[7] ) );
618
619    // call local kernel function
620    error = vfs_inode_create( dentry_xp,
621                              fs_type,
622                              inode_type,
623                              extend,
624                              attr,
625                              rights,
626                              uid,
627                              gid,
628                              &inode_xp );
629
630    // set output arguments
631    hal_remote_swd( XPTR( client_cxy , &desc->args[8] ) , (uint64_t)inode_xp );
632    hal_remote_swd( XPTR( client_cxy , &desc->args[9] ) , (uint64_t)error );
633
634    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
635}
636
637/////////////////////////////////////////////////////////////////////////////////////////
638// [11]          Marshaling functions attached to RPC_VFS_INODE_DESTROY
639/////////////////////////////////////////////////////////////////////////////////////////
640
641/////////////////////////////////////////////////////////////
642void rpc_vfs_inode_destroy_client( cxy_t                cxy,
643                                   struct vfs_inode_s * inode )
644{
645    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
646
647    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
648
649    // initialise RPC descriptor header
650    rpc_desc_t  rpc;
651    rpc.index    = RPC_VFS_INODE_DESTROY;
652    rpc.response = 1;
653
654    // set input arguments in RPC descriptor
655    rpc.args[0] = (uint64_t)(intptr_t)inode;
656   
657    // register RPC request in remote RPC fifo (blocking function)
658    rpc_send_sync( cxy , &rpc );
659
660    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
661}
662
663//////////////////////////////////////////////
664void rpc_vfs_inode_destroy_server( xptr_t xp )
665{
666    vfs_inode_t * inode;
667
668    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
669
670    // get client cluster identifier and pointer on RPC descriptor
671    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
672    rpc_desc_t * desc        = (rpc_desc_t *)GET_PTR( xp );
673
674    // get arguments "inode" from client RPC descriptor
675    inode = (vfs_inode_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
676                       
677    // call local kernel function
678    vfs_inode_destroy( inode );
679
680    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
681}
682
683/////////////////////////////////////////////////////////////////////////////////////////
684// [12]          Marshaling functions attached to RPC_VFS_DENTRY_CREATE
685/////////////////////////////////////////////////////////////////////////////////////////
686
687//////////////////////////////////////////////////////////////
688void rpc_vfs_dentry_create_client( cxy_t                  cxy,
689                                   uint32_t               type,         // in
690                                   char                 * name,         // in
691                                   struct vfs_inode_s   * parent,       // in
692                                   xptr_t               * dentry_xp,    // out
693                                   error_t              * error )       // out
694{
695    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
696
697    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
698
699    // initialise RPC descriptor header
700    rpc_desc_t  rpc;
701    rpc.index    = RPC_VFS_DENTRY_CREATE;
702    rpc.response = 1;
703
704    // set input arguments in RPC descriptor
705    rpc.args[0] = (uint64_t)type;
706    rpc.args[1] = (uint64_t)(intptr_t)name;
707    rpc.args[2] = (uint64_t)(intptr_t)parent;
708
709    // register RPC request in remote RPC fifo (blocking function)
710    rpc_send_sync( cxy , &rpc );
711
712    // get output values from RPC descriptor
713    *dentry_xp = (xptr_t)rpc.args[3];
714    *error     = (error_t)rpc.args[4];
715
716    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
717}
718
719//////////////////////////////////////////////
720void rpc_vfs_dentry_create_server( xptr_t xp )
721{
722    uint32_t      type;
723    char        * name;
724    vfs_inode_t * parent;
725    xptr_t        dentry_xp;
726    error_t       error;
727
728    char          name_copy[CONFIG_VFS_MAX_NAME_LENGTH];
729
730    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
731
732    // get client cluster identifier and pointer on RPC descriptor
733    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
734    rpc_desc_t * desc        = (rpc_desc_t *)GET_PTR( xp );
735
736    // get arguments "name", "type", and "parent" from client RPC descriptor
737    type   = (uint32_t)               hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
738    name   = (char *)(intptr_t)       hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
739    parent = (vfs_inode_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[2] ) );
740
741    // makes a local copy of  name
742    hal_remote_strcpy( XPTR( local_cxy , name_copy ),
743                       XPTR( client_cxy , name ) );
744
745    // call local kernel function
746    error = vfs_dentry_create( type,
747                               name_copy,
748                               parent,
749                               &dentry_xp );
750    // set output arguments
751    hal_remote_swd( XPTR( client_cxy , &desc->args[3] ) , (uint64_t)dentry_xp );
752    hal_remote_swd( XPTR( client_cxy , &desc->args[4] ) , (uint64_t)error );
753
754    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
755}
756
757/////////////////////////////////////////////////////////////////////////////////////////
758// [13]          Marshaling functions attached to RPC_VFS_DENTRY_DESTROY
759/////////////////////////////////////////////////////////////////////////////////////////
760
761
762///////////////////////////////////////////////////////
763void rpc_vfs_dentry_destroy_client( cxy_t          cxy,
764                                    vfs_dentry_t * dentry )
765{
766    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
767
768    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
769
770    // initialise RPC descriptor header
771    rpc_desc_t  rpc;
772    rpc.index    = RPC_VFS_DENTRY_DESTROY;
773    rpc.response = 1;
774
775    // set input arguments in RPC descriptor
776    rpc.args[0] = (uint64_t)(intptr_t)dentry;
777   
778    // register RPC request in remote RPC fifo (blocking function)
779    rpc_send_sync( cxy , &rpc );
780
781    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
782}
783
784///////////////////////////////////////////////
785void rpc_vfs_dentry_destroy_server( xptr_t xp )
786{
787    vfs_dentry_t * dentry;
788
789    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
790
791    // get client cluster identifier and pointer on RPC descriptor
792    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
793    rpc_desc_t * desc        = (rpc_desc_t *)GET_PTR( xp );
794
795    // get arguments "dentry" from client RPC descriptor
796    dentry = (vfs_dentry_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
797                       
798    // call local kernel function
799    vfs_dentry_destroy( dentry );
800
801    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
802}
803
804
805/////////////////////////////////////////////////////////////////////////////////////////
806// [14]          Marshaling functions attached to RPC_VFS_FILE_CREATE
807/////////////////////////////////////////////////////////////////////////////////////////
808
809//////////////////////////////////////////////////////////////
810void rpc_vfs_file_create_client( cxy_t                  cxy,
811                                 struct vfs_inode_s   * inode,       // in
812                                 uint32_t               file_attr,   // in
813                                 xptr_t               * file_xp,     // out
814                                 error_t              * error )      // out
815{
816    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
817
818    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
819
820    // initialise RPC descriptor header
821    rpc_desc_t  rpc;
822    rpc.index    = RPC_VFS_FILE_CREATE;
823    rpc.response = 1;
824
825    // set input arguments in RPC descriptor
826    rpc.args[0] = (uint64_t)(intptr_t)inode;
827    rpc.args[1] = (uint64_t)file_attr;
828
829    // register RPC request in remote RPC fifo (blocking function)
830    rpc_send_sync( cxy , &rpc );
831
832    // get output values from RPC descriptor
833    *file_xp = (xptr_t)rpc.args[2];
834    *error   = (error_t)rpc.args[3];
835
836    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
837}
838
839////////////////////////////////////////////
840void rpc_vfs_file_create_server( xptr_t xp )
841{
842    uint32_t      file_attr;
843    vfs_inode_t * inode;
844    xptr_t        file_xp;
845    error_t       error;
846
847    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
848
849    // get client cluster identifier and pointer on RPC descriptor
850    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
851    rpc_desc_t * desc        = (rpc_desc_t *)GET_PTR( xp );
852
853    // get arguments "file_attr" and "inode" from client RPC descriptor
854    inode     = (vfs_inode_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
855    file_attr = (uint32_t)               hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
856                       
857    // call local kernel function
858    error = vfs_file_create( inode,
859                             file_attr,
860                             &file_xp );
861 
862    // set output arguments
863    hal_remote_swd( XPTR( client_cxy , &desc->args[2] ) , (uint64_t)file_xp );
864    hal_remote_swd( XPTR( client_cxy , &desc->args[3] ) , (uint64_t)error );
865
866    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
867}
868
869/////////////////////////////////////////////////////////////////////////////////////////
870// [15]          Marshaling functions attached to RPC_VFS_FILE_DESTROY
871/////////////////////////////////////////////////////////////////////////////////////////
872
873///////////////////////////////////////////////////
874void rpc_vfs_file_destroy_client( cxy_t        cxy,
875                                  vfs_file_t * file )
876{
877    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
878
879    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
880
881    // initialise RPC descriptor header
882    rpc_desc_t  rpc;
883    rpc.index    = RPC_VFS_FILE_DESTROY;
884    rpc.response = 1;
885
886    // set input arguments in RPC descriptor
887    rpc.args[0] = (uint64_t)(intptr_t)file;
888   
889    // register RPC request in remote RPC fifo (blocking function)
890    rpc_send_sync( cxy , &rpc );
891
892    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
893}
894
895/////////////////////////////////////////////
896void rpc_vfs_file_destroy_server( xptr_t xp )
897{
898    vfs_file_t * file;
899
900    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
901
902    // get client cluster identifier and pointer on RPC descriptor
903    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
904    rpc_desc_t * desc        = (rpc_desc_t *)GET_PTR( xp );
905
906    // get arguments "dentry" from client RPC descriptor
907    file = (vfs_file_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
908                       
909    // call local kernel function
910    vfs_file_destroy( file );
911
912    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
913}
914
915/////////////////////////////////////////////////////////////////////////////////////////
916// [16]          Marshaling functions attached to RPC_VFS_INODE_LOAD 
917/////////////////////////////////////////////////////////////////////////////////////////
918
919//////////////////////////////////////////////////
920void rpc_vfs_inode_load_client( cxy_t         cxy,
921                                vfs_inode_t * parent_inode,    // in
922                                char        * name,            // in
923                                xptr_t        child_inode_xp,  // in
924                                error_t     * error )          // out
925{
926    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
927
928    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
929
930    // initialise RPC descriptor header
931    rpc_desc_t  rpc;
932    rpc.index    = RPC_VFS_INODE_LOAD;
933    rpc.response = 1;
934
935    // set input arguments in RPC descriptor
936    rpc.args[0] = (uint64_t)(intptr_t)parent_inode;
937    rpc.args[1] = (uint64_t)(intptr_t)name;
938    rpc.args[2] = (uint64_t)child_inode_xp;
939
940    // register RPC request in remote RPC fifo (blocking function)
941    rpc_send_sync( cxy , &rpc );
942
943    // get output values from RPC descriptor
944    *error   = (error_t)rpc.args[3];
945
946    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
947}
948
949///////////////////////////////////////////
950void rpc_vfs_inode_load_server( xptr_t xp )
951{
952    error_t       error;
953    vfs_inode_t * parent;
954    xptr_t        child_xp;
955    char        * name;
956
957    char          name_copy[CONFIG_VFS_MAX_NAME_LENGTH];
958
959    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
960
961    // get client cluster identifier and pointer on RPC descriptor
962    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
963    rpc_desc_t * desc        = (rpc_desc_t *)GET_PTR( xp );
964
965    // get arguments "parent", "name", and "child_xp"
966    parent     = (vfs_inode_t*)(intptr_t)hal_remote_lwd(XPTR(client_cxy , &desc->args[0]));
967    name       = (char*)(intptr_t)       hal_remote_lwd(XPTR(client_cxy , &desc->args[1]));
968    child_xp   = (xptr_t)                hal_remote_lwd(XPTR(client_cxy , &desc->args[2]));
969
970    // get name local copy
971    hal_remote_strcpy( XPTR( local_cxy , name_copy ) ,
972                       XPTR( client_cxy , name ) );
973
974    // call the kernel function
975    error = vfs_inode_load( parent , name_copy , child_xp );
976
977    // set output argument
978    hal_remote_swd( XPTR( client_cxy , &desc->args[3] ) , (uint64_t)error );
979
980    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
981}
982
983/////////////////////////////////////////////////////////////////////////////////////////
984// [17]          Marshaling functions attached to RPC_VFS_MAPPER_LOAD_ALL
985/////////////////////////////////////////////////////////////////////////////////////////
986
987///////////////////////////////////////////////////////
988void rpc_vfs_mapper_load_all_client( cxy_t         cxy,
989                                     vfs_inode_t * inode,      // in
990                                     error_t     * error )     // out
991{
992    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
993
994    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
995
996    // initialise RPC descriptor header
997    rpc_desc_t  rpc;
998    rpc.index    = RPC_VFS_INODE_LOAD;
999    rpc.response = 1;
1000
1001    // set input arguments in RPC descriptor
1002    rpc.args[0] = (uint64_t)(intptr_t)inode;
1003
1004    // register RPC request in remote RPC fifo (blocking function)
1005    rpc_send_sync( cxy , &rpc );
1006
1007    // get output values from RPC descriptor
1008    *error   = (error_t)rpc.args[1];
1009
1010    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
1011}
1012
1013////////////////////////////////////////////////
1014void rpc_vfs_mapper_load_all_server( xptr_t xp )
1015{
1016    error_t       error;
1017    vfs_inode_t * inode;
1018
1019    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
1020
1021    // get client cluster identifier and pointer on RPC descriptor
1022    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
1023    rpc_desc_t * desc        = (rpc_desc_t *)GET_PTR( xp );
1024
1025    // get arguments "parent", "name", and "child_xp"
1026    inode = (vfs_inode_t*)(intptr_t)hal_remote_lwd(XPTR(client_cxy , &desc->args[0]));
1027
1028    // call the kernel function
1029    error = vfs_mapper_load_all( inode );
1030
1031    // set output argument
1032    hal_remote_swd( XPTR( client_cxy , &desc->args[3] ) , (uint64_t)error );
1033
1034    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
1035}
1036
1037/////////////////////////////////////////////////////////////////////////////////////////
1038// [18]          Marshaling functions attached to RPC_FATFS_GET_CLUSTER
1039/////////////////////////////////////////////////////////////////////////////////////////
1040
1041//////////////////////////////////////////////////
1042void rpc_fatfs_get_cluster_client( cxy_t      cxy,
1043                                   mapper_t * mapper,    // in
1044                                   uint32_t   first,     // in
1045                                   uint32_t   page,      // in
1046                                   uint32_t * cluster,   // out
1047                                   error_t  * error )    // out
1048{
1049    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
1050
1051    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
1052
1053    // initialise RPC descriptor header
1054    rpc_desc_t  rpc;
1055    rpc.index    = RPC_FATFS_GET_CLUSTER;
1056    rpc.response = 1;
1057
1058    // set input arguments in RPC descriptor
1059    rpc.args[0] = (uint64_t)(intptr_t)mapper;
1060    rpc.args[1] = (uint64_t)first;
1061    rpc.args[2] = (uint64_t)page;
1062
1063    // register RPC request in remote RPC fifo
1064    rpc_send_sync( cxy , &rpc );
1065
1066    // get output argument from rpc descriptor
1067    *cluster = (uint32_t)rpc.args[3];
1068    *error   = (error_t)rpc.args[4];
1069
1070    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
1071}
1072
1073//////////////////////////////////////////////
1074void rpc_fatfs_get_cluster_server( xptr_t xp )
1075{
1076    mapper_t    * mapper;
1077    uint32_t      first;
1078    uint32_t      page;
1079    uint32_t      cluster;
1080    error_t       error;
1081
1082    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
1083
1084    // get client cluster identifier and pointer on RPC descriptor
1085    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
1086    rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
1087
1088    // get input arguments
1089    mapper = (mapper_t *)(intptr_t)hal_remote_lpt( XPTR( client_cxy , &desc->args[0] ) );
1090    first  = (uint32_t)            hal_remote_lw ( XPTR( client_cxy , &desc->args[1] ) );
1091    page   = (uint32_t)            hal_remote_lw ( XPTR( client_cxy , &desc->args[2] ) );
1092
1093    // call the kernel function
1094    error = fatfs_get_cluster( mapper , first , page , &cluster );
1095
1096    // set output argument
1097    hal_remote_swd( XPTR( client_cxy , &desc->args[3] ) , (uint64_t)cluster );
1098    hal_remote_swd( XPTR( client_cxy , &desc->args[4] ) , (uint64_t)error );
1099
1100    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
1101}
1102
1103/////////////////////////////////////////////////////////////////////////////////////////
1104// [20]          Marshaling functions attached to RPC_VMM_GET_REF_VSEG
1105/////////////////////////////////////////////////////////////////////////////////////////
1106
1107//////////////////////////////////////////////////
1108void rpc_vmm_get_ref_vseg_client( cxy_t       cxy,     
1109                                  process_t * process,     // in 
1110                                  intptr_t    vaddr,       // in 
1111                                  xptr_t    * vseg_xp )    // out
1112{
1113    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
1114
1115    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
1116
1117    // initialise RPC descriptor header
1118    rpc_desc_t  rpc;
1119    rpc.index    = RPC_VMM_GET_REF_VSEG;
1120    rpc.response = 1;
1121
1122    // set input arguments in RPC descriptor
1123    rpc.args[0] = (uint64_t)(intptr_t)process;
1124    rpc.args[1] = (uint64_t)vaddr;
1125
1126    // register RPC request in remote RPC fifo (blocking function)
1127    rpc_send_sync( cxy , &rpc );
1128
1129    // get output argument from rpc descriptor
1130    *vseg_xp = rpc.args[2];
1131
1132    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
1133}
1134
1135/////////////////////////////////////////////
1136void rpc_vmm_get_ref_vseg_server( xptr_t xp )
1137{
1138    process_t   * process;
1139    intptr_t      vaddr;
1140    vseg_t      * vseg_ptr;
1141    xptr_t        vseg_xp;
1142
1143    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
1144
1145    // get client cluster identifier and pointer on RPC descriptor
1146    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
1147    rpc_desc_t * desc        = (rpc_desc_t *)GET_PTR( xp );
1148
1149    // get input argument from client RPC descriptor
1150    process = (process_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
1151    vaddr   = (intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
1152   
1153    // call local kernel function
1154    vseg_ptr = vmm_get_vseg( process , vaddr );
1155
1156    // set output argument to client RPC descriptor
1157    if( vseg_ptr == NULL ) vseg_xp = XPTR_NULL;
1158    else                   vseg_xp = XPTR( local_cxy , vseg_ptr );
1159    hal_remote_swd( XPTR( client_cxy , &desc->args[2] ) , (uint64_t)vseg_xp );
1160
1161    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
1162}
1163
1164
1165/////////////////////////////////////////////////////////////////////////////////////////
1166// [21]          Marshaling functions attached to RPC_VMM_GET_PTE
1167/////////////////////////////////////////////////////////////////////////////////////////
1168
1169////////////////////////////////////////////
1170void rpc_vmm_get_pte_client( cxy_t       cxy,   
1171                             process_t * process,  // in
1172                             vpn_t       vpn,      // in
1173                             uint32_t  * attr,     // out
1174                             ppn_t     * ppn,      // out
1175                             error_t   * error )   // out
1176{
1177    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
1178
1179    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
1180
1181    // initialise RPC descriptor header
1182    rpc_desc_t  rpc;
1183    rpc.index    = RPC_VMM_GET_PTE;
1184    rpc.response = 1;
1185
1186    // set input arguments in RPC descriptor
1187    rpc.args[0] = (uint64_t)(intptr_t)process;
1188    rpc.args[1] = (uint64_t)vpn;
1189
1190    // register RPC request in remote RPC fifo (blocking function)
1191    rpc_send_sync( cxy , &rpc );
1192
1193    // get output argument from rpc descriptor
1194    *attr  = (uint32_t)rpc.args[2];
1195    *ppn   = (ppn_t)rpc.args[3];
1196    *error = (error_t)rpc.args[4];
1197
1198    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
1199}
1200
1201////////////////////////////////////////
1202void rpc_vmm_get_pte_server( xptr_t xp )
1203{
1204    process_t   * process;
1205    vpn_t         vpn;
1206    uint32_t      attr;
1207    ppn_t         ppn;
1208    error_t       error;
1209
1210    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
1211
1212    // get client cluster identifier and pointer on RPC descriptor
1213    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
1214    rpc_desc_t * desc        = (rpc_desc_t *)GET_PTR( xp );
1215
1216    // get input argument "process" & "vpn" from client RPC descriptor
1217    process = (process_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
1218    vpn     = (vpn_t)                hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
1219   
1220    // call local kernel function
1221    error = vmm_get_pte( process , vpn , &attr , &ppn ); 
1222
1223    // set output argument "attr" & "ppn" to client RPC descriptor
1224    hal_remote_swd( XPTR( client_cxy , &desc->args[2] ) , (uint64_t)attr );
1225    hal_remote_swd( XPTR( client_cxy , &desc->args[3] ) , (uint64_t)ppn );
1226    hal_remote_swd( XPTR( client_cxy , &desc->args[4] ) , (uint64_t)error );
1227
1228    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
1229}
1230
1231/////////////////////////////////////////////////////////////////////////////////////////
1232// [22]          Marshaling functions attached to RPC_KCM_ALLOC
1233/////////////////////////////////////////////////////////////////////////////////////////
1234
1235//////////////////////////////////////////
1236void rpc_kcm_alloc_client( cxy_t      cxy,
1237                           uint32_t   kmem_type,   // in
1238                           xptr_t *   buf_xp )     // out
1239{
1240    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
1241
1242    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
1243
1244    // initialise RPC descriptor header
1245    rpc_desc_t  rpc;
1246    rpc.index    = RPC_THREAD_USER_CREATE;
1247    rpc.response = 1;
1248
1249    // set input arguments in RPC descriptor
1250    rpc.args[0] = (uint64_t)kmem_type;
1251
1252    // register RPC request in remote RPC fifo
1253    rpc_send_sync( cxy , &rpc );
1254
1255    // get output arguments from RPC descriptor
1256    *buf_xp = (xptr_t)rpc.args[1];
1257
1258    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
1259}
1260
1261//////////////////////////////////////
1262void rpc_kcm_alloc_server( xptr_t xp )
1263{
1264    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
1265
1266    // get client cluster identifier and pointer on RPC descriptor
1267    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
1268    rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
1269
1270    // get input argument "kmem_type" from client RPC descriptor
1271    uint32_t kmem_type = (uint32_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
1272
1273    // allocates memory for kcm
1274    kmem_req_t  req;
1275    req.type  = kmem_type;
1276    req.flags = AF_ZERO;
1277    void * buf_ptr = kmem_alloc( &req );
1278
1279    // set output argument
1280    xptr_t buf_xp = XPTR( local_cxy , buf_ptr );
1281    hal_remote_swd( XPTR( client_cxy , &desc->args[1] ) , (uint64_t)buf_xp );
1282
1283    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
1284}   
1285
1286/////////////////////////////////////////////////////////////////////////////////////////
1287// [23]          Marshaling functions attached to RPC_KCM_FREE
1288/////////////////////////////////////////////////////////////////////////////////////////
1289
1290/////////////////////////////////////////
1291void rpc_kcm_free_client( cxy_t      cxy,
1292                          void     * buf,          // in
1293                          uint32_t   kmem_type )   // in
1294{
1295    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
1296
1297    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
1298
1299    // initialise RPC descriptor header
1300    rpc_desc_t  rpc;
1301    rpc.index    = RPC_THREAD_USER_CREATE;
1302    rpc.response = 1;
1303
1304    // set input arguments in RPC descriptor
1305    rpc.args[0] = (uint64_t)(intptr_t)buf;
1306    rpc.args[1] = (uint64_t)kmem_type;
1307
1308    // register RPC request in remote RPC fifo
1309    rpc_send_sync( cxy , &rpc );
1310
1311    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
1312}
1313
1314/////////////////////////////////////
1315void rpc_kcm_free_server( xptr_t xp )
1316{
1317    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
1318
1319    // get client cluster identifier and pointer on RPC descriptor
1320    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
1321    rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
1322
1323    // get input arguments "buf" and "kmem_type" from client RPC descriptor
1324    void     * buf = (void *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
1325    uint32_t   kmem_type = (uint32_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
1326
1327    // releases memory
1328    kmem_req_t  req;
1329    req.type = kmem_type;
1330    req.ptr  = buf;
1331    kmem_free( &req );
1332
1333    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
1334}   
1335
1336/////////////////////////////////////////////////////////////////////////////////////////
1337// [24]          Marshaling functions attached to RPC_MAPPER_MOVE_BUFFER
1338/////////////////////////////////////////////////////////////////////////////////////////
1339
1340///////////////////////////////////////////////////
1341void rpc_mapper_move_buffer_client( cxy_t      cxy,
1342                                    mapper_t * mapper,        // in
1343                                    bool_t     to_buffer,     // in
1344                                    bool_t     is_user,       // in
1345                                    uint32_t   file_offset,   // in
1346                                    uint64_t   buffer,        // in
1347                                    uint32_t   size,          // in
1348                                    error_t  * error )        // out
1349{
1350    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
1351
1352    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
1353
1354    // initialise RPC descriptor header
1355    rpc_desc_t  rpc;
1356    rpc.index    = RPC_MAPPER_MOVE_BUFFER;
1357    rpc.response = 1;
1358
1359    // set input arguments in RPC descriptor
1360    rpc.args[0] = (uint64_t)(intptr_t)mapper;
1361    rpc.args[1] = (uint64_t)to_buffer;
1362    rpc.args[2] = (uint64_t)is_user;
1363    rpc.args[3] = (uint64_t)file_offset;
1364    rpc.args[4] = (uint64_t)buffer;
1365    rpc.args[5] = (uint64_t)size;
1366
1367    // register RPC request in remote RPC fifo (blocking function)
1368    rpc_send_sync( cxy , &rpc );
1369
1370    // get output values from RPC descriptor
1371    *error     = (error_t)rpc.args[6];
1372
1373    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
1374}
1375
1376///////////////////////////////////////////////
1377void rpc_mapper_move_buffer_server( xptr_t xp )
1378{
1379    mapper_t * mapper;
1380    bool_t     to_buffer;
1381    bool_t     is_user;
1382    uint32_t   file_offset;
1383    void     * user_buffer;
1384    xptr_t     kern_buffer;
1385    uint32_t   size;
1386    error_t    error;
1387
1388    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
1389
1390    // get client cluster identifier and pointer on RPC descriptor
1391    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
1392    rpc_desc_t * desc        = (rpc_desc_t *)GET_PTR( xp );
1393
1394    // get arguments from client RPC descriptor
1395    mapper      = (mapper_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
1396    to_buffer   =                       hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
1397    is_user     =                       hal_remote_lwd( XPTR( client_cxy , &desc->args[2] ) );
1398    file_offset =                       hal_remote_lwd( XPTR( client_cxy , &desc->args[3] ) );
1399    size        =                       hal_remote_lwd( XPTR( client_cxy , &desc->args[5] ) );
1400
1401    // call local kernel function
1402    if( is_user )
1403    {
1404        user_buffer = (void *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[4] ) );
1405
1406        error = mapper_move_user( mapper,
1407                                  to_buffer,
1408                                  file_offset,
1409                                  user_buffer,
1410                                  size );
1411    }
1412    else
1413    {
1414        kern_buffer = (xptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[4] ) );
1415
1416        error = mapper_move_kernel( mapper,
1417                                    to_buffer,
1418                                    file_offset,
1419                                    kern_buffer,
1420                                    size );
1421    }
1422
1423    // set output argument to client RPC descriptor
1424    hal_remote_swd( XPTR( client_cxy , &desc->args[6] ) , (uint64_t)error );
1425
1426    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
1427}
1428
1429/////////////////////////////////////////////////////////////////////////////////////////
1430// [25]          Marshaling functions attached to RPC_MAPPER_GET_PAGE
1431/////////////////////////////////////////////////////////////////////////////////////////
1432
1433///////////////////////////////////////////////////////
1434void rpc_mapper_get_page_client( cxy_t             cxy,
1435                                 struct mapper_s * mapper,     // in
1436                                 uint32_t          index,      // in
1437                                 page_t         ** page )      // out
1438{
1439    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
1440
1441    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
1442
1443    // initialise RPC descriptor header
1444    rpc_desc_t  rpc;
1445    rpc.index    = RPC_MAPPER_GET_PAGE;
1446    rpc.response = 1;
1447
1448    // set input arguments in RPC descriptor
1449    rpc.args[0] = (uint64_t)(intptr_t)mapper;
1450    rpc.args[1] = (uint64_t)index;
1451
1452    // register RPC request in remote RPC fifo (blocking function)
1453    rpc_send_sync( cxy , &rpc );
1454
1455    // get output values from RPC descriptor
1456    *page = (page_t *)(intptr_t)rpc.args[2];
1457
1458    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
1459}
1460
1461////////////////////////////////////////////
1462void rpc_mapper_get_page_server( xptr_t xp )
1463{
1464    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
1465
1466    // get client cluster identifier and pointer on RPC descriptor
1467    cxy_t        cxy  = (cxy_t)GET_CXY( xp );
1468    rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
1469
1470    // get input arguments from client RPC descriptor
1471    mapper_t * mapper = (mapper_t *)(intptr_t)hal_remote_lwd( XPTR( cxy , &desc->args[0] ) );
1472    uint32_t   index  = (uint32_t)            hal_remote_lwd( XPTR( cxy , &desc->args[1] ) );
1473   
1474    // call local pmem allocator
1475    page_t * page = mapper_get_page( mapper , index ); 
1476
1477    // set output arguments into client RPC descriptor
1478    hal_remote_swd( XPTR( cxy , &desc->args[1] ) , (uint64_t)(intptr_t)page );
1479
1480    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
1481}
1482
1483
1484/***************************************************************************************/
1485/************ Generic functions supporting RPCs : client side **************************/
1486/***************************************************************************************/
1487
1488////////////////////////////////////////////
1489void rpc_send_sync( cxy_t        server_cxy, 
1490                    rpc_desc_t * rpc )
1491{
1492    uint32_t   cores;
1493    error_t    error;
1494    bool_t     first;
1495    reg_t      sr_save;
1496
1497    thread_t * this = CURRENT_THREAD;
1498
1499    rpc_dmsg("\n[INFO] %s : enter / client_cxy = %x / server_cxy = %x / cycle %d\n",
1500    __FUNCTION__ , local_cxy , server_cxy , hal_time_stamp() );
1501
1502    // allocate and initialise an extended pointer on the RPC descriptor
1503        xptr_t   desc_xp = XPTR( local_cxy , rpc );
1504
1505    // get local pointer on rpc_fifo in remote cluster, with the
1506    // assumption that rpc_fifo pddresses are identical in all clusters
1507    rpc_fifo_t * rf = &LOCAL_CLUSTER->rpc_fifo;
1508
1509        // try to post an item in remote fifo
1510    // deschedule and retry if remote fifo full
1511    do
1512    { 
1513        error = remote_fifo_put_item( XPTR( server_cxy , &rf->fifo ),
1514                                      (uint64_t )desc_xp,
1515                                      &first );
1516
1517            if ( error ) 
1518        {
1519            printk("\n[WARNING] %s : cluster %x cannot post RPC to cluster %x\n",
1520            __FUNCTION__ , local_cxy , server_cxy );
1521
1522            if( thread_can_yield() ) sched_yield( NULL );
1523        }
1524    }
1525    while( error );
1526 
1527    rpc_dmsg("\n[INFO] %s : RPC %l registered / server_cxy = %x / cycle %d\n",
1528    __FUNCTION__ , desc_xp , server_cxy , hal_time_stamp() );
1529       
1530    // send IPI to remote CP0, if this is the first RPC in remote FIFO,
1531    // and there is no CPU is in kernel mode in server cluster.
1532        if( first )
1533        {
1534        // get number of cores in kernel mode in server cluster
1535        cores = hal_remote_lw( XPTR( server_cxy , &LOCAL_CLUSTER->cores_in_kernel ) );
1536
1537                if( cores == 0 ) // no core in kernel mode in server
1538                {
1539                    dev_pic_send_ipi( server_cxy , 0 );
1540
1541                    rpc_dmsg("\n[INFO] %s : IPI sent / client_cxy = %x / server_cxy = %x\n",
1542            __FUNCTION__, local_cxy , server_cxy );
1543        }
1544        }
1545
1546        // enable IRQs to allow incoming RPC and avoid deadlock
1547        if( this->type == THREAD_RPC ) hal_enable_irq( &sr_save );
1548
1549    // the server thread poll the response slot until RPC completed
1550    // TODO this could be replaced by a descheduling policy... [AG]
1551        while( 1 )
1552    {
1553        if( rpc->response == 0 ) break;
1554    }
1555
1556    // restore IRQs
1557        if( this->type == THREAD_RPC ) hal_restore_irq( sr_save );
1558
1559    rpc_dmsg("\n[INFO] %s : completed / client_cxy = %x / server_cxy = %x / cycle %d\n",
1560    __FUNCTION__ , local_cxy , server_cxy , hal_time_stamp() );
1561
1562}  // end rpc_send_sync()
1563
1564
1565
1566/***************************************************************************************/
1567/************ Generic functions supporting RPCs : server side **************************/
1568/***************************************************************************************/
1569
1570///////////////////////////////////////////
1571void rpc_fifo_init( rpc_fifo_t * rpc_fifo )
1572{
1573        rpc_fifo->count       = 0;
1574        rpc_fifo->owner       = 0;
1575        local_fifo_init( &rpc_fifo->fifo );
1576}
1577
1578/////////////////////////////////////////////
1579void rpc_execute_all( rpc_fifo_t * rpc_fifo )
1580{
1581        xptr_t         xp;             // extended pointer on RPC descriptor
1582        uint32_t       count;          // handled RPC request counter
1583        thread_t     * this;           // pointer on this RPC thread
1584    core_t       * core;           // pointer on core running this thread
1585    rpc_desc_t   * desc;           // pointer on RPC descriptor
1586    uint32_t       index;          // RPC index
1587    cxy_t          client_cxy;     // client cluster identifier
1588        error_t        error;
1589     
1590        this  = CURRENT_THREAD; 
1591    core  = this->core;   
1592        count = 0;
1593
1594    rpc_dmsg("\n[INFO] %s : enter / thread %x on core[%x,%d] / fifo = %x / cycle %d\n",
1595    __FUNCTION__, this->trdid, local_cxy, core->lid , hal_time_stamp() );
1596 
1597    // handle up to CONFIG_RPC_PENDING_MAX requests before exit
1598        do
1599    {
1600            error = local_fifo_get_item( &rpc_fifo->fifo, (uint64_t *)&xp );
1601
1602                if ( error == 0 )  // One RPC request successfully extracted from RPC_FIFO
1603        {
1604            // get client cluster identifier and pointer on RPC descriptor
1605            client_cxy = (cxy_t)GET_CXY( xp );
1606            desc       = (rpc_desc_t *)GET_PTR( xp );
1607
1608            // get rpc index from RPC descriptor
1609                index = hal_remote_lw( XPTR( client_cxy , &desc->index ) );
1610
1611            rpc_dmsg("\n[INFO] %s : thread %x on core [%x,%d] / index = %d / &rpc = %x\n",
1612                     __FUNCTION__ , this->trdid , core->lid , local_cxy , index , rpc_server[index] );
1613
1614            // call the relevant server function
1615            rpc_server[index]( xp );
1616
1617            // increment handled RPC counter
1618                count++;
1619
1620            // notify RPC completion as required
1621            hal_remote_atomic_add( XPTR(client_cxy,&desc->response) , -1 );
1622                }
1623       
1624                // exit loop in three cases:
1625        // - fifo is empty
1626        // - look has been released (because descheduling)
1627        // - max number of RPCs has been reached
1628                if( error || 
1629            (rpc_fifo->owner != this->trdid) || 
1630            (count > CONFIG_RPC_PENDING_MAX) ) break;
1631        }
1632    while( 1 );
1633
1634    // update RPC_FIFO global counter
1635        rpc_fifo->count += count;
1636
1637}  // end rpc_execute_all()
1638
1639////////////////////////////////////////////////////
1640error_t rpc_activate_thread( rpc_fifo_t * rpc_fifo )
1641{
1642        core_t      * core;
1643        thread_t    * thread;
1644        thread_t    * this;
1645    scheduler_t * sched;
1646        error_t       error;
1647    bool_t        found;
1648    reg_t         sr_save;
1649
1650   
1651        this   = CURRENT_THREAD;
1652    core   = this->core;
1653    sched  = &core->scheduler;
1654    found  = false;
1655
1656    assert( (this->trdid == rpc_fifo->owner) , __FUNCTION__ ,
1657          "calling thread is not RPC_FIFO owner\n" );
1658
1659    // makes the calling thread not preemptable
1660    // during activation / creation of the RPC thread
1661        hal_disable_irq( &sr_save );
1662
1663    // search a free RPC thread (must be in THREAD_BLOCKED_IDLE state)   
1664    list_entry_t * iter;
1665    LIST_FOREACH( &sched->k_root , iter )
1666    {
1667        thread = LIST_ELEMENT( iter , thread_t , sched_list );
1668        if( (thread->type == THREAD_RPC) && (thread->blocked == THREAD_BLOCKED_IDLE ) ) 
1669        {
1670            found = true;
1671            break;
1672        }
1673    }
1674
1675    if( found )                    // activate this idle RPC thread     
1676    {
1677        // unblock it
1678        thread->blocked = 0;
1679
1680        rpc_dmsg("\n[INFO] %s : activate RPC thread %x on core [%x,%d] / cycle %d\n", 
1681                          __FUNCTION__ , thread , core->gid , local_cxy , hal_time_stamp() );
1682    }
1683    else                           // create a new RPC thread
1684    {
1685        // create new thread
1686        error = thread_kernel_create( &thread,
1687                                      THREAD_RPC, 
1688                                                  &rpc_thread_func, 
1689                                      NULL,
1690                                                  core->lid );
1691            if( error ) 
1692        {
1693                hal_restore_irq( sr_save );
1694            printk("\n[ERROR] in %s : no memory for new RPC thread in cluster %x\n",
1695                   __FUNCTION__ , local_cxy );
1696            return ENOMEM;
1697        }
1698
1699        // unblock new thread
1700        thread->blocked = 0;
1701
1702        // update core descriptor counter 
1703            hal_atomic_add( &LOCAL_CLUSTER->rpc_threads , 1 );
1704
1705        rpc_dmsg("\n[INFO] %s : create RPC thread %x on core [%x,%d] / cycle %d\n", 
1706                          __FUNCTION__ , thread->trdid, local_cxy, core->lid, hal_time_stamp() );
1707    }
1708
1709    // update owner in rpc_fifo
1710    rpc_fifo->owner = thread->trdid;
1711
1712    // current thread switch to RPC thread 
1713        sched_yield( thread );
1714
1715    // restore IRQs for the calling thread
1716        hal_restore_irq( sr_save );
1717
1718    // return success
1719        return 0;
1720
1721}  // end rpc_activate_thread()
1722
1723//////////////////
1724bool_t rpc_check()
1725{
1726        thread_t   * this     = CURRENT_THREAD;
1727        rpc_fifo_t * rpc_fifo = &LOCAL_CLUSTER->rpc_fifo;
1728    error_t      error;
1729
1730    rpc_dmsg("\n[INFO] %s : enter in cluster %x\n",
1731             __FUNCTION__ , local_cxy );
1732
1733    // calling thread does nothing if light lock already taken or FIFO empty 
1734        if( (rpc_fifo->owner != 0) || (local_fifo_is_empty( &rpc_fifo->fifo )) )
1735    {
1736        rpc_dmsg("\n[INFO] %s : exit but do nothing in cluster %x\n",
1737                 __FUNCTION__ , local_cxy );
1738
1739        return false;
1740    }
1741
1742        // try to take the light lock, and activates an RPC thread if success
1743    if( hal_atomic_test_set( &rpc_fifo->owner , this->trdid ) )
1744        {
1745        error = rpc_activate_thread( rpc_fifo );
1746
1747        if( error )    // cannot activate an RPC_THREAD
1748        {
1749            rpc_fifo->owner = 0;
1750
1751            printk("\n[ERROR] in %s : no memory to create a RPC thread for core %d"
1752                   " in cluster %x => do nothing\n",
1753                   __FUNCTION__ , CURRENT_CORE->lid , local_cxy );
1754        }
1755
1756        rpc_dmsg("\n[INFO] %s : exit after activating an RPC thread in cluster %x\n",
1757                 __FUNCTION__ , local_cxy );
1758
1759        return true;
1760    }
1761    else  // light lock taken by another thread
1762    {
1763        rpc_dmsg("\n[INFO] %s : exit but do nothing in cluster %x\n",
1764                 __FUNCTION__ , local_cxy );
1765
1766        return false;
1767    }
1768} // end rpc_check()
1769
1770
1771//////////////////////
1772void rpc_thread_func()
1773{
1774    // makes the RPC thread not preemptable
1775        hal_disable_irq( NULL );
1776 
1777        thread_t   * this     = CURRENT_THREAD;
1778        rpc_fifo_t * rpc_fifo = &LOCAL_CLUSTER->rpc_fifo;
1779
1780    rpc_dmsg("\n[INFO] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
1781             __FUNCTION__, this->trdid, local_cxy, this->core->lid, hal_time_stamp() );
1782
1783    // this infinite loop is not preemptable
1784    // the RPC thread deschedule only when the RPC_FIFO is empty
1785        while(1)
1786        {
1787        // check fifo ownership (ownership should be given by rpc_activate()
1788        if( this->trdid != rpc_fifo->owner )
1789        {
1790            printk("\n[PANIC] in %s : thread %x on core[%x,%d] not owner of RPC_FIFO\n",
1791            __FUNCTION__, this->trdid, local_cxy, this->core->lid );
1792            hal_core_sleep();
1793        }
1794 
1795        // executes pending RPC(s)
1796        rpc_execute_all( rpc_fifo );
1797
1798        // release rpc_fifo ownership (can be lost during RPC execution)
1799        if( rpc_fifo->owner == this->trdid ) rpc_fifo->owner = 0;
1800
1801
1802        //  block and deschedule or sucide
1803                if( LOCAL_CLUSTER->rpc_threads >= CONFIG_RPC_THREADS_MAX ) 
1804                {
1805            rpc_dmsg("\n[INFO] thread %x on core[%x,%d] suicide / cycle %d\n", 
1806                    __FUNCTION__, this->trdid, local_cxy, this->core->lid, hal_time_stamp() );
1807
1808            // update core descriptor counter
1809                hal_atomic_add( &LOCAL_CLUSTER->rpc_threads , -1 );
1810
1811            // suicide
1812                        thread_exit();
1813                }
1814        else
1815        {
1816            rpc_dmsg("\n[INFO] %s : thread %x on core[%x,%d] blocks / cycle %d\n", 
1817                        __FUNCTION__, this->trdid, local_cxy, this->core->lid, hal_time_stamp() ); 
1818
1819                    thread_block( this , THREAD_BLOCKED_IDLE );
1820            sched_yield( NULL );
1821
1822                    rpc_dmsg("\n[INFO] RPC thread %x wake up on core[%x,%d] / cycle %d\n", 
1823                __FUNCTION__, this->trdid, local_cxy, this->core->lid, hal_time_stamp() );
1824        }
1825        } // end while
1826} // end rpc_thread_func()
1827
Note: See TracBrowser for help on using the repository browser.