Context Navigation

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

Last change on this file since 434 was 433, checked in by alain, 8 years ago
blip
File size: 90.3 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	/////////////////////////////////////////////////////////////////////////////////////////
46	// Debug macros for marshalling functions
47	/////////////////////////////////////////////////////////////////////////////////////////
48
49	#if CONFIG_DEBUG_RPC_MARSHALING
50
51	#define RPC_DEBUG_ENTER \
52	uint32_t cycle = (uint32_t)hal_get_cycles(); \
53	if( cycle > CONFIG_DEBUG_RPC_MARSHALING ) \
54	printk("\n[DBG] %s : enter thread %x on core[%x,%d] / cycle %d\n", \
55	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, CURRENT_THREAD->core->lid , cycle );
56
57	#define RPC_DEBUG_EXIT \
58	cycle = (uint32_t)hal_get_cycles(); \
59	if( cycle > CONFIG_DEBUG_RPC_MARSHALING ) \
60	printk("\n[DBG] %s : exit thread %x on core[%x,%d] / cycle %d\n", \
61	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, CURRENT_THREAD->core->lid , cycle );
62
63	#else
64
65	#define RPC_DEBUG_ENTER
66
67	#define RPC_DEBUG_EXIT
68
69	#endif
70
71	/////////////////////////////////////////////////////////////////////////////////////////
72	// array of function pointers (must be consistent with enum in rpc.h)
73	/////////////////////////////////////////////////////////////////////////////////////////
74
75	rpc_server_t * rpc_server[RPC_MAX_INDEX] =
76	{
77	&rpc_pmem_get_pages_server, // 0
78	&rpc_pmem_release_pages_server, // 1
79	&rpc_undefined, // 2 unused slot
80	&rpc_process_make_fork_server, // 3
81	&rpc_undefined, // 4 unused slot
82	&rpc_process_make_kill_server, // 5
83	&rpc_thread_user_create_server, // 6
84	&rpc_thread_kernel_create_server, // 7
85	&rpc_thread_kill_server, // 8
86	&rpc_process_sigaction_server, // 9
87
88	&rpc_vfs_inode_create_server, // 10
89	&rpc_vfs_inode_destroy_server, // 11
90	&rpc_vfs_dentry_create_server, // 12
91	&rpc_vfs_dentry_destroy_server, // 13
92	&rpc_vfs_file_create_server, // 14
93	&rpc_vfs_file_destroy_server, // 15
94	&rpc_vfs_inode_load_server, // 16
95	&rpc_vfs_mapper_load_all_server, // 17
96	&rpc_fatfs_get_cluster_server, // 18
97	&rpc_undefined, // 19 unused slot
98
99	&rpc_vmm_get_vseg_server, // 20
100	&rpc_vmm_get_pte_server, // 21
101	&rpc_kcm_alloc_server, // 22
102	&rpc_kcm_free_server, // 23
103	&rpc_mapper_move_buffer_server, // 24
104	&rpc_mapper_get_page_server, // 25
105	&rpc_vmm_create_vseg_server, // 26
106	&rpc_sched_display_server, // 27
107	&rpc_vmm_set_cow_server, // 28
108	&rpc_vmm_display_server, // 29
109	};
110
111	//////////////////////////////////////////////
112	void __attribute__((noinline)) rpc_undefined()
113	{
114	assert( false , __FUNCTION__ , "called in cluster %x", local_cxy );
115	}
116
117	/***************************************************************************************/
118	/********** Generic functions supporting RPCs : client side ************************/
119	/***************************************************************************************/
120
121	///////////////////////////////////////
122	void rpc_send( cxy_t server_cxy,
123	rpc_desc_t * rpc )
124	{
125	error_t error;
126
127	thread_t * this = CURRENT_THREAD;
128	core_t * core = this->core;
129
130	// register client thread pointer and core lid in RPC descriptor
131	rpc->thread = this;
132	rpc->lid = core->lid;
133
134	// build an extended pointer on the RPC descriptor
135	xptr_t desc_xp = XPTR( local_cxy , rpc );
136
137	// get local pointer on rpc_fifo in remote cluster, with the
138	// assumption that local pointers are identical in all clusters
139	remote_fifo_t * rpc_fifo = &LOCAL_CLUSTER->rpc_fifo;
140
141	// try to post an item in remote fifo
142	// deschedule and retry if remote fifo full
143	do
144	{
145	error = remote_fifo_put_item( XPTR( server_cxy , rpc_fifo ),
146	(uint64_t )desc_xp );
147	if ( error )
148	{
149	printk("\n[WARNING] %s : cluster %x cannot post RPC to cluster %x\n",
150	__FUNCTION__ , local_cxy , server_cxy );
151
152	if( thread_can_yield() ) sched_yield("RPC fifo full");
153	}
154	}
155	while( error );
156
157	hal_fence();
158
159	// send IPI to the remote core corresponding to the client core
160	dev_pic_send_ipi( server_cxy , core->lid );
161
162	// wait RPC completion before returning if blocking RPC
163	// - busy waiting policy during kernel_init, or if threads cannot yield
164	// - block and deschedule in all other cases
165	if ( rpc->blocking )
166	{
167	if( (this->type == THREAD_IDLE) \|\| (thread_can_yield() == false) ) // busy waiting
168	{
169
170	grpc_dmsg("\n[DBG] %s : core[%x,%d] / thread %s busy waiting after registering RPC\n"
171	" rpc = %d / server = %x / cycle %d\n",
172	__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , thread_type_str(this->type) ,
173	rpc->index , server_cxy , hal_time_stamp() );
174
175	while( rpc->response ) hal_fixed_delay( 100 );
176
177	grpc_dmsg("\n[DBG] %s : core[%x,%d] / thread %s exit after RPC completion\n",
178	__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , thread_type_str(this->type) );
179
180	}
181	else // block & deschedule
182	{
183
184	grpc_dmsg("\n[DBG] %s : core[%x,%d] / thread %s deschedule after registering RPC\n"
185	" rpc = %d / server = %x / cycle %d\n",
186	__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , thread_type_str(this->type) ,
187	rpc->index , server_cxy , hal_time_stamp() );
188
189	thread_block( this , THREAD_BLOCKED_RPC );
190	sched_yield("BLOCKED on RPC");
191
192	grpc_dmsg("\n[DBG] %s : core[%x,%d] / thread %s resumes after RPC completion\n",
193	__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , thread_type_str(this->type) );
194
195	}
196
197	// check response available
198	assert( (rpc->response == 0) , __FUNCTION__, "illegal RPC response\n" );
199
200	// acknowledge the IPI sent by the server
201	dev_pic_ack_ipi();
202	}
203	} // end rpc_send()
204
205
206	/***************************************************************************************/
207	/********** Generic functions supporting RPCs : server side ************************/
208	/***************************************************************************************/
209
210	////////////////
211	void rpc_check()
212	{
213	error_t error;
214	thread_t * thread;
215	uint32_t sr_save;
216
217	bool_t found = false;
218	thread_t * this = CURRENT_THREAD;
219	core_t * core = this->core;
220	scheduler_t * sched = &core->scheduler;
221	remote_fifo_t * rpc_fifo = &LOCAL_CLUSTER->rpc_fifo;
222
223	grpc_dmsg("\n[DBG] %s : core[%x,%d] / interrupted thread %s / cycle %d\n",
224	__FUNCTION__, local_cxy, core->lid, thread_type_str(this->type), hal_time_stamp() );
225
226	// interrupted thread not preemptable during RPC chek
227	hal_disable_irq( &sr_save );
228
229	// check RPC FIFO not empty and no RPC thread handling it
230	if( (rpc_fifo->owner == 0) && (local_fifo_is_empty(rpc_fifo) == false) )
231	{
232	// search one non blocked RPC thread
233	list_entry_t * iter;
234	LIST_FOREACH( &sched->k_root , iter )
235	{
236	thread = LIST_ELEMENT( iter , thread_t , sched_list );
237	if( (thread->type == THREAD_RPC) && (thread->blocked == 0 ) )
238	{
239	found = true;
240	break;
241	}
242	}
243
244	// create new RPC thread if not found
245	if( found == false )
246	{
247	error = thread_kernel_create( &thread,
248	THREAD_RPC,
249	&rpc_thread_func,
250	NULL,
251	this->core->lid );
252	if( error )
253	{
254	printk("\n[WARNING] in %s : no memory for new RPC thread in cluster %x\n",
255	__FUNCTION__ , local_cxy );
256	}
257	else
258	{
259	// unblock created RPC thread
260	thread->blocked = 0;
261
262	// update core descriptor counter
263	hal_atomic_add( &LOCAL_CLUSTER->rpc_threads , 1 );
264
265	grpc_dmsg("\n[DBG] %s : core [%x,%d] creates a new RPC thread %x / trdid %x / cycle %d\n",
266	__FUNCTION__ , local_cxy , core->lid , thread , thread->trdid , hal_time_stamp() );
267
268	}
269	}
270	}
271
272	grpc_dmsg("\n[DBG] %s : core[%x,%d] / interrupted thread %s deschedules / cycle %d\n",
273	__FUNCTION__, local_cxy, core->lid, thread_type_str(this->type), hal_time_stamp() );
274
275	// interrupted thread deschedule always
276	sched_yield("IPI received");
277
278	grpc_dmsg("\n[DBG] %s : core[%x,%d] / interrupted thread %s resume / cycle %d\n",
279	__FUNCTION__, local_cxy, core->lid, thread_type_str(this->type), hal_time_stamp() );
280
281	// interrupted thread restore IRQs after resume
282	hal_restore_irq( sr_save );
283
284	} // end rpc_check()
285
286
287	//////////////////////
288	void rpc_thread_func()
289	{
290	uint32_t count; // handled RPC requests counter
291	error_t empty; // local RPC fifo state
292	xptr_t desc_xp; // extended pointer on RPC request
293	cxy_t desc_cxy; // RPC request cluster (client)
294	rpc_desc_t * desc_ptr; // RPC request local pointer
295	uint32_t index; // RPC request index
296	thread_t * thread_ptr; // local pointer on client thread
297	lid_t core_lid; // local index of client core
298	bool_t blocking; // blocking RPC when true
299
300	// makes RPC thread not preemptable
301	hal_disable_irq( NULL );
302
303	thread_t * this = CURRENT_THREAD;
304	remote_fifo_t * rpc_fifo = &LOCAL_CLUSTER->rpc_fifo;
305
306	// two embedded loops:
307	// - external loop : "infinite" RPC thread
308	// - internal loop : handle up to CONFIG_RPC_PENDING_MAX RPC requests
309
310	while(1) // external loop
311	{
312	// try to take RPC_FIFO ownership
313	if( hal_atomic_test_set( &rpc_fifo->owner , this->trdid ) )
314	{
315	// initializes RPC requests counter
316	count = 0;
317
318	// acknowledge local IPI
319	dev_pic_ack_ipi();
320
321	// exit internal loop in three cases:
322	// - RPC fifo is empty
323	// - ownership has been lost (because descheduling)
324	// - max number of RPCs is reached
325	while( 1 ) // internal loop
326	{
327
328	empty = local_fifo_get_item( rpc_fifo , (uint64_t *)&desc_xp );
329
330	if ( empty == 0 ) // one RPC request found
331	{
332	// get client cluster and pointer on RPC descriptor
333	desc_cxy = (cxy_t)GET_CXY( desc_xp );
334	desc_ptr = (rpc_desc_t *)GET_PTR( desc_xp );
335
336	// get RPC <index> & <blocking> fields from RPC descriptor
337	index = hal_remote_lw( XPTR( desc_cxy , &desc_ptr->index ) );
338	blocking = hal_remote_lw( XPTR( desc_cxy , &desc_ptr->blocking ) );
339
340	grpc_dmsg("\n[DBG] %s : core[%x,%d] / RPC thread %x / starts rpc %d / cycle %d\n",
341	__FUNCTION__ , local_cxy , this->core->lid , this->trdid , index , (uint32_t)hal_get_cycles() );
342
343	// call the relevant server function
344	rpc_server[index]( desc_xp );
345
346	grpc_dmsg("\n[DBG] %s : core[%x,%d] / RPC thread %x / completes rpc %d / cycle %d\n",
347	__FUNCTION__ , local_cxy , this->core->lid , this->trdid , index , hal_time_stamp() );
348
349	// increment handled RPCs counter
350	count++;
351
352	// decrement response counter in RPC descriptor if blocking
353	if( blocking )
354	{
355	// decrement responses counter in RPC descriptor
356	hal_remote_atomic_add(XPTR( desc_cxy, &desc_ptr->response ), -1);
357
358	// unblock client thread
359	thread_ptr = (thread_t *)hal_remote_lpt(XPTR(desc_cxy,&desc_ptr->thread));
360	thread_unblock( XPTR(desc_cxy,thread_ptr) , THREAD_BLOCKED_RPC );
361
362	hal_fence();
363
364	// get client core lid and send IPI
365	core_lid = hal_remote_lw(XPTR(desc_cxy, &desc_ptr->lid));
366	dev_pic_send_ipi( desc_cxy , core_lid );
367	}
368	}
369
370	// chek exit condition
371	if( local_fifo_is_empty( rpc_fifo ) \|\|
372	(rpc_fifo->owner != this->trdid) \|\|
373	(count >= CONFIG_RPC_PENDING_MAX) ) break;
374	} // end internal loop
375
376	// release rpc_fifo ownership if not lost
377	if( rpc_fifo->owner == this->trdid ) rpc_fifo->owner = 0;
378
379	} // end if RPC fifo
380
381	// sucide if too many RPC threads in cluster
382	if( LOCAL_CLUSTER->rpc_threads >= CONFIG_RPC_THREADS_MAX )
383	{
384
385	grpc_dmsg("\n[DBG] %s : core[%x,%d] (RPC thread %x) suicide at cycle %d\n",
386	__FUNCTION__, local_cxy, this->core->lid, this->trdid, hal_time_stamp() );
387
388	// update RPC threads counter
389	hal_atomic_add( &LOCAL_CLUSTER->rpc_threads , -1 );
390
391	// suicide
392	thread_kill( this );
393	}
394
395	grpc_dmsg("\n[DBG] %s : core[%x,%d] (RPC thread %x) deschedules / cycle %d\n",
396	__FUNCTION__, local_cxy, this->core->lid, this->trdid, hal_time_stamp() );
397
398	// deschedule without blocking
399	sched_yield("RPC fifo empty or too much work");
400
401	grpc_dmsg("\n[DBG] %s : core[%x,%d] (RPC thread %x) resumes / cycle %d\n",
402	__FUNCTION__, local_cxy, this->core->lid, this->trdid, hal_time_stamp() );
403
404	} // end external loop
405
406	} // end rpc_thread_func()
407
408
409	/////////////////////////////////////////////////////////////////////////////////////////
410	// [0] Marshaling functions attached to RPC_PMEM_GET_PAGES (blocking)
411	/////////////////////////////////////////////////////////////////////////////////////////
412
413	///////////////////////////////////////////////
414	void rpc_pmem_get_pages_client( cxy_t cxy,
415	uint32_t order, // in
416	page_t ** page ) // out
417	{
418	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
419	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
420	CURRENT_THREAD->core->lid , hal_time_stamp() );
421
422	assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
423
424	// initialise RPC descriptor header
425	rpc_desc_t rpc;
426	rpc.index = RPC_PMEM_GET_PAGES;
427	rpc.response = 1;
428	rpc.blocking = true;
429
430	// set input arguments in RPC descriptor
431	rpc.args[0] = (uint64_t)order;
432
433	// register RPC request in remote RPC fifo (blocking function)
434	rpc_send( cxy , &rpc );
435
436	// get output arguments from RPC descriptor
437	page = (page_t )(intptr_t)rpc.args[1];
438
439	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
440	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
441	CURRENT_THREAD->core->lid , hal_time_stamp() );
442	}
443
444	///////////////////////////////////////////
445	void rpc_pmem_get_pages_server( xptr_t xp )
446	{
447	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
448	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
449	CURRENT_THREAD->core->lid , hal_time_stamp() );
450
451	// get client cluster identifier and pointer on RPC descriptor
452	cxy_t cxy = (cxy_t)GET_CXY( xp );
453	rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
454
455	// get input arguments from client RPC descriptor
456	uint32_t order = (uint32_t)hal_remote_lwd( XPTR( cxy , &desc->args[0] ) );
457
458	// call local pmem allocator
459	page_t * page = ppm_alloc_pages( order );
460
461	// set output arguments into client RPC descriptor
462	hal_remote_swd( XPTR( cxy , &desc->args[1] ) , (uint64_t)(intptr_t)page );
463
464	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
465	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
466	CURRENT_THREAD->core->lid , hal_time_stamp() );
467	}
468
469	/////////////////////////////////////////////////////////////////////////////////////////
470	// [1] Marshaling functions attached to RPC_PMEM_RELEASE_PAGES (blocking)
471	/////////////////////////////////////////////////////////////////////////////////////////
472
473	//////////////////////////////////////////////////
474	void rpc_pmem_release_pages_client( cxy_t cxy,
475	page_t * page ) // out
476	{
477	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
478	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
479	CURRENT_THREAD->core->lid , hal_time_stamp() );
480
481	assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
482
483	// initialise RPC descriptor header
484	rpc_desc_t rpc;
485	rpc.index = RPC_PMEM_RELEASE_PAGES;
486	rpc.response = 1;
487	rpc.blocking = true;
488
489	// set input arguments in RPC descriptor
490	rpc.args[0] = (uint64_t)(intptr_t)page;
491
492	// register RPC request in remote RPC fifo (blocking function)
493	rpc_send( cxy , &rpc );
494
495	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
496	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
497	CURRENT_THREAD->core->lid , hal_time_stamp() );
498	}
499
500	///////////////////////////////////////////////
501	void rpc_pmem_release_pages_server( xptr_t xp )
502	{
503	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
504	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
505	CURRENT_THREAD->core->lid , hal_time_stamp() );
506
507	// get client cluster identifier and pointer on RPC descriptor
508	cxy_t cxy = (cxy_t)GET_CXY( xp );
509	rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
510
511	// get input arguments from client RPC descriptor
512	page_t * page = (page_t *)(intptr_t)hal_remote_lwd( XPTR( cxy , &desc->args[0] ) );
513
514	// release memory to local pmem
515	kmem_req_t req;
516	req.type = KMEM_PAGE;
517	req.ptr = page;
518	kmem_free( &req );
519
520	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
521	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
522	CURRENT_THREAD->core->lid , hal_time_stamp() );
523	}
524
525	/////////////////////////////////////////////////////////////////////////////////////////
526	// [2] undefined slot
527	/////////////////////////////////////////////////////////////////////////////////////////
528
529	/////////////////////////////////////////////////////////////////////////////////////////
530	// [3] Marshaling functions attached to RPC_PROCESS_MAKE_FORK (blocking)
531	/////////////////////////////////////////////////////////////////////////////////////////
532
533	///////////////////////////////////////////////////
534	void rpc_process_make_fork_client( cxy_t cxy,
535	xptr_t ref_process_xp, // in
536	xptr_t parent_thread_xp, // in
537	pid_t * child_pid, // out
538	thread_t ** child_thread_ptr, // out
539	error_t * error ) // out
540	{
541	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
542	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
543	CURRENT_THREAD->core->lid , hal_time_stamp() );
544
545	assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
546
547	// initialise RPC descriptor header
548	rpc_desc_t rpc;
549	rpc.index = RPC_PROCESS_MAKE_FORK;
550	rpc.response = 1;
551	rpc.blocking = true;
552
553	// set input arguments in RPC descriptor
554	rpc.args[0] = (uint64_t)(intptr_t)ref_process_xp;
555	rpc.args[1] = (uint64_t)(intptr_t)parent_thread_xp;
556
557	// register RPC request in remote RPC fifo (blocking function)
558	rpc_send( cxy , &rpc );
559
560	// get output arguments from RPC descriptor
561	*child_pid = (pid_t)rpc.args[2];
562	child_thread_ptr = (thread_t )(intptr_t)rpc.args[3];
563	*error = (error_t)rpc.args[4];
564
565	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
566	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
567	CURRENT_THREAD->core->lid , hal_time_stamp() );
568	}
569
570	//////////////////////////////////////////////
571	void rpc_process_make_fork_server( xptr_t xp )
572	{
573	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
574	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
575	CURRENT_THREAD->core->lid , hal_time_stamp() );
576
577	xptr_t ref_process_xp; // extended pointer on reference parent process
578	xptr_t parent_thread_xp; // extended pointer on parent thread
579	pid_t child_pid; // child process identifier
580	thread_t * child_thread_ptr; // local copy of exec_info structure
581	error_t error; // local error status
582
583	// get client cluster identifier and pointer on RPC descriptor
584	cxy_t client_cxy = (cxy_t)GET_CXY( xp );
585	rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
586
587	// get input arguments from cient RPC descriptor
588	ref_process_xp = (xptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
589	parent_thread_xp = (xptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
590
591	// call local kernel function
592	error = process_make_fork( ref_process_xp,
593	parent_thread_xp,
594	&child_pid,
595	&child_thread_ptr );
596
597	// set output argument into client RPC descriptor
598	hal_remote_swd( XPTR( client_cxy , &desc->args[2] ) , (uint64_t)child_pid );
599	hal_remote_swd( XPTR( client_cxy , &desc->args[3] ) , (uint64_t)(intptr_t)child_thread_ptr );
600	hal_remote_swd( XPTR( client_cxy , &desc->args[4] ) , (uint64_t)error );
601
602	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
603	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
604	CURRENT_THREAD->core->lid , hal_time_stamp() );
605	}
606
607	/////////////////////////////////////////////////////////////////////////////////////////
608	// [4] undefined slot
609	/////////////////////////////////////////////////////////////////////////////////////////
610
611	/////////////////////////////////////////////////////////////////////////////////////////
612	// [5] Marshaling functions attached to RPC_PROCESS_MAKE_KILL (blocking)
613	/////////////////////////////////////////////////////////////////////////////////////////
614
615	///////////////////////////////////////////////////
616	void rpc_process_make_kill_client( cxy_t cxy,
617	process_t * process,
618	bool_t is_exit,
619	uint32_t status )
620	{
621	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
622	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
623	CURRENT_THREAD->core->lid , hal_time_stamp() );
624
625	// initialise RPC descriptor header
626	rpc_desc_t rpc;
627	rpc.index = RPC_PROCESS_MAKE_KILL;
628	rpc.response = 1;
629	rpc.blocking = true;
630
631	// set input arguments in RPC descriptor
632	rpc.args[0] = (uint64_t)(intptr_t)process;
633	rpc.args[1] = (uint64_t)is_exit;
634	rpc.args[2] = (uint64_t)status;
635
636	// register RPC request in remote RPC fifo (blocking function)
637	rpc_send( cxy , &rpc );
638
639	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
640	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
641	CURRENT_THREAD->core->lid , hal_time_stamp() );
642	}
643
644	//////////////////////////////////////////////
645	void rpc_process_make_kill_server( xptr_t xp )
646	{
647	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
648	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
649	CURRENT_THREAD->core->lid , hal_time_stamp() );
650
651	process_t * process;
652	bool_t is_exit;
653	uint32_t status;
654
655	// get client cluster identifier and pointer on RPC descriptor
656	cxy_t client_cxy = (cxy_t)GET_CXY( xp );
657	rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
658
659	// get arguments from RPC descriptor
660	process = (process_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
661	is_exit = (bool_t) hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
662	status = (uint32_t) hal_remote_lwd( XPTR( client_cxy , &desc->args[2] ) );
663
664	// call local kernel function
665	process_make_kill( process , is_exit , status );
666
667	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
668	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
669	CURRENT_THREAD->core->lid , hal_time_stamp() );
670	}
671
672	/////////////////////////////////////////////////////////////////////////////////////////
673	// [6] Marshaling functions attached to RPC_THREAD_USER_CREATE (blocking)
674	/////////////////////////////////////////////////////////////////////////////////////////
675
676	/////////////////////////////////////////////////////////
677	void rpc_thread_user_create_client( cxy_t cxy,
678	pid_t pid, // in
679	void * start_func, // in
680	void * start_arg, // in
681	pthread_attr_t * attr, // in
682	xptr_t * thread_xp, // out
683	error_t * error ) // out
684	{
685	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
686	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
687	CURRENT_THREAD->core->lid , hal_time_stamp() );
688
689	assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
690
691	// initialise RPC descriptor header
692	rpc_desc_t rpc;
693	rpc.index = RPC_THREAD_USER_CREATE;
694	rpc.response = 1;
695	rpc.blocking = true;
696
697	// set input arguments in RPC descriptor
698	rpc.args[0] = (uint64_t)pid;
699	rpc.args[1] = (uint64_t)(intptr_t)start_func;
700	rpc.args[2] = (uint64_t)(intptr_t)start_arg;
701	rpc.args[3] = (uint64_t)(intptr_t)attr;
702
703	// register RPC request in remote RPC fifo (blocking function)
704	rpc_send( cxy , &rpc );
705
706	// get output arguments from RPC descriptor
707	*thread_xp = (xptr_t)rpc.args[4];
708	*error = (error_t)rpc.args[5];
709
710	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
711	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
712	CURRENT_THREAD->core->lid , hal_time_stamp() );
713	}
714
715	///////////////////////////////////////////////
716	void rpc_thread_user_create_server( xptr_t xp )
717	{
718	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
719	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
720	CURRENT_THREAD->core->lid , hal_time_stamp() );
721
722	pthread_attr_t * attr_ptr; // pointer on attributes structure in client cluster
723	pthread_attr_t attr_copy; // attributes structure copy in server cluster
724	thread_t * thread_ptr; // local pointer on thread descriptor
725	xptr_t thread_xp; // extended pointer on thread descriptor
726
727	pid_t pid; // process identifier
728	void * start_func;
729	void * start_arg;
730	error_t error;
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 pointer on attributes structure in client cluster from RPC descriptor
737
738	// get input arguments from RPC descriptor
739	pid = (pid_t) hal_remote_lwd(XPTR(client_cxy , &desc->args[0]));
740	start_func = (void *)(intptr_t) hal_remote_lwd(XPTR(client_cxy , &desc->args[1]));
741	start_arg = (void *)(intptr_t) hal_remote_lwd(XPTR(client_cxy , &desc->args[2]));
742	attr_ptr = (pthread_attr_t *)(intptr_t)hal_remote_lwd(XPTR(client_cxy , &desc->args[3]));
743
744	// makes a local copy of attributes structure
745	hal_remote_memcpy( XPTR( local_cxy , &attr_copy ),
746	XPTR( client_cxy , attr_ptr ),
747	sizeof(pthread_attr_t) );
748
749	// call kernel function
750	error = thread_user_create( pid,
751	start_func,
752	start_arg,
753	&attr_copy,
754	&thread_ptr );
755
756	// set output arguments
757	thread_xp = XPTR( local_cxy , thread_ptr );
758	hal_remote_swd( XPTR( client_cxy , &desc->args[4] ) , (uint64_t)thread_xp );
759	hal_remote_swd( XPTR( client_cxy , &desc->args[5] ) , (uint64_t)error );
760
761	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
762	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
763	CURRENT_THREAD->core->lid , hal_time_stamp() );
764	}
765
766	/////////////////////////////////////////////////////////////////////////////////////////
767	// [7] Marshaling functions attached to RPC_THREAD_KERNEL_CREATE (blocking)
768	/////////////////////////////////////////////////////////////////////////////////////////
769
770	////////////////////////////////////////////////////
771	void rpc_thread_kernel_create_client( cxy_t cxy,
772	uint32_t type, // in
773	void * func, // in
774	void * args, // in
775	xptr_t * thread_xp, // out
776	error_t * error ) // out
777	{
778	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
779	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
780	CURRENT_THREAD->core->lid , hal_time_stamp() );
781
782	assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
783
784	// initialise RPC descriptor header
785	rpc_desc_t rpc;
786	rpc.index = RPC_THREAD_KERNEL_CREATE;
787	rpc.response = 1;
788	rpc.blocking = true;
789
790	// set input arguments in RPC descriptor
791	rpc.args[0] = (uint64_t)type;
792	rpc.args[1] = (uint64_t)(intptr_t)func;
793	rpc.args[2] = (uint64_t)(intptr_t)args;
794
795	// register RPC request in remote RPC fifo (blocking function)
796	rpc_send( cxy , &rpc );
797
798	// get output arguments from RPC descriptor
799	*thread_xp = (xptr_t)rpc.args[3];
800	*error = (error_t)rpc.args[4];
801
802	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
803	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
804	CURRENT_THREAD->core->lid , hal_time_stamp() );
805	}
806
807	/////////////////////////////////////////////////
808	void rpc_thread_kernel_create_server( xptr_t xp )
809	{
810	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
811	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
812	CURRENT_THREAD->core->lid , hal_time_stamp() );
813
814	thread_t * thread_ptr; // local pointer on thread descriptor
815	xptr_t thread_xp; // extended pointer on thread descriptor
816	lid_t core_lid; // core local index
817	error_t error;
818
819	// get client cluster identifier and pointer on RPC descriptor
820	cxy_t client_cxy = (cxy_t)GET_CXY( xp );
821	rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
822
823	// get attributes from RPC descriptor
824	uint32_t type = (uint32_t) hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
825	void * func = (void*)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
826	void * args = (void*)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[2] ) );
827
828	// select one core
829	core_lid = cluster_select_local_core();
830
831	// call local kernel function
832	error = thread_kernel_create( &thread_ptr , type , func , args , core_lid );
833
834	// set output arguments
835	thread_xp = XPTR( local_cxy , thread_ptr );
836	hal_remote_swd( XPTR( client_cxy , &desc->args[1] ) , (uint64_t)error );
837	hal_remote_swd( XPTR( client_cxy , &desc->args[2] ) , (uint64_t)thread_xp );
838
839	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
840	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
841	CURRENT_THREAD->core->lid , hal_time_stamp() );
842	}
843
844	/////////////////////////////////////////////////////////////////////////////////////////
845	// [8] Marshaling functions attached to RPC_THREAD_KILL (blocking)
846	/////////////////////////////////////////////////////////////////////////////////////////
847
848	/////////////////////////////////////////////
849	void rpc_thread_kill_client( cxy_t cxy,
850	thread_t * thread ) // in
851	{
852	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
853	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
854	CURRENT_THREAD->core->lid , hal_time_stamp() );
855
856	// this RPC can be called in local cluster
857
858	// initialise RPC descriptor header
859	rpc_desc_t rpc;
860	rpc.index = RPC_THREAD_KILL;
861	rpc.response = 1;
862	rpc.blocking = true;
863
864	// set input arguments in RPC descriptor
865	rpc.args[0] = (uint64_t)(intptr_t)thread;
866
867	// register RPC request in remote RPC fifo (blocking function)
868	rpc_send( cxy , &rpc );
869
870	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
871	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
872	CURRENT_THREAD->core->lid , hal_time_stamp() );
873	}
874
875	////////////////////////////////////////
876	void rpc_thread_kill_server( xptr_t xp )
877	{
878	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
879	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
880	CURRENT_THREAD->core->lid , hal_time_stamp() );
881
882	thread_t * thread; // local pointer on process descriptor
883
884	// get client cluster identifier and pointer on RPC descriptor
885	cxy_t client_cxy = (cxy_t)GET_CXY( xp );
886	rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
887
888	// get attributes from RPC descriptor
889	thread = (thread_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
890
891	// call local kernel function
892	thread_kill( thread );
893
894	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
895	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
896	CURRENT_THREAD->core->lid , hal_time_stamp() );
897	}
898
899
900	/////////////////////////////////////////////////////////////////////////////////////////
901	// [9] Marshaling functions attached to RPC_PROCESS_SIGACTION (multicast / non blocking)
902	/////////////////////////////////////////////////////////////////////////////////////////
903
904	////////////////////////////////////////////////////
905	void rpc_process_sigaction_client( cxy_t cxy,
906	rpc_desc_t * rpc_ptr )
907	{
908	sigaction_dmsg("\n[DBG] %s : enter to %s process %x in cluster %x / cycle %d\n",
909	__FUNCTION__ , process_action_str( (uint32_t)rpc_ptr->args[0] ) ,
910	((process_t *)(intptr_t)rpc_ptr->args[1])->pid , cxy , (uint32_t)hal_get_cycles() );
911
912	// register RPC request in remote RPC fifo
913	rpc_send( cxy , rpc_ptr );
914
915	sigaction_dmsg("\n[DBG] %s : exit after %s process %x in cluster %x / cycle %d\n",
916	__FUNCTION__ , process_action_str( (uint32_t)rpc_ptr->args[0] ) ,
917	((process_t *)(intptr_t)rpc_ptr->args[1])->pid , cxy , (uint32_t)hal_get_cycles() );
918	}
919
920	//////////////////////////////////////////////
921	void rpc_process_sigaction_server( xptr_t xp )
922	{
923	process_t * process; // pointer on local process descriptor
924	uint32_t action; // sigaction index
925	thread_t * client_ptr; // local pointer on client thread in client cluster
926	cxy_t client_cxy; // client cluster identifier
927	xptr_t client_xp; // extended pointer on client thread
928	core_t * client_core; // local pointer on core running the client thread
929	rpc_desc_t * rpc; // local pointer on rpc descriptor in client cluster
930
931	// get client cluster identifier and pointer on RPC descriptor
932	client_cxy = (cxy_t)GET_CXY( xp );
933	rpc = (rpc_desc_t *)GET_PTR( xp );
934
935	// get arguments from RPC descriptor
936	action = (uint32_t) hal_remote_lwd( XPTR( client_cxy , &rpc->args[0] ) );
937	process = (process_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &rpc->args[1] ) );
938	client_ptr = (thread_t *)hal_remote_lpt( XPTR( client_cxy , &rpc->thread ) );
939
940	// build extended pointer on client thread
941	client_xp = XPTR( client_cxy , client_ptr );
942
943	sigaction_dmsg("\n[DBG] %s : enter to %s process %x / cycle %d\n",
944	__FUNCTION__ , process_action_str( action ) , process->pid , (uint32_t)hal_get_cycles() );
945
946	// call relevant kernel function
947	if (action == DELETE_ALL_THREADS ) process_delete_threads ( process );
948	else if (action == BLOCK_ALL_THREADS ) process_block_threads ( process );
949	else if (action == UNBLOCK_ALL_THREADS ) process_unblock_threads( process );
950
951	// decrement the responses counter in RPC descriptor,
952	// unblock the client thread only if it is the last response.
953	if( hal_remote_atomic_add( XPTR( client_cxy , &rpc->response ) , -1 ) == 1 )
954	{
955	client_core = (core_t *)hal_remote_lpt( XPTR( client_cxy , &client_ptr->core ) );
956	thread_unblock( client_xp , THREAD_BLOCKED_RPC );
957	dev_pic_send_ipi( client_cxy , client_core->lid );
958	}
959
960	sigaction_dmsg("\n[DBG] %s : exit after %s process %x / cycle %d\n",
961	__FUNCTION__ , process_action_str( action ) , process->pid , (uint32_t)hal_get_cycles() );
962	}
963
964	/////////////////////////////////////////////////////////////////////////////////////////
965	// [10] Marshaling functions attached to RPC_VFS_INODE_CREATE (blocking)
966	/////////////////////////////////////////////////////////////////////////////////////////
967
968	/////////////////////////////////////////////////////
969	void rpc_vfs_inode_create_client( cxy_t cxy,
970	xptr_t dentry_xp, // in
971	uint32_t fs_type, // in
972	uint32_t inode_type, // in
973	void * extend, // in
974	uint32_t attr, // in
975	uint32_t rights, // in
976	uint32_t uid, // in
977	uint32_t gid, // in
978	xptr_t * inode_xp, // out
979	error_t * error ) // out
980	{
981	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
982	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
983	CURRENT_THREAD->core->lid , hal_time_stamp() );
984
985	assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
986
987	// initialise RPC descriptor header
988	rpc_desc_t rpc;
989	rpc.index = RPC_VFS_INODE_CREATE;
990	rpc.response = 1;
991	rpc.blocking = true;
992
993	// set input arguments in RPC descriptor
994	rpc.args[0] = (uint64_t)dentry_xp;
995	rpc.args[1] = (uint64_t)fs_type;
996	rpc.args[2] = (uint64_t)inode_type;
997	rpc.args[3] = (uint64_t)(intptr_t)extend;
998	rpc.args[4] = (uint64_t)attr;
999	rpc.args[5] = (uint64_t)rights;
1000	rpc.args[6] = (uint64_t)uid;
1001	rpc.args[7] = (uint64_t)gid;
1002
1003	// register RPC request in remote RPC fifo (blocking function)
1004	rpc_send( cxy , &rpc );
1005
1006	// get output values from RPC descriptor
1007	*inode_xp = (xptr_t)rpc.args[8];
1008	*error = (error_t)rpc.args[9];
1009
1010	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
1011	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1012	CURRENT_THREAD->core->lid , hal_time_stamp() );
1013	}
1014
1015	/////////////////////////////////////////////
1016	void rpc_vfs_inode_create_server( xptr_t xp )
1017	{
1018	xptr_t dentry_xp;
1019	uint32_t fs_type;
1020	uint32_t inode_type;
1021	void * extend;
1022	uint32_t attr;
1023	uint32_t rights;
1024	uint32_t uid;
1025	uint32_t gid;
1026	xptr_t inode_xp;
1027	error_t error;
1028
1029	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
1030	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1031	CURRENT_THREAD->core->lid , hal_time_stamp() );
1032
1033	// get client cluster identifier and pointer on RPC descriptor
1034	cxy_t client_cxy = (cxy_t)GET_CXY( xp );
1035	rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
1036
1037	// get input arguments from client rpc descriptor
1038	dentry_xp = (xptr_t) hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
1039	fs_type = (uint32_t) hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
1040	inode_type = (uint32_t) hal_remote_lwd( XPTR( client_cxy , &desc->args[2] ) );
1041	extend = (void *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[3] ) );
1042	attr = (uint32_t) hal_remote_lwd( XPTR( client_cxy , &desc->args[4] ) );
1043	rights = (uint32_t) hal_remote_lwd( XPTR( client_cxy , &desc->args[5] ) );
1044	uid = (uid_t) hal_remote_lwd( XPTR( client_cxy , &desc->args[6] ) );
1045	gid = (gid_t) hal_remote_lwd( XPTR( client_cxy , &desc->args[7] ) );
1046
1047	// call local kernel function
1048	error = vfs_inode_create( dentry_xp,
1049	fs_type,
1050	inode_type,
1051	extend,
1052	attr,
1053	rights,
1054	uid,
1055	gid,
1056	&inode_xp );
1057
1058	// set output arguments
1059	hal_remote_swd( XPTR( client_cxy , &desc->args[8] ) , (uint64_t)inode_xp );
1060	hal_remote_swd( XPTR( client_cxy , &desc->args[9] ) , (uint64_t)error );
1061
1062	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
1063	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1064	CURRENT_THREAD->core->lid , hal_time_stamp() );
1065	}
1066
1067	/////////////////////////////////////////////////////////////////////////////////////////
1068	// [11] Marshaling functions attached to RPC_VFS_INODE_DESTROY (blocking)
1069	/////////////////////////////////////////////////////////////////////////////////////////
1070
1071	/////////////////////////////////////////////////////////////
1072	void rpc_vfs_inode_destroy_client( cxy_t cxy,
1073	struct vfs_inode_s * inode )
1074	{
1075	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
1076	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1077	CURRENT_THREAD->core->lid , hal_time_stamp() );
1078
1079	assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
1080
1081	// initialise RPC descriptor header
1082	rpc_desc_t rpc;
1083	rpc.index = RPC_VFS_INODE_DESTROY;
1084	rpc.response = 1;
1085	rpc.blocking = true;
1086
1087	// set input arguments in RPC descriptor
1088	rpc.args[0] = (uint64_t)(intptr_t)inode;
1089
1090	// register RPC request in remote RPC fifo (blocking function)
1091	rpc_send( cxy , &rpc );
1092
1093	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
1094	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1095	CURRENT_THREAD->core->lid , hal_time_stamp() );
1096	}
1097
1098	//////////////////////////////////////////////
1099	void rpc_vfs_inode_destroy_server( xptr_t xp )
1100	{
1101	vfs_inode_t * inode;
1102
1103	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
1104	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1105	CURRENT_THREAD->core->lid , hal_time_stamp() );
1106
1107	// get client cluster identifier and pointer on RPC descriptor
1108	cxy_t client_cxy = (cxy_t)GET_CXY( xp );
1109	rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
1110
1111	// get arguments "inode" from client RPC descriptor
1112	inode = (vfs_inode_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
1113
1114	// call local kernel function
1115	vfs_inode_destroy( inode );
1116
1117	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
1118	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1119	CURRENT_THREAD->core->lid , hal_time_stamp() );
1120	}
1121
1122	/////////////////////////////////////////////////////////////////////////////////////////
1123	// [12] Marshaling functions attached to RPC_VFS_DENTRY_CREATE (blocking)
1124	/////////////////////////////////////////////////////////////////////////////////////////
1125
1126	//////////////////////////////////////////////////////////////
1127	void rpc_vfs_dentry_create_client( cxy_t cxy,
1128	uint32_t type, // in
1129	char * name, // in
1130	struct vfs_inode_s * parent, // in
1131	xptr_t * dentry_xp, // out
1132	error_t * error ) // out
1133	{
1134	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
1135	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1136	CURRENT_THREAD->core->lid , hal_time_stamp() );
1137
1138	assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
1139
1140	// initialise RPC descriptor header
1141	rpc_desc_t rpc;
1142	rpc.index = RPC_VFS_DENTRY_CREATE;
1143	rpc.response = 1;
1144	rpc.blocking = true;
1145
1146	// set input arguments in RPC descriptor
1147	rpc.args[0] = (uint64_t)type;
1148	rpc.args[1] = (uint64_t)(intptr_t)name;
1149	rpc.args[2] = (uint64_t)(intptr_t)parent;
1150
1151	// register RPC request in remote RPC fifo (blocking function)
1152	rpc_send( cxy , &rpc );
1153
1154	// get output values from RPC descriptor
1155	*dentry_xp = (xptr_t)rpc.args[3];
1156	*error = (error_t)rpc.args[4];
1157
1158	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
1159	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1160	CURRENT_THREAD->core->lid , hal_time_stamp() );
1161	}
1162
1163	//////////////////////////////////////////////
1164	void rpc_vfs_dentry_create_server( xptr_t xp )
1165	{
1166	uint32_t type;
1167	char * name;
1168	vfs_inode_t * parent;
1169	xptr_t dentry_xp;
1170	error_t error;
1171
1172	char name_copy[CONFIG_VFS_MAX_NAME_LENGTH];
1173
1174	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
1175	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1176	CURRENT_THREAD->core->lid , hal_time_stamp() );
1177
1178	// get client cluster identifier and pointer on RPC descriptor
1179	cxy_t client_cxy = (cxy_t)GET_CXY( xp );
1180	rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
1181
1182	// get arguments "name", "type", and "parent" from client RPC descriptor
1183	type = (uint32_t) hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
1184	name = (char *)(intptr_t) hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
1185	parent = (vfs_inode_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[2] ) );
1186
1187	// makes a local copy of name
1188	hal_remote_strcpy( XPTR( local_cxy , name_copy ),
1189	XPTR( client_cxy , name ) );
1190
1191	// call local kernel function
1192	error = vfs_dentry_create( type,
1193	name_copy,
1194	parent,
1195	&dentry_xp );
1196	// set output arguments
1197	hal_remote_swd( XPTR( client_cxy , &desc->args[3] ) , (uint64_t)dentry_xp );
1198	hal_remote_swd( XPTR( client_cxy , &desc->args[4] ) , (uint64_t)error );
1199
1200	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
1201	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1202	CURRENT_THREAD->core->lid , hal_time_stamp() );
1203	}
1204
1205	/////////////////////////////////////////////////////////////////////////////////////////
1206	// [13] Marshaling functions attached to RPC_VFS_DENTRY_DESTROY (blocking)
1207	/////////////////////////////////////////////////////////////////////////////////////////
1208
1209
1210	///////////////////////////////////////////////////////
1211	void rpc_vfs_dentry_destroy_client( cxy_t cxy,
1212	vfs_dentry_t * dentry )
1213	{
1214	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
1215	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1216	CURRENT_THREAD->core->lid , hal_time_stamp() );
1217
1218	assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
1219
1220	// initialise RPC descriptor header
1221	rpc_desc_t rpc;
1222	rpc.index = RPC_VFS_DENTRY_DESTROY;
1223	rpc.response = 1;
1224	rpc.blocking = true;
1225
1226	// set input arguments in RPC descriptor
1227	rpc.args[0] = (uint64_t)(intptr_t)dentry;
1228
1229	// register RPC request in remote RPC fifo (blocking function)
1230	rpc_send( cxy , &rpc );
1231
1232	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
1233	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1234	CURRENT_THREAD->core->lid , hal_time_stamp() );
1235	}
1236
1237	///////////////////////////////////////////////
1238	void rpc_vfs_dentry_destroy_server( xptr_t xp )
1239	{
1240	vfs_dentry_t * dentry;
1241
1242	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
1243	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1244	CURRENT_THREAD->core->lid , hal_time_stamp() );
1245
1246	// get client cluster identifier and pointer on RPC descriptor
1247	cxy_t client_cxy = (cxy_t)GET_CXY( xp );
1248	rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
1249
1250	// get arguments "dentry" from client RPC descriptor
1251	dentry = (vfs_dentry_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
1252
1253	// call local kernel function
1254	vfs_dentry_destroy( dentry );
1255
1256	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
1257	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1258	CURRENT_THREAD->core->lid , hal_time_stamp() );
1259	}
1260
1261
1262	/////////////////////////////////////////////////////////////////////////////////////////
1263	// [14] Marshaling functions attached to RPC_VFS_FILE_CREATE (blocking)
1264	/////////////////////////////////////////////////////////////////////////////////////////
1265
1266	//////////////////////////////////////////////////////////////
1267	void rpc_vfs_file_create_client( cxy_t cxy,
1268	struct vfs_inode_s * inode, // in
1269	uint32_t file_attr, // in
1270	xptr_t * file_xp, // out
1271	error_t * error ) // out
1272	{
1273	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
1274	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1275	CURRENT_THREAD->core->lid , hal_time_stamp() );
1276
1277	assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
1278
1279	// initialise RPC descriptor header
1280	rpc_desc_t rpc;
1281	rpc.index = RPC_VFS_FILE_CREATE;
1282	rpc.response = 1;
1283	rpc.blocking = true;
1284
1285	// set input arguments in RPC descriptor
1286	rpc.args[0] = (uint64_t)(intptr_t)inode;
1287	rpc.args[1] = (uint64_t)file_attr;
1288
1289	// register RPC request in remote RPC fifo (blocking function)
1290	rpc_send( cxy , &rpc );
1291
1292	// get output values from RPC descriptor
1293	*file_xp = (xptr_t)rpc.args[2];
1294	*error = (error_t)rpc.args[3];
1295
1296	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
1297	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1298	CURRENT_THREAD->core->lid , hal_time_stamp() );
1299	}
1300
1301	////////////////////////////////////////////
1302	void rpc_vfs_file_create_server( xptr_t xp )
1303	{
1304	uint32_t file_attr;
1305	vfs_inode_t * inode;
1306	xptr_t file_xp;
1307	error_t error;
1308
1309	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
1310	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1311	CURRENT_THREAD->core->lid , hal_time_stamp() );
1312
1313	// get client cluster identifier and pointer on RPC descriptor
1314	cxy_t client_cxy = (cxy_t)GET_CXY( xp );
1315	rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
1316
1317	// get arguments "file_attr" and "inode" from client RPC descriptor
1318	inode = (vfs_inode_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
1319	file_attr = (uint32_t) hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
1320
1321	// call local kernel function
1322	error = vfs_file_create( inode,
1323	file_attr,
1324	&file_xp );
1325
1326	// set output arguments
1327	hal_remote_swd( XPTR( client_cxy , &desc->args[2] ) , (uint64_t)file_xp );
1328	hal_remote_swd( XPTR( client_cxy , &desc->args[3] ) , (uint64_t)error );
1329
1330	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
1331	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1332	CURRENT_THREAD->core->lid , hal_time_stamp() );
1333	}
1334
1335	/////////////////////////////////////////////////////////////////////////////////////////
1336	// [15] Marshaling functions attached to RPC_VFS_FILE_DESTROY (blocking)
1337	/////////////////////////////////////////////////////////////////////////////////////////
1338
1339	///////////////////////////////////////////////////
1340	void rpc_vfs_file_destroy_client( cxy_t cxy,
1341	vfs_file_t * file )
1342	{
1343	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
1344	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1345	CURRENT_THREAD->core->lid , hal_time_stamp() );
1346
1347	assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
1348
1349	// initialise RPC descriptor header
1350	rpc_desc_t rpc;
1351	rpc.index = RPC_VFS_FILE_DESTROY;
1352	rpc.response = 1;
1353	rpc.blocking = true;
1354
1355	// set input arguments in RPC descriptor
1356	rpc.args[0] = (uint64_t)(intptr_t)file;
1357
1358	// register RPC request in remote RPC fifo (blocking function)
1359	rpc_send( cxy , &rpc );
1360
1361	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
1362	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1363	CURRENT_THREAD->core->lid , hal_time_stamp() );
1364	}
1365
1366	/////////////////////////////////////////////
1367	void rpc_vfs_file_destroy_server( xptr_t xp )
1368	{
1369	vfs_file_t * file;
1370
1371	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
1372	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1373	CURRENT_THREAD->core->lid , hal_time_stamp() );
1374
1375	// get client cluster identifier and pointer on RPC descriptor
1376	cxy_t client_cxy = (cxy_t)GET_CXY( xp );
1377	rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
1378
1379	// get arguments "dentry" from client RPC descriptor
1380	file = (vfs_file_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
1381
1382	// call local kernel function
1383	vfs_file_destroy( file );
1384
1385	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
1386	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1387	CURRENT_THREAD->core->lid , hal_time_stamp() );
1388	}
1389
1390	/////////////////////////////////////////////////////////////////////////////////////////
1391	// [16] Marshaling functions attached to RPC_VFS_INODE_LOAD (blocking)
1392	/////////////////////////////////////////////////////////////////////////////////////////
1393
1394	//////////////////////////////////////////////////
1395	void rpc_vfs_inode_load_client( cxy_t cxy,
1396	vfs_inode_t * parent_inode, // in
1397	char * name, // in
1398	xptr_t child_inode_xp, // in
1399	error_t * error ) // out
1400	{
1401	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
1402	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1403	CURRENT_THREAD->core->lid , hal_time_stamp() );
1404
1405	assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
1406
1407	// initialise RPC descriptor header
1408	rpc_desc_t rpc;
1409	rpc.index = RPC_VFS_INODE_LOAD;
1410	rpc.response = 1;
1411	rpc.blocking = true;
1412
1413	// set input arguments in RPC descriptor
1414	rpc.args[0] = (uint64_t)(intptr_t)parent_inode;
1415	rpc.args[1] = (uint64_t)(intptr_t)name;
1416	rpc.args[2] = (uint64_t)child_inode_xp;
1417
1418	// register RPC request in remote RPC fifo (blocking function)
1419	rpc_send( cxy , &rpc );
1420
1421	// get output values from RPC descriptor
1422	*error = (error_t)rpc.args[3];
1423
1424	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
1425	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1426	CURRENT_THREAD->core->lid , hal_time_stamp() );
1427	}
1428
1429	///////////////////////////////////////////
1430	void rpc_vfs_inode_load_server( xptr_t xp )
1431	{
1432	error_t error;
1433	vfs_inode_t * parent;
1434	xptr_t child_xp;
1435	char * name;
1436
1437	char name_copy[CONFIG_VFS_MAX_NAME_LENGTH];
1438
1439	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
1440	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1441	CURRENT_THREAD->core->lid , hal_time_stamp() );
1442
1443	// get client cluster identifier and pointer on RPC descriptor
1444	cxy_t client_cxy = (cxy_t)GET_CXY( xp );
1445	rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
1446
1447	// get arguments "parent", "name", and "child_xp"
1448	parent = (vfs_inode_t*)(intptr_t)hal_remote_lwd(XPTR(client_cxy , &desc->args[0]));
1449	name = (char*)(intptr_t) hal_remote_lwd(XPTR(client_cxy , &desc->args[1]));
1450	child_xp = (xptr_t) hal_remote_lwd(XPTR(client_cxy , &desc->args[2]));
1451
1452	// get name local copy
1453	hal_remote_strcpy( XPTR( local_cxy , name_copy ) ,
1454	XPTR( client_cxy , name ) );
1455
1456	// call the kernel function
1457	error = vfs_inode_load( parent , name_copy , child_xp );
1458
1459	// set output argument
1460	hal_remote_swd( XPTR( client_cxy , &desc->args[3] ) , (uint64_t)error );
1461
1462	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
1463	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1464	CURRENT_THREAD->core->lid , hal_time_stamp() );
1465	}
1466
1467	/////////////////////////////////////////////////////////////////////////////////////////
1468	// [17] Marshaling functions attached to RPC_VFS_MAPPER_LOAD_ALL (blocking)
1469	/////////////////////////////////////////////////////////////////////////////////////////
1470
1471	///////////////////////////////////////////////////////
1472	void rpc_vfs_mapper_load_all_client( cxy_t cxy,
1473	vfs_inode_t * inode, // in
1474	error_t * error ) // out
1475	{
1476	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
1477	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1478	CURRENT_THREAD->core->lid , hal_time_stamp() );
1479
1480	assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
1481
1482	// initialise RPC descriptor header
1483	rpc_desc_t rpc;
1484	rpc.index = RPC_VFS_MAPPER_LOAD_ALL;
1485	rpc.response = 1;
1486	rpc.blocking = true;
1487
1488	// set input arguments in RPC descriptor
1489	rpc.args[0] = (uint64_t)(intptr_t)inode;
1490
1491	// register RPC request in remote RPC fifo (blocking function)
1492	rpc_send( cxy , &rpc );
1493
1494	// get output values from RPC descriptor
1495	*error = (error_t)rpc.args[1];
1496
1497	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
1498	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1499	CURRENT_THREAD->core->lid , hal_time_stamp() );
1500	}
1501
1502	////////////////////////////////////////////////
1503	void rpc_vfs_mapper_load_all_server( xptr_t xp )
1504	{
1505	error_t error;
1506	vfs_inode_t * inode;
1507
1508	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
1509	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1510	CURRENT_THREAD->core->lid , hal_time_stamp() );
1511
1512	// get client cluster identifier and pointer on RPC descriptor
1513	cxy_t client_cxy = (cxy_t)GET_CXY( xp );
1514	rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
1515
1516	// get arguments "parent", "name", and "child_xp"
1517	inode = (vfs_inode_t*)(intptr_t)hal_remote_lwd(XPTR(client_cxy , &desc->args[0]));
1518
1519	// call the kernel function
1520	error = vfs_mapper_load_all( inode );
1521
1522	// set output argument
1523	hal_remote_swd( XPTR( client_cxy , &desc->args[1] ) , (uint64_t)error );
1524
1525	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
1526	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1527	CURRENT_THREAD->core->lid , hal_time_stamp() );
1528	}
1529
1530	/////////////////////////////////////////////////////////////////////////////////////////
1531	// [18] Marshaling functions attached to RPC_FATFS_GET_CLUSTER (blocking)
1532	/////////////////////////////////////////////////////////////////////////////////////////
1533
1534	//////////////////////////////////////////////////
1535	void rpc_fatfs_get_cluster_client( cxy_t cxy,
1536	mapper_t * mapper, // in
1537	uint32_t first, // in
1538	uint32_t index, // in
1539	uint32_t * cluster, // out
1540	error_t * error ) // out
1541	{
1542	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
1543	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1544	CURRENT_THREAD->core->lid , hal_time_stamp() );
1545
1546	assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
1547
1548	// initialise RPC descriptor header
1549	rpc_desc_t rpc;
1550	rpc.index = RPC_FATFS_GET_CLUSTER;
1551	rpc.response = 1;
1552	rpc.blocking = true;
1553
1554	// set input arguments in RPC descriptor
1555	rpc.args[0] = (uint64_t)(intptr_t)mapper;
1556	rpc.args[1] = (uint64_t)first;
1557	rpc.args[2] = (uint64_t)index;
1558
1559	// register RPC request in remote RPC fifo
1560	rpc_send( cxy , &rpc );
1561
1562	// get output argument from rpc descriptor
1563	*cluster = (uint32_t)rpc.args[3];
1564	*error = (error_t)rpc.args[4];
1565
1566	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
1567	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1568	CURRENT_THREAD->core->lid , hal_time_stamp() );
1569	}
1570
1571	//////////////////////////////////////////////
1572	void rpc_fatfs_get_cluster_server( xptr_t xp )
1573	{
1574	mapper_t * mapper;
1575	uint32_t first;
1576	uint32_t index;
1577	uint32_t cluster;
1578	error_t error;
1579
1580	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
1581	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1582	CURRENT_THREAD->core->lid , hal_time_stamp() );
1583
1584	// get client cluster identifier and pointer on RPC descriptor
1585	cxy_t client_cxy = (cxy_t)GET_CXY( xp );
1586	rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
1587
1588	// get input arguments
1589	mapper = (mapper_t *)(intptr_t)hal_remote_lpt( XPTR( client_cxy , &desc->args[0] ) );
1590	first = (uint32_t) hal_remote_lw ( XPTR( client_cxy , &desc->args[1] ) );
1591	index = (uint32_t) hal_remote_lw ( XPTR( client_cxy , &desc->args[2] ) );
1592
1593	// call the kernel function
1594	error = fatfs_get_cluster( mapper , first , index , &cluster );
1595
1596	// set output argument
1597	hal_remote_swd( XPTR( client_cxy , &desc->args[3] ) , (uint64_t)cluster );
1598	hal_remote_swd( XPTR( client_cxy , &desc->args[4] ) , (uint64_t)error );
1599
1600	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
1601	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1602	CURRENT_THREAD->core->lid , hal_time_stamp() );
1603	}
1604
1605	/////////////////////////////////////////////////////////////////////////////////////////
1606	// [20] Marshaling functions attached to RPC_VMM_GET_VSEG (blocking)
1607	/////////////////////////////////////////////////////////////////////////////////////////
1608
1609	//////////////////////////////////////////////////
1610	void rpc_vmm_get_vseg_client( cxy_t cxy,
1611	process_t * process, // in
1612	intptr_t vaddr, // in
1613	xptr_t * vseg_xp, // out
1614	error_t * error ) // out
1615	{
1616	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
1617	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1618	CURRENT_THREAD->core->lid , hal_time_stamp() );
1619
1620	assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
1621
1622	// initialise RPC descriptor header
1623	rpc_desc_t rpc;
1624	rpc.index = RPC_VMM_GET_VSEG;
1625	rpc.response = 1;
1626	rpc.blocking = true;
1627
1628	// set input arguments in RPC descriptor
1629	rpc.args[0] = (uint64_t)(intptr_t)process;
1630	rpc.args[1] = (uint64_t)vaddr;
1631
1632	// register RPC request in remote RPC fifo (blocking function)
1633	rpc_send( cxy , &rpc );
1634
1635	// get output argument from rpc descriptor
1636	*vseg_xp = rpc.args[2];
1637	*error = (error_t)rpc.args[3];
1638
1639	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
1640	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1641	CURRENT_THREAD->core->lid , hal_time_stamp() );
1642	}
1643
1644	/////////////////////////////////////////
1645	void rpc_vmm_get_vseg_server( xptr_t xp )
1646	{
1647	process_t * process;
1648	intptr_t vaddr;
1649	vseg_t * vseg_ptr;
1650	xptr_t vseg_xp;
1651	error_t error;
1652
1653	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
1654	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1655	CURRENT_THREAD->core->lid , hal_time_stamp() );
1656
1657	// get client cluster identifier and pointer on RPC descriptor
1658	cxy_t client_cxy = (cxy_t)GET_CXY( xp );
1659	rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
1660
1661	// get input argument from client RPC descriptor
1662	process = (process_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
1663	vaddr = (intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
1664
1665	// call local kernel function
1666	error = vmm_get_vseg( process , vaddr , &vseg_ptr );
1667
1668	// set output arguments to client RPC descriptor
1669	vseg_xp = XPTR( local_cxy , vseg_ptr );
1670	hal_remote_swd( XPTR( client_cxy , &desc->args[2] ) , (uint64_t)vseg_xp );
1671	hal_remote_swd( XPTR( client_cxy , &desc->args[3] ) , (uint64_t)error );
1672
1673	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
1674	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1675	CURRENT_THREAD->core->lid , hal_time_stamp() );
1676	}
1677
1678
1679	/////////////////////////////////////////////////////////////////////////////////////////
1680	// [21] Marshaling functions attached to RPC_VMM_GET_PTE (blocking)
1681	/////////////////////////////////////////////////////////////////////////////////////////
1682
1683	////////////////////////////////////////////
1684	void rpc_vmm_get_pte_client( cxy_t cxy,
1685	process_t * process, // in
1686	vpn_t vpn, // in
1687	bool_t cow, // in
1688	uint32_t * attr, // out
1689	ppn_t * ppn, // out
1690	error_t * error ) // out
1691	{
1692	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
1693	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1694	CURRENT_THREAD->core->lid , hal_time_stamp() );
1695
1696	assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
1697
1698	// initialise RPC descriptor header
1699	rpc_desc_t rpc;
1700	rpc.index = RPC_VMM_GET_PTE;
1701	rpc.response = 1;
1702	rpc.blocking = true;
1703
1704	// set input arguments in RPC descriptor
1705	rpc.args[0] = (uint64_t)(intptr_t)process;
1706	rpc.args[1] = (uint64_t)vpn;
1707	rpc.args[2] = (uint64_t)cow;
1708
1709	// register RPC request in remote RPC fifo (blocking function)
1710	rpc_send( cxy , &rpc );
1711
1712	// get output argument from rpc descriptor
1713	*attr = (uint32_t)rpc.args[3];
1714	*ppn = (ppn_t)rpc.args[4];
1715	*error = (error_t)rpc.args[5];
1716
1717	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
1718	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1719	CURRENT_THREAD->core->lid , hal_time_stamp() );
1720	}
1721
1722	////////////////////////////////////////
1723	void rpc_vmm_get_pte_server( xptr_t xp )
1724	{
1725	process_t * process;
1726	vpn_t vpn;
1727	bool_t cow;
1728	uint32_t attr;
1729	ppn_t ppn;
1730	error_t error;
1731
1732	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
1733	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1734	CURRENT_THREAD->core->lid , hal_time_stamp() );
1735
1736	// get client cluster identifier and pointer on RPC descriptor
1737	cxy_t client_cxy = (cxy_t)GET_CXY( xp );
1738	rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
1739
1740	// get input argument "process" & "vpn" from client RPC descriptor
1741	process = (process_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
1742	vpn = (vpn_t) hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
1743	cow = (bool_t) hal_remote_lwd( XPTR( client_cxy , &desc->args[2] ) );
1744
1745	// call local kernel function
1746	error = vmm_get_pte( process , vpn , cow , &attr , &ppn );
1747
1748	// set output argument "attr" & "ppn" to client RPC descriptor
1749	hal_remote_swd( XPTR( client_cxy , &desc->args[3] ) , (uint64_t)attr );
1750	hal_remote_swd( XPTR( client_cxy , &desc->args[4] ) , (uint64_t)ppn );
1751	hal_remote_swd( XPTR( client_cxy , &desc->args[5] ) , (uint64_t)error );
1752
1753	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
1754	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1755	CURRENT_THREAD->core->lid , hal_time_stamp() );
1756	}
1757
1758	/////////////////////////////////////////////////////////////////////////////////////////
1759	// [22] Marshaling functions attached to RPC_KCM_ALLOC (blocking)
1760	/////////////////////////////////////////////////////////////////////////////////////////
1761
1762	//////////////////////////////////////////
1763	void rpc_kcm_alloc_client( cxy_t cxy,
1764	uint32_t kmem_type, // in
1765	xptr_t * buf_xp ) // out
1766	{
1767	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
1768	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1769	CURRENT_THREAD->core->lid , hal_time_stamp() );
1770
1771	assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
1772
1773	// initialise RPC descriptor header
1774	rpc_desc_t rpc;
1775	rpc.index = RPC_THREAD_USER_CREATE;
1776	rpc.response = 1;
1777	rpc.blocking = true;
1778
1779	// set input arguments in RPC descriptor
1780	rpc.args[0] = (uint64_t)kmem_type;
1781
1782	// register RPC request in remote RPC fifo (blocking function)
1783	rpc_send( cxy , &rpc );
1784
1785	// get output arguments from RPC descriptor
1786	*buf_xp = (xptr_t)rpc.args[1];
1787
1788	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
1789	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1790	CURRENT_THREAD->core->lid , hal_time_stamp() );
1791	}
1792
1793	//////////////////////////////////////
1794	void rpc_kcm_alloc_server( xptr_t xp )
1795	{
1796	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
1797	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1798	CURRENT_THREAD->core->lid , hal_time_stamp() );
1799
1800	// get client cluster identifier and pointer on RPC descriptor
1801	cxy_t client_cxy = (cxy_t)GET_CXY( xp );
1802	rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
1803
1804	// get input argument "kmem_type" from client RPC descriptor
1805	uint32_t kmem_type = (uint32_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
1806
1807	// allocates memory for kcm
1808	kmem_req_t req;
1809	req.type = kmem_type;
1810	req.flags = AF_ZERO;
1811	void * buf_ptr = kmem_alloc( &req );
1812
1813	// set output argument
1814	xptr_t buf_xp = XPTR( local_cxy , buf_ptr );
1815	hal_remote_swd( XPTR( client_cxy , &desc->args[1] ) , (uint64_t)buf_xp );
1816
1817	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
1818	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1819	CURRENT_THREAD->core->lid , hal_time_stamp() );
1820	}
1821
1822	/////////////////////////////////////////////////////////////////////////////////////////
1823	// [23] Marshaling functions attached to RPC_KCM_FREE (blocking)
1824	/////////////////////////////////////////////////////////////////////////////////////////
1825
1826	/////////////////////////////////////////
1827	void rpc_kcm_free_client( cxy_t cxy,
1828	void * buf, // in
1829	uint32_t kmem_type ) // in
1830	{
1831	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
1832	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1833	CURRENT_THREAD->core->lid , hal_time_stamp() );
1834
1835	assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
1836
1837	// initialise RPC descriptor header
1838	rpc_desc_t rpc;
1839	rpc.index = RPC_THREAD_USER_CREATE;
1840	rpc.response = 1;
1841	rpc.blocking = true;
1842
1843	// set input arguments in RPC descriptor
1844	rpc.args[0] = (uint64_t)(intptr_t)buf;
1845	rpc.args[1] = (uint64_t)kmem_type;
1846
1847	// register RPC request in remote RPC fifo (blocking function)
1848	rpc_send( cxy , &rpc );
1849
1850	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
1851	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1852	CURRENT_THREAD->core->lid , hal_time_stamp() );
1853	}
1854
1855	/////////////////////////////////////
1856	void rpc_kcm_free_server( xptr_t xp )
1857	{
1858	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
1859	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1860	CURRENT_THREAD->core->lid , hal_time_stamp() );
1861
1862	// get client cluster identifier and pointer on RPC descriptor
1863	cxy_t client_cxy = (cxy_t)GET_CXY( xp );
1864	rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
1865
1866	// get input arguments "buf" and "kmem_type" from client RPC descriptor
1867	void * buf = (void *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
1868	uint32_t kmem_type = (uint32_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
1869
1870	// releases memory
1871	kmem_req_t req;
1872	req.type = kmem_type;
1873	req.ptr = buf;
1874	kmem_free( &req );
1875
1876	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
1877	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1878	CURRENT_THREAD->core->lid , hal_time_stamp() );
1879	}
1880
1881	/////////////////////////////////////////////////////////////////////////////////////////
1882	// [24] Marshaling functions attached to RPC_MAPPER_MOVE_BUFFER
1883	/////////////////////////////////////////////////////////////////////////////////////////
1884
1885	///////////////////////////////////////////////////
1886	void rpc_mapper_move_buffer_client( cxy_t cxy,
1887	mapper_t * mapper, // in
1888	bool_t to_buffer, // in
1889	bool_t is_user, // in
1890	uint32_t file_offset, // in
1891	uint64_t buffer, // in
1892	uint32_t size, // in
1893	error_t * error ) // out
1894	{
1895	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
1896	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1897	CURRENT_THREAD->core->lid , hal_time_stamp() );
1898
1899	assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
1900
1901	// initialise RPC descriptor header
1902	rpc_desc_t rpc;
1903	rpc.index = RPC_MAPPER_MOVE_BUFFER;
1904	rpc.response = 1;
1905	rpc.blocking = true;
1906
1907	// set input arguments in RPC descriptor
1908	rpc.args[0] = (uint64_t)(intptr_t)mapper;
1909	rpc.args[1] = (uint64_t)to_buffer;
1910	rpc.args[2] = (uint64_t)is_user;
1911	rpc.args[3] = (uint64_t)file_offset;
1912	rpc.args[4] = (uint64_t)buffer;
1913	rpc.args[5] = (uint64_t)size;
1914
1915	// register RPC request in remote RPC fifo (blocking function)
1916	rpc_send( cxy , &rpc );
1917
1918	// get output values from RPC descriptor
1919	*error = (error_t)rpc.args[6];
1920
1921	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
1922	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1923	CURRENT_THREAD->core->lid , hal_time_stamp() );
1924	}
1925
1926	///////////////////////////////////////////////
1927	void rpc_mapper_move_buffer_server( xptr_t xp )
1928	{
1929	mapper_t * mapper;
1930	bool_t to_buffer;
1931	bool_t is_user;
1932	uint32_t file_offset;
1933	void * user_buffer;
1934	xptr_t kern_buffer;
1935	uint32_t size;
1936	error_t error;
1937
1938	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
1939	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1940	CURRENT_THREAD->core->lid , hal_time_stamp() );
1941
1942	// get client cluster identifier and pointer on RPC descriptor
1943	cxy_t client_cxy = (cxy_t)GET_CXY( xp );
1944	rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
1945
1946	// get arguments from client RPC descriptor
1947	mapper = (mapper_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
1948	to_buffer = hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
1949	is_user = hal_remote_lwd( XPTR( client_cxy , &desc->args[2] ) );
1950	file_offset = hal_remote_lwd( XPTR( client_cxy , &desc->args[3] ) );
1951	size = hal_remote_lwd( XPTR( client_cxy , &desc->args[5] ) );
1952
1953	// call local kernel function
1954	if( is_user )
1955	{
1956	user_buffer = (void *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[4] ) );
1957
1958	error = mapper_move_user( mapper,
1959	to_buffer,
1960	file_offset,
1961	user_buffer,
1962	size );
1963	}
1964	else
1965	{
1966	kern_buffer = (xptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[4] ) );
1967
1968	error = mapper_move_kernel( mapper,
1969	to_buffer,
1970	file_offset,
1971	kern_buffer,
1972	size );
1973	}
1974
1975	// set output argument to client RPC descriptor
1976	hal_remote_swd( XPTR( client_cxy , &desc->args[6] ) , (uint64_t)error );
1977
1978	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
1979	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1980	CURRENT_THREAD->core->lid , hal_time_stamp() );
1981	}
1982
1983	/////////////////////////////////////////////////////////////////////////////////////////
1984	// [25] Marshaling functions attached to RPC_MAPPER_GET_PAGE (blocking)
1985	/////////////////////////////////////////////////////////////////////////////////////////
1986
1987	///////////////////////////////////////////////////////
1988	void rpc_mapper_get_page_client( cxy_t cxy,
1989	struct mapper_s * mapper, // in
1990	uint32_t index, // in
1991	page_t ** page ) // out
1992	{
1993	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
1994	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
1995	CURRENT_THREAD->core->lid , hal_time_stamp() );
1996
1997	assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
1998
1999	// initialise RPC descriptor header
2000	rpc_desc_t rpc;
2001	rpc.index = RPC_MAPPER_GET_PAGE;
2002	rpc.response = 1;
2003	rpc.blocking = true;
2004
2005	// set input arguments in RPC descriptor
2006	rpc.args[0] = (uint64_t)(intptr_t)mapper;
2007	rpc.args[1] = (uint64_t)index;
2008
2009	// register RPC request in remote RPC fifo (blocking function)
2010	rpc_send( cxy , &rpc );
2011
2012	// get output values from RPC descriptor
2013	page = (page_t )(intptr_t)rpc.args[2];
2014
2015	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
2016	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
2017	CURRENT_THREAD->core->lid , hal_time_stamp() );
2018	}
2019
2020	////////////////////////////////////////////
2021	void rpc_mapper_get_page_server( xptr_t xp )
2022	{
2023	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
2024	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
2025	CURRENT_THREAD->core->lid , hal_time_stamp() );
2026
2027	// get client cluster identifier and pointer on RPC descriptor
2028	cxy_t cxy = (cxy_t)GET_CXY( xp );
2029	rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
2030
2031	// get input arguments from client RPC descriptor
2032	mapper_t * mapper = (mapper_t *)(intptr_t)hal_remote_lwd( XPTR( cxy , &desc->args[0] ) );
2033	uint32_t index = (uint32_t) hal_remote_lwd( XPTR( cxy , &desc->args[1] ) );
2034
2035	// call local pmem allocator
2036	page_t * page = mapper_get_page( mapper , index );
2037
2038	// set output arguments into client RPC descriptor
2039	hal_remote_swd( XPTR( cxy , &desc->args[1] ) , (uint64_t)(intptr_t)page );
2040
2041	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
2042	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
2043	CURRENT_THREAD->core->lid , hal_time_stamp() );
2044	}
2045
2046	/////////////////////////////////////////////////////////////////////////////////////////
2047	// [26] Marshaling functions attached to RPC_VMM_CREATE_VSEG (blocking)
2048	/////////////////////////////////////////////////////////////////////////////////////////
2049
2050	////////////////////////////////////////////////////////
2051	void rpc_vmm_create_vseg_client( cxy_t cxy,
2052	struct process_s * process,
2053	vseg_type_t type,
2054	intptr_t base,
2055	uint32_t size,
2056	uint32_t file_offset,
2057	uint32_t file_size,
2058	xptr_t mapper_xp,
2059	cxy_t vseg_cxy,
2060	struct vseg_s ** vseg )
2061	{
2062	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
2063	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
2064	CURRENT_THREAD->core->lid , hal_time_stamp() );
2065
2066	assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
2067
2068	// initialise RPC descriptor header
2069	rpc_desc_t rpc;
2070	rpc.index = RPC_VMM_CREATE_VSEG;
2071	rpc.response = 1;
2072	rpc.blocking = true;
2073
2074	// set input arguments in RPC descriptor
2075	rpc.args[0] = (uint64_t)(intptr_t)process;
2076	rpc.args[1] = (uint64_t)type;
2077	rpc.args[2] = (uint64_t)base;
2078	rpc.args[3] = (uint64_t)size;
2079	rpc.args[4] = (uint64_t)file_offset;
2080	rpc.args[5] = (uint64_t)file_size;
2081	rpc.args[6] = (uint64_t)mapper_xp;
2082	rpc.args[7] = (uint64_t)vseg_cxy;
2083
2084	// register RPC request in remote RPC fifo (blocking function)
2085	rpc_send( cxy , &rpc );
2086
2087	// get output values from RPC descriptor
2088	vseg = (vseg_t )(intptr_t)rpc.args[8];
2089
2090	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
2091	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
2092	CURRENT_THREAD->core->lid , hal_time_stamp() );
2093	}
2094
2095	////////////////////////////////////////////
2096	void rpc_vmm_create_vseg_server( xptr_t xp )
2097	{
2098	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
2099	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
2100	CURRENT_THREAD->core->lid , hal_time_stamp() );
2101
2102	// get client cluster identifier and pointer on RPC descriptor
2103	cxy_t cxy = (cxy_t)GET_CXY( xp );
2104	rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
2105
2106	// get input arguments from client RPC descriptor
2107	process_t * process = (process_t *)(intptr_t)hal_remote_lwd( XPTR(cxy , &desc->args[0]));
2108	vseg_type_t type = (vseg_type_t)(uint32_t)hal_remote_lwd( XPTR(cxy , &desc->args[1]));
2109	intptr_t base = (intptr_t) hal_remote_lwd( XPTR(cxy , &desc->args[2]));
2110	uint32_t size = (uint32_t) hal_remote_lwd( XPTR(cxy , &desc->args[3]));
2111	uint32_t file_offset = (uint32_t) hal_remote_lwd( XPTR(cxy , &desc->args[4]));
2112	uint32_t file_size = (uint32_t) hal_remote_lwd( XPTR(cxy , &desc->args[5]));
2113	xptr_t mapper_xp = (xptr_t) hal_remote_lwd( XPTR(cxy , &desc->args[6]));
2114	cxy_t vseg_cxy = (cxy_t)(uint32_t) hal_remote_lwd( XPTR(cxy , &desc->args[7]));
2115
2116	// call local kernel function
2117	vseg_t * vseg = vmm_create_vseg( process,
2118	type,
2119	base,
2120	size,
2121	file_offset,
2122	file_size,
2123	mapper_xp,
2124	vseg_cxy );
2125
2126	// set output arguments into client RPC descriptor
2127	hal_remote_swd( XPTR( cxy , &desc->args[8] ) , (uint64_t)(intptr_t)vseg );
2128
2129	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
2130	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
2131	CURRENT_THREAD->core->lid , hal_time_stamp() );
2132	}
2133
2134	/////////////////////////////////////////////////////////////////////////////////////////
2135	// [27] Marshaling functions attached to RPC_SCHED_DISPLAY (blocking)
2136	/////////////////////////////////////////////////////////////////////////////////////////
2137
2138	////////////////////////////////////////////////////////
2139	void rpc_sched_display_client( cxy_t cxy,
2140	lid_t lid)
2141	{
2142	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
2143	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
2144	CURRENT_THREAD->core->lid , hal_time_stamp() );
2145
2146	assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
2147
2148	// initialise RPC descriptor header
2149	rpc_desc_t rpc;
2150	rpc.index = RPC_SCHED_DISPLAY;
2151	rpc.response = 1;
2152	rpc.blocking = true;
2153
2154	// set input arguments in RPC descriptor
2155	rpc.args[0] = (uint64_t)lid;
2156
2157	// register RPC request in remote RPC fifo (blocking function)
2158	rpc_send( cxy , &rpc );
2159
2160	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
2161	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
2162	CURRENT_THREAD->core->lid , hal_time_stamp() );
2163	}
2164
2165	//////////////////////////////////////////
2166	void rpc_sched_display_server( xptr_t xp )
2167	{
2168	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
2169	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
2170	CURRENT_THREAD->core->lid , hal_time_stamp() );
2171
2172	// get client cluster identifier and pointer on RPC descriptor
2173	cxy_t cxy = (cxy_t)GET_CXY( xp );
2174	rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
2175
2176	// get input arguments from client RPC descriptor
2177	lid_t lid = (lid_t)hal_remote_lwd( XPTR(cxy , &desc->args[0]));
2178
2179	// call local kernel function
2180	sched_display( lid );
2181
2182	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
2183	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
2184	CURRENT_THREAD->core->lid , hal_time_stamp() );
2185	}
2186
2187	/////////////////////////////////////////////////////////////////////////////////////////
2188	// [28] Marshaling functions attached to RPC_VMM_SET_COW (blocking)
2189	/////////////////////////////////////////////////////////////////////////////////////////
2190
2191	/////////////////////////////////////////////
2192	void rpc_vmm_set_cow_client( cxy_t cxy,
2193	process_t * process )
2194	{
2195	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
2196	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
2197	CURRENT_THREAD->core->lid , hal_time_stamp() );
2198
2199	assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
2200
2201	// initialise RPC descriptor header
2202	rpc_desc_t rpc;
2203	rpc.index = RPC_VMM_SET_COW;
2204	rpc.response = 1;
2205	rpc.blocking = true;
2206
2207	// set input arguments in RPC descriptor
2208	rpc.args[0] = (uint64_t)(intptr_t)process;
2209
2210	// register RPC request in remote RPC fifo (blocking function)
2211	rpc_send( cxy , &rpc );
2212
2213	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
2214	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
2215	CURRENT_THREAD->core->lid , hal_time_stamp() );
2216	}
2217
2218	////////////////////////////////////////
2219	void rpc_vmm_set_cow_server( xptr_t xp )
2220	{
2221	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
2222	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
2223	CURRENT_THREAD->core->lid , hal_time_stamp() );
2224
2225	process_t * process;
2226
2227	// get client cluster identifier and pointer on RPC descriptor
2228	cxy_t cxy = (cxy_t)GET_CXY( xp );
2229	rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
2230
2231	// get input arguments from client RPC descriptor
2232	process = (process_t *)(intptr_t)hal_remote_lwd( XPTR(cxy , &desc->args[0]));
2233
2234	// call local kernel function
2235	vmm_set_cow( process );
2236
2237	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
2238	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
2239	CURRENT_THREAD->core->lid , hal_time_stamp() );
2240	}
2241
2242	/////////////////////////////////////////////////////////////////////////////////////////
2243	// [29] Marshaling functions attached to RPC_VMM_DISPLAY (blocking)
2244	/////////////////////////////////////////////////////////////////////////////////////////
2245
2246	/////////////////////////////////////////////
2247	void rpc_vmm_display_client( cxy_t cxy,
2248	process_t * process,
2249	bool_t detailed )
2250	{
2251	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
2252	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
2253	CURRENT_THREAD->core->lid , hal_time_stamp() );
2254
2255	assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
2256
2257	// initialise RPC descriptor header
2258	rpc_desc_t rpc;
2259	rpc.index = RPC_VMM_DISPLAY;
2260	rpc.response = 1;
2261	rpc.blocking = true;
2262
2263	// set input arguments in RPC descriptor
2264	rpc.args[0] = (uint64_t)(intptr_t)process;
2265	rpc.args[1] = (uint64_t)detailed;
2266
2267	// register RPC request in remote RPC fifo (blocking function)
2268	rpc_send( cxy , &rpc );
2269
2270	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
2271	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
2272	CURRENT_THREAD->core->lid , hal_time_stamp() );
2273	}
2274
2275	////////////////////////////////////////
2276	void rpc_vmm_display_server( xptr_t xp )
2277	{
2278	rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
2279	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
2280	CURRENT_THREAD->core->lid , hal_time_stamp() );
2281
2282	process_t * process;
2283	bool_t detailed;
2284
2285	// get client cluster identifier and pointer on RPC descriptor
2286	cxy_t cxy = (cxy_t)GET_CXY( xp );
2287	rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
2288
2289	// get input arguments from client RPC descriptor
2290	process = (process_t *)(intptr_t)hal_remote_lwd( XPTR(cxy , &desc->args[0]));
2291	detailed = (bool_t) hal_remote_lwd( XPTR(cxy , &desc->args[1]));
2292
2293	// call local kernel function
2294	vmm_display( process , detailed );
2295
2296	rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
2297	__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
2298	CURRENT_THREAD->core->lid , hal_time_stamp() );
2299	}
2300
2301

Note: See TracBrowser for help on using the repository browser.

Download in other formats: