Context Navigation

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

Last change on this file since 586 was 583, checked in by alain, 6 years ago
Improve signals.
File size: 84.9 KB

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

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

Download in other formats: