Context Navigation

source: trunk/kernel/kern/rpc.h @ 240

Last change on this file since 240 was 238, checked in by alain, 7 years ago
Fixing bugs in vfs_lookup()
File size: 29.0 KB

Rev	Line
[1]	1	/*
	2	* rpc.h - RPC (Remote Procedure Call) operations definition.
	3	*
[23]	4	* Author Alain Greiner (2016,2017)
[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
	24	#ifndef _RPC_H_
	25	#define _RPC_H_
	26
[14]	27	#include <kernel_config.h>
[1]	28	#include <hal_types.h>
	29	#include <hal_atomic.h>
	30	#include <bits.h>
	31	#include <spinlock.h>
	32	#include <remote_fifo.h>
	33
	34	/** Forward declarations **/
	35
	36	struct process_s;
	37	struct vseg_s;
	38	struct exec_info_s;
	39	struct pthread_attr_s;
	40	struct remote_sem_s;
	41	struct fragment_s;
	42	struct vfs_inode_s;
	43	struct vfs_dentry_s;
[23]	44	struct vfs_file_s;
[1]	45	struct thread_s;
	46	struct mapper_s;
	47
	48	/**********************************************************************************/
	49	/************ structures for Remote Procedure Calls **************************/
	50	/**********************************************************************************/
	51
	52	/***********************************************************************************
	53	* This enum defines all RPC indexes.
	54	* It must be consistent with the rpc_server[] array defined in in the rpc.c file.
	55	**********************************************************************************/
	56
	57	typedef enum
	58	{
	59	RPC_PMEM_GET_PAGES = 0,
	60	RPC_PROCESS_PID_ALLOC = 1,
	61	RPC_PROCESS_EXEC = 2,
	62	RPC_PROCESS_KILL = 3,
	63	RPC_THREAD_USER_CREATE = 4,
	64	RPC_THREAD_KERNEL_CREATE = 5,
[23]	65	RPC_SIGNAL_RISE = 6,
[1]	66
	67	RPC_VFS_INODE_CREATE = 10,
	68	RPC_VFS_INODE_DESTROY = 11,
	69	RPC_VFS_DENTRY_CREATE = 12,
	70	RPC_VFS_DENTRY_DESTROY = 13,
[23]	71	RPC_VFS_FILE_CREATE = 14,
	72	RPC_VFS_FILE_DESTROY = 15,
[238]	73	RPC_VFS_INODE_LOAD = 16,
	74	RPC_VFS_MAPPER_LOAD_ALL = 17,
	75	RPC_FATFS_GET_CLUSTER = 18,
[1]	76
	77	RPC_VMM_GET_REF_VSEG = 20,
	78	RPC_VMM_GET_PTE = 21,
[23]	79	RPC_KCM_ALLOC = 22,
	80	RPC_KCM_FREE = 23,
[1]	81	RPC_MAPPER_MOVE = 24,
	82
[23]	83	RPC_MAX_INDEX = 30,
[1]	84	}
	85	rpc_index_t;
	86
	87	/***********************************************************************************
	88	* This defines the prototype of the rpc_server functions,
	89	* defined by the rpc_server[] array in the rpc.c file.
	90	**********************************************************************************/
	91
	92	typedef void (rpc_server_t) ( xptr_t xp );
	93
	94	/***********************************************************************************
	95	* This structure defines the RPC descriptor
	96	**********************************************************************************/
	97
	98	typedef struct rpc_desc_s
	99	{
	100	rpc_index_t index; // index of requested RPC service
	101	volatile uint32_t response; // response valid when 0
[23]	102	uint64_t args[10]; // input/output arguments buffer
[1]	103	}
	104	rpc_desc_t;
	105
	106	/***********************************************************************************
	107	* This structure defines the RPC fifo, containing a remote_fifo, the owner RPC
	108	* thread TRDID (used as a light lock), and the intrumentation counter.
	109	*
	110	* Implementation note: the TRDID is a good owner identifier, because all
	111	* RPC threads in a given cluster belong to the same process_zero kernel process,
	112	* and RPC threads cannot have local index LTID = 0.
	113	**********************************************************************************/
	114
	115	typedef struct rpc_fifo_s
	116	{
	117	trdid_t owner; // owner thread / 0 if no owner
	118	uint64_t count; // total number of received RPCs (instrumentation)
	119	remote_fifo_t fifo; // embedded remote fifo
	120	}
	121	rpc_fifo_t;
	122
	123
	124	/**********************************************************************************/
	125	/***** Generic functions supporting RPCs : client side ************************/
	126	/**********************************************************************************/
	127
	128	/***********************************************************************************
	129	* This blocking function executes on the client core.
	130	* It puts one RPC extended pointer in the remote fifo.
	131	* It sends an IPI if fifo is empty, and waits until RPC response available.
	132	* The RPC descriptor must be allocated in the caller's stack
	133	* and initialised by the caller. Exit with a Panic message if remote fifo
	134	* is still full after (CONFIG_RPC_PUT_MAX_ITERATIONS) retries.
	135	***********************************************************************************
	136	* @ cxy : server cluster identifier
	137	* @ desc : local pointer on RPC descriptor in client cluster
	138	**********************************************************************************/
	139	void rpc_send_sync( cxy_t cxy,
	140	rpc_desc_t * desc );
	141
	142
	143
	144	/**********************************************************************************/
	145	/***** Generic functions supporting RPCs : server side ************************/
	146	/**********************************************************************************/
	147
	148	/***********************************************************************************
	149	* This function initialises the local RPC fifo and the lock protecting readers.
	150	* The number of slots is defined by the CONFIG_REMOTE_FIFO_SLOTS parameter.
	151	* Each slot contains an extended pointer on the RPC descriptor.
	152	***********************************************************************************
	153	* @ rf : pointer on the local RPC fifo.
	154	**********************************************************************************/
	155	void rpc_fifo_init( rpc_fifo_t * rf );
	156
	157	/***********************************************************************************
	158	* This function is the entry point for RPC handling on the server side.
	159	* It can be executed by any thread running (in kernel mode) on any core.
	160	* It first checks the core private RPC fifo, an then the cluster shared RPC fifo.
	161	* It calls the rpc_activate_thread() function to activate a dedicated RPC thread.
	162	***********************************************************************************
	163	* @ returns true if at least one RPC found / false otherwise.
	164	**********************************************************************************/
	165	bool_t rpc_check();
	166
	167	/***********************************************************************************
	168	* This function contains the loop to execute all pending RPCs on the server side.
	169	* It should be called with irq disabled and after light lock acquisition.
	170	***********************************************************************************
	171	* @ rpc_fifo : pointer on the local RPC fifo
	172	* @ returns 0 if success
	173	**********************************************************************************/
	174	error_t rpc_execute_all( rpc_fifo_t * rpc_fifo );
	175
	176	/**********************************************************************************
	177	* This function is called by any thread running on any core in any cluster,
	178	* that detected a non-empty RPC_FIFO and got the RPC_FIFO ownership.
	179	* It activates one RPC thread, and immediately switches to the RPC thread.
	180	* It gets the first free RPC thread from the core free-list, or creates a new one
	181	* when the core free-list is empty.
	182	***********************************************************************************
	183	* @ rpc_fifo : pointer on the non-empty RPC fifo.
	184	* @ return 0 if success / return ENOMEM if error.
	185	**********************************************************************************/
	186	error_t rpc_activate_thread( rpc_fifo_t * rpc_fifo );
	187
	188	/***********************************************************************************
	189	* This function contains the infinite loop executed by each RPC thread.
	190	**********************************************************************************/
	191	void rpc_thread_func();
	192
	193	/***********************************************************************************
	194	* This function is executed in case of illegal RPC index.
	195	**********************************************************************************/
	196	void __attribute__((noinline)) rpc_undefined();
	197
[23]	198
	199
	200
[1]	201	/**********************************************************************************/
	202	/***** Marshalling functions attached to the various RPCs *********************/
	203	/**********************************************************************************/
	204
	205	/***********************************************************************************
[23]	206	* [0] The RPC_PMEM_GET_PAGES allocates one or several pages in a remote cluster,
[1]	207	* and returns the PPN of the first allocated page.
	208	***********************************************************************************
	209	* @ cxy : server cluster identifier
	210	* @ order : [in] ln2( number of requested pages )
	211	* @ error : [out] error status (0 if success)
	212	* @ ppn : [out] first physical page number
	213	**********************************************************************************/
	214	void rpc_pmem_get_pages_client( cxy_t cxy,
	215	uint32_t order,
	216	error_t * error,
	217	uint32_t * ppn );
	218
	219	void rpc_pmem_get_pages_server( xptr_t xp );
	220
	221	/***********************************************************************************
[23]	222	* [1] The RPC_PROCESS_PID_ALLOC allocates one new PID in a remote cluster, registers
[1]	223	* the new process in the remote cluster, and returns the PID, and an error code.
	224	***********************************************************************************
	225	* @ cxy : server cluster identifier.
	226	* @ process : [in] local pointer on process descriptor in client cluster.
	227	* @ error : [out] error status (0 if success).
	228	* @ pid : [out] new process identifier.
	229	**********************************************************************************/
	230	void rpc_process_pid_alloc_client( cxy_t cxy,
	231	struct process_s * process,
	232	error_t * error,
	233	pid_t * pid );
	234
	235	void rpc_process_pid_alloc_server( xptr_t xp );
	236
	237	/***********************************************************************************
[23]	238	* [2] The RPC_PROCESS_EXEC creates a process descriptor copy, in a remote cluster
[1]	239	* and initializes if from information found in the reference process descriptor.
	240	* This remote cluster becomes the new reference cluster.
	241	***********************************************************************************
	242	* @ cxy : server cluster identifier.
	243	* @ info : [in] pointer on local exec_info structure.
	244	* @ error : [out] error status (0 if success).
	245	**********************************************************************************/
	246	void rpc_process_exec_client( cxy_t cxy,
	247	struct exec_info_s * info,
	248	error_t * error );
	249
	250	void rpc_process_exec_server( xptr_t xp );
	251
	252	/***********************************************************************************
[23]	253	* [3] The RPC_PROCESS_KILL is actually a multicast RPC sent by the reference cluster
[1]	254	* to other clusters containing a process descriptor copy, to destroy these copies.
	255	***********************************************************************************
	256	* @ process : local pointer on target process.
	257	**********************************************************************************/
	258	void rpc_process_kill_client( struct process_s * process );
	259
	260	void rpc_process_kill_server( xptr_t xp );
	261
	262	/***********************************************************************************
[23]	263	* [4] The RPC_THREAD_USER_CREATE creates an user thread in the server cluster,
	264	* as specified by the arguments. It returns an extended pointer on the new
	265	* thread descriptor in server cluster, and an error code.
	266	* It is called by the sys_thread_create() system call.
[1]	267	***********************************************************************************
	268	* @ cxy : server cluster identifier.
	269	* @ attr : [in] pointer on pthread_attr_t in client cluster.
	270	* @ thread_xp : [out] pointer on buffer for thread extended pointer.
	271	* @ error : [out] error status (0 if success).
	272	**********************************************************************************/
	273	void rpc_thread_user_create_client( cxy_t cxy,
[23]	274	pid_t pid,
	275	void * start_func,
	276	void * start_arg,
[1]	277	struct pthread_attr_s * attr,
	278	xptr_t * thread_xp,
	279	error_t * error );
	280
	281	void rpc_thread_user_create_server( xptr_t xp );
	282
	283	/***********************************************************************************
[23]	284	* [5] The RPC_THREAD_KERNEL_CREATE creates a kernel thread in the server cluster,
[1]	285	* as specified by the type, func and args arguments. It returns the local pointer
	286	* on the thread descriptor in server cluster and an error code.
[23]	287	* It is used by the dev_init() function to create the device server thread.
[1]	288	***********************************************************************************
	289	* @ cxy : server cluster identifier.
	290	* @ type : [in] type of kernel thread.
	291	* @ func : [in] local pointer on thread function.
	292	* @ args : [in] local pointer on function arguments.
	293	* @ thread_xp : [out] pointer on buffer for thread extended pointer.
	294	* @ error : [out] error status (0 if success).
	295	**********************************************************************************/
	296	void rpc_thread_kernel_create_client( cxy_t cxy,
	297	uint32_t type,
	298	void * func,
	299	void * args,
	300	xptr_t * thread_xp,
	301	error_t * error );
	302
	303	void rpc_thread_kernel_create_server( xptr_t xp );
	304
[23]	305	/***********************************************************************************
	306	* [6] The RPC_SIGNAL_RISE ask a target cluster to register a given signal in
	307	* all threads descriptors of a given process.
	308	* It is used by the sys_kill() function.
	309	***********************************************************************************
	310	* @ cxy : server cluster identifier.
	311	* @ process : [in] local pointer on target process descriptor in server.
	312	* @ sig_id : [in] signal index.
	313	**********************************************************************************/
	314	void rpc_signal_rise_client( cxy_t cxy,
	315	struct process_s * process,
	316	uint32_t sig_id );
	317
	318	void rpc_signal_rise_server( xptr_t xp );
	319
[1]	320	/***********************************************************************************
[23]	321	* [10] The RPC_VFS_INODE_CREATE creates an inode and the associated mapper in a
[1]	322	* remote cluster. The parent dentry must have been previously created.
	323	* It returns an extended pointer on the created inode.
	324	***********************************************************************************
[23]	325	* @ cxy : server cluster identifier.
	326	* @ dentry_xp : [in] extended pointer on parent dentry.
	327	* @ fs_type : [in] file system type.
	328	* @ inode_type : [in] file system type.
[188]	329	* @ extend : [in] fs_type_specific inode extension.
[23]	330	* @ attr : [in] inode attributes.
	331	* @ rights : [in] access rights
	332	* @ uid : [in] user ID
	333	* @ gid : [in] group ID
	334	* @ inode_xp : [out] buffer for extended pointer on created inode.
	335	* @ error : [out] error status (0 if success).
[1]	336	**********************************************************************************/
	337	void rpc_vfs_inode_create_client( cxy_t cxy,
	338	xptr_t dentry_xp,
[23]	339	uint32_t fs_type,
	340	uint32_t inode_type,
[188]	341	void * extend,
[1]	342	uint32_t attr,
[23]	343	uint32_t rights,
[1]	344	uint32_t uid,
	345	uint32_t gid,
	346	xptr_t * inode_xp,
	347	error_t * error );
	348
	349	void rpc_vfs_inode_create_server( xptr_t xp );
	350
	351	/***********************************************************************************
[23]	352	* [11] The RPC_VFS_INODE_DESTROY releases memory allocated for an inode descriptor
[1]	353	* and for the associated mapper in a remote cluster.
	354	***********************************************************************************
	355	* @ cxy : server cluster identifier
	356	* @ inode : [in] local pointer on inode.
	357	**********************************************************************************/
	358	void rpc_vfs_inode_destroy_client( cxy_t cxy,
	359	struct vfs_inode_s * inode );
	360
	361	void rpc_vfs_inode_destroy_server( xptr_t xp );
	362
	363	/***********************************************************************************
[23]	364	* [12] The RPC_VFS_DENTRY_CREATE creates a dentry in a remote cluster.
[1]	365	* It returns an extended pointer on the created dentry.
	366	***********************************************************************************
	367	* @ cxy : server cluster identifier
	368	* @ type : [in] file system type.
	369	* @ name : [in] directory entry name.
	370	* @ parent : [in] local pointer on parent inode.
	371	* @ dentry_xp : [out] buffer for extended pointer on created dentry.
	372	* @ error : [out] error status (0 if success).
	373	**********************************************************************************/
	374	void rpc_vfs_dentry_create_client( cxy_t cxy,
	375	uint32_t type,
	376	char * name,
	377	struct vfs_inode_s * parent,
	378	xptr_t * dentry_xp,
	379	error_t * error );
	380
	381	void rpc_vfs_dentry_create_server( xptr_t xp );
	382
	383	/***********************************************************************************
[23]	384	* [13] The RPC_VFS_DENTRY_DESTROY releases memory allocated for an dentry descriptor
[1]	385	* in a remote cluster.
	386	***********************************************************************************
	387	* @ cxy : server cluster identifier
	388	* @ dentry : [in] local pointer on dentry.
	389	**********************************************************************************/
	390	void rpc_vfs_dentry_destroy_client( cxy_t cxy,
	391	struct vfs_dentry_s * dentry );
	392
	393	void rpc_vfs_dentry_destroy_server( xptr_t xp );
	394
[23]	395	/***********************************************************************************
	396	* [14] The RPC_VFS_FILE_CREATE creates a file descriptor in a remote cluster.
	397	* It returns an extended pointer on the created file structure.
	398	***********************************************************************************
	399	* @ cxy : server cluster identifier
	400	* @ inode : [in] local pointer on parent inode.
	401	* @ file_attr : [in] new file attributes.
	402	* @ file_xp : [out] buffer for extended pointer on created file.
	403	* @ error : [out] error status (0 if success).
	404	**********************************************************************************/
	405	void rpc_vfs_file_create_client( cxy_t cxy,
	406	struct vfs_inode_s * inode,
	407	uint32_t file_attr,
	408	xptr_t * file_xp,
	409	error_t * error );
[1]	410
[23]	411	void rpc_vfs_file_create_server( xptr_t xp );
[1]	412
[23]	413	/***********************************************************************************
	414	* [15] The RPC_VFS_FILE_DESTROY releases memory allocated for a file descriptor
	415	* in a remote cluster.
	416	***********************************************************************************
	417	* @ cxy : server cluster identifier
	418	* @ file : [in] local pointer on file.
	419	**********************************************************************************/
	420	void rpc_vfs_file_destroy_client( cxy_t cxy,
	421	struct vfs_file_s * file );
[1]	422
[23]	423	void rpc_vfs_file_destroy_server( xptr_t xp );
	424
[238]	425	/***********************************************************************************
	426	* [16] The RPC_VFS_LOAD_INODE calls the vfs_inode_load() kernel function in a
	427	* remote cluster containing a parent inode directory to scan the associated
	428	* mapper, find a directory entry, identified by its name, and update the remote
	429	* child inode.
	430	***********************************************************************************
	431	* @ cxy : server cluster identifier
	432	* @ parent_inode : [in] local pointer on parent inode.
	433	* @ name : [in] local pointer on child name (in client cluster).
	434	* @ child_inode_xp : [in] extended pointer on child inode (in another cluster).
	435	* @ error : [out] error status (0 if success).
	436	**********************************************************************************/
	437	void rpc_vfs_inode_load_client( cxy_t cxy,
	438	struct vfs_inode_s * parent_inode,
	439	char * name,
	440	xptr_t child_inode_xp,
	441	error_t * error );
	442
	443	void rpc_vfs_inode_load_server( xptr_t xp );
	444
	445	/***********************************************************************************
	446	* [17] The RPC_VFS_MAPPER_LOAD_ALL calls the vfs_mapper_load_all() kernel function
	447	* in a remote cluster containing an inode, to load all pages of the associated
	448	* mapper from the file system on device.
	449	***********************************************************************************
	450	* @ cxy : server cluster identifier
	451	* @ inode : [in] local pointer on inode in server cluster.
	452	* @ error : [out] error status (0 if success).
	453	**********************************************************************************/
	454	void rpc_vfs_mapper_load_all_client( cxy_t cxy,
	455	struct vfs_inode_s * inode,
	456	error_t * error );
	457
	458	void rpc_vfs_mapper_load_all_server( xptr_t xp );
	459
[1]	460	/***********************************************************************************
[238]	461	* [18] The RPC_FATFS_GET_CLUSTER can be send by any thread running in a "client"
[23]	462	* cluster to scan the FAT mapper, stored in a remote "server" cluster, and get
	463	* from the mapper the local pointer on a given page.
	464	***********************************************************************************
	465	* @ cxy : server cluster identifier.
	466	* @ mapper : [in] local pointer on FAT mapper.
	467	* @ first : [in] FATFS cluster index allocated to first page of file.
	468	* @ page : [in] page index in file.
	469	* @ cluster : [out] local pointer on buffer for found FATFS cluster index.
	470	* @ error : [out] local pointer on buffer for error code (in client cluster).
	471	**********************************************************************************/
	472	void rpc_fatfs_get_cluster_client( cxy_t cxy,
	473	struct mapper_s * mapper,
	474	uint32_t first,
	475	uint32_t page,
	476	uint32_t * cluster,
	477	error_t * error );
	478
	479	void rpc_fatfs_get_cluster_server( xptr_t xp );
	480
	481	/***********************************************************************************
	482	* [20] The RPC_VMM_GET_REF_VSEG returns an extended pointer
[1]	483	* on the vseg containing a given virtual address in a given process.
	484	* The server cluster is supposed to be the reference cluster.
[16]	485	* It returns XPTR_NULL if no vseg has been founded.
[1]	486	***********************************************************************************
	487	* @ cxy : server cluster identifier.
	488	* @ process : [in] pointer on process descriptor in server cluster.
	489	* @ vaddr : [in] virtual address to be searched.
[16]	490	* @ vseg_xp : [out] buffer for extended pointer on vseg in client cluster.
[1]	491	**********************************************************************************/
	492	void rpc_vmm_get_ref_vseg_client( cxy_t cxy,
	493	struct process_s * process,
	494	intptr_t vaddr,
	495	xptr_t * vseg_xp );
	496
	497	void rpc_vmm_get_ref_vseg_server( xptr_t xp );
	498
	499	/***********************************************************************************
[23]	500	* [21] The RPC_VMM_GET_PTE returns in the "ppn" and "attr" arguments the PTE value
[1]	501	* for a given VPN in a given process.
	502	* The server cluster is supposed to be the reference cluster, and the vseg
	503	* containing the VPN must be registered in the reference VMM.
	504	* It returns an error if physical memory cannot be allocated for the PTE2,
	505	* or for the missing page itself.
	506	***********************************************************************************
	507	* @ cxy : server cluster identifier.
	508	* @ process : [in] pointer on process descriptor in server cluster.
	509	* @ vaddr : [in] virtual address to be searched.
	510	* @ attr : [out] address of buffer for attributes.
	511	* @ ppn : [out] address of buffer for PPN.
	512	* @ error : [out] address of buffer for error code.
	513	**********************************************************************************/
	514	void rpc_vmm_get_pte_client( cxy_t cxy,
	515	struct process_s * process,
	516	vpn_t vpn,
	517	uint32_t * attr,
	518	ppn_t * ppn,
	519	error_t * error );
	520
	521	void rpc_vmm_get_pte_server( xptr_t xp );
	522
	523	/***********************************************************************************
[23]	524	* [22] The RPC_KCM_ALLOC allocates memory from a given KCM in a remote cluster,
	525	* and returns an extended pointer on the allocated object.
	526	It returns XPTR_NULL if physical memory cannot be allocated.
[1]	527	***********************************************************************************
[23]	528	* @ cxy : server cluster identifier.
	529	* @ kmem_type : [in] KCM object type (as defined in kmem.h).
	530	* @ buf_xp : [out] buffer for extended pointer on allocated buffer.
[1]	531	**********************************************************************************/
[23]	532	void rpc_kcm_alloc_client( cxy_t cxy,
	533	uint32_t kmem_type,
	534	xptr_t * buf_xp );
[1]	535
[23]	536	void rpc_kcm_alloc_server( xptr_t xp );
[1]	537
	538	/***********************************************************************************
[23]	539	* [23] The RPC_KCM_FREE releases memory allocated for a KCM object of a given type,
[1]	540	* in a remote cluster.
	541	***********************************************************************************
[23]	542	* @ cxy : server cluster identifier.
	543	* @ buf : [in] local pointer on allocated buffer.
	544	* @ kmem_type : [in] KCM object type (as defined in kmem.h).
[1]	545	**********************************************************************************/
[23]	546	void rpc_kcm_free_client( cxy_t cxy,
	547	void * buf,
	548	uint32_t kmem_type );
[1]	549
[23]	550	void rpc_kcm_free_server( xptr_t xp );
[1]	551
	552	/***********************************************************************************
[23]	553	* [24] The RPC_MAPPER_MOVE is called by the vfs_move() function.
	554	* It allows a client thread to requires a remote mapper to move data to/from
	555	* an user buffer, as specified by the arguments.
[1]	556	***********************************************************************************
[23]	557	* @ cxy : server cluster identifier.
	558	* @ mapper : [in] local pointer on mapper
	559	* @ to_buffer : [in] move data from buffer to mapper if non zero.
	560	* @ file_offset : [in] first byte to move in mapper
	561	* @ buffer : [in] pointer on buffer in user space
	562	* @ size : [in] number of bytes to move
	563	* @ error : [out] error status (0 if success).
[1]	564	**********************************************************************************/
[23]	565	void rpc_mapper_move_client( cxy_t cxy,
	566	struct mapper_s * mapper,
	567	uint32_t to_buffer,
	568	uint32_t file_offset,
	569	void * buffer,
	570	uint32_t size,
	571	error_t * error );
[1]	572
	573	void rpc_mapper_move_server( xptr_t xp );
	574
	575
	576
[23]	577
[1]	578	#endif

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

Download in other formats: