Context Navigation

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

Last change on this file since 472 was 459, checked in by alain, 6 years ago
Introduce the math library, to support the floating point data used by the multi-thread fft application. Fix several bugs regarding the FPU context save/restore. Introduce support for the %f format in printf.
File size: 81.5 KB

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

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

Download in other formats: