Context Navigation

source: trunk/kernel/fs/vfs.c @ 623

Last change on this file since 623 was 623, checked in by alain, 6 years ago
Introduce three new types of vsegs (KCODE,KDATA,KDEV) to map the kernel vsegs in the process VSL and GPT. This now used by both the TSAR and the I86 architectures.
File size: 131.6 KB

Line
1	/*
2	* vfs.c - Virtual File System implementation.
3	*
4	* Author Mohamed Lamine Karaoui (2015)
5	* Alain Greiner (2016,2017,2018,2019)
6	*
7	* Copyright (c) UPMC Sorbonne Universites
8	*
9	* This file is part of ALMOS-MKH.
10	*
11	* ALMOS-MKH is free software; you can redistribute it and/or modify it
12	* under the terms of the GNU General Public License as published by
13	* the Free Software Foundation; version 2.0 of the License.
14	*
15	* ALMOS-MKH is distributed in the hope that it will be useful, but
16	* WITHOUT ANY WARRANTY; without even the implied warranty of
17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18	* General Public License for more details.
19	*
20	* You should have received a copy of the GNU General Public License
21	* along with ALMOS-MKH; if not, write to the Free Software Foundation,
22	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
23	*/
24
25	#include <kernel_config.h>
26	#include <hal_kernel_types.h>
27	#include <hal_atomic.h>
28	#include <hal_special.h>
29	#include <printk.h>
30	#include <list.h>
31	#include <xlist.h>
32	#include <slist.h>
33	#include <xhtab.h>
34	#include <string.h>
35	#include <rpc.h>
36	#include <errno.h>
37	#include <kmem.h>
38	#include <mapper.h>
39	#include <thread.h>
40	#include <chdev.h>
41	#include <process.h>
42	#include <cluster.h>
43	#include <vfs.h>
44	#include <fatfs.h>
45	#include <ramfs.h>
46	#include <devfs.h>
47	#include <syscalls.h>
48
49	//////////////////////////////////////////////////////////////////////////////////////////
50	// Extern variables
51	//////////////////////////////////////////////////////////////////////////////////////////
52
53	extern vfs_ctx_t fs_context[FS_TYPES_NR]; // allocated in kernel_init.c
54	extern chdev_directory_t chdev_dir; // allocated in kernel_init.c
55	extern char * lock_type_str[]; // allocated in kernel_init.c
56
57	///////////////////////////////////////////////////////////////////////////////////////////
58	// VFS Context related functions
59	//////////////////////////////////////////////////////////////////////////////////////////
60
61	////////////////////////////////////////
62	void vfs_ctx_init( vfs_fs_type_t type,
63	uint32_t attr,
64	uint32_t total_clusters,
65	uint32_t cluster_size,
66	xptr_t vfs_root_xp,
67	void * extend )
68	{
69	vfs_ctx_t * vfs_ctx = &fs_context[type];
70
71	vfs_ctx->type = type;
72	vfs_ctx->attr = attr;
73	vfs_ctx->total_clusters = total_clusters;
74	vfs_ctx->cluster_size = cluster_size;
75	vfs_ctx->vfs_root_xp = vfs_root_xp;
76	vfs_ctx->extend = extend;
77
78	busylock_init( &vfs_ctx->lock , LOCK_VFS_CTX );
79
80	bitmap_init( vfs_ctx->bitmap , BITMAP_SIZE(CONFIG_VFS_MAX_INODES) );
81	}
82
83	////////////////////////////////////////////
84	error_t vfs_ctx_inum_alloc( vfs_ctx_t * ctx,
85	uint32_t * inum )
86	{
87	// get lock on inum allocator
88	busylock_acquire( &ctx->lock );
89
90	// get lid from local inum allocator
91	uint32_t lid = bitmap_ffc( ctx->bitmap , CONFIG_VFS_MAX_INODES );
92
93	if( lid == 0xFFFFFFFF ) // no more free slot => error
94	{
95	// release lock
96	busylock_release( &ctx->lock );
97
98	// return error
99	return 1;
100	}
101	else // found => return inum
102	{
103	// set slot allocated
104	bitmap_set( ctx->bitmap , lid );
105
106	// release lock
107	busylock_release( &ctx->lock );
108
109	// return inum
110	*inum = (((uint32_t)local_cxy) << 16) \| (lid & 0xFFFF);
111	return 0;
112	}
113	}
114
115	////////////////////////////////////////////
116	void vfs_ctx_inum_release( vfs_ctx_t * ctx,
117	uint32_t inum )
118	{
119	bitmap_clear( ctx->bitmap , inum & 0xFFFF );
120	}
121
122	//////////////////////////////////////////////////////////////////////////////////////////
123	// VFS inode descriptor related functions
124	//////////////////////////////////////////////////////////////////////////////////////////
125
126	const char * vfs_inode_type_str( vfs_inode_type_t type )
127	{
128	switch ( type )
129	{
130	case INODE_TYPE_FILE: return "FILE";
131	case INODE_TYPE_DIR: return "DIR ";
132	case INODE_TYPE_FIFO: return "FIFO";
133	case INODE_TYPE_PIPE: return "PIPE";
134	case INODE_TYPE_SOCK: return "SOCK";
135	case INODE_TYPE_DEV: return "DEV ";
136	case INODE_TYPE_BLK: return "BLK ";
137	case INODE_TYPE_SYML: return "SYML";
138	default: return "undefined";
139	}
140	}
141
142	////////////////////////////////////////////////////
143	error_t vfs_inode_create( vfs_fs_type_t fs_type,
144	uint32_t attr,
145	uint32_t rights,
146	uid_t uid,
147	gid_t gid,
148	xptr_t * inode_xp )
149	{
150	mapper_t * mapper; // associated mapper( to be allocated)
151	vfs_inode_t * inode; // inode descriptor (to be allocated)
152	uint32_t inum; // inode identifier (to be allocated)
153	vfs_ctx_t * ctx; // file system context
154	kmem_req_t req; // request to kernel memory allocator
155	error_t error;
156
157	#if DEBUG_VFS_INODE_CREATE
158	char name[CONFIG_VFS_MAX_NAME_LENGTH];
159	uint32_t cycle = (uint32_t)hal_get_cycles();
160	cxy_t dentry_cxy = GET_CXY( dentry_xp );
161	vfs_dentry_t * dentry_ptr = GET_PTR( dentry_xp );
162	thread_t * this = CURRENT_THREAD;
163	if( dentry_xp != XPTR_NULL ) hal_remote_strcpy( XPTR( local_cxy , name ),
164	XPTR( dentry_cxy , dentry_ptr->name ) );
165	else strcpy( name , "/" );
166	if( DEBUG_VFS_INODE_CREATE < cycle )
167	printk("\n[%s] thread[%x,%x] enter for <%s> / cycle %d\n",
168	__FUNCTION__, this->process->pid, this->trdid, name, cycle );
169	#endif
170
171	// check fs type and get pointer on context
172	if ( fs_type == FS_TYPE_FATFS ) ctx = &fs_context[FS_TYPE_FATFS];
173	else if( fs_type == FS_TYPE_RAMFS ) ctx = &fs_context[FS_TYPE_RAMFS];
174	else if( fs_type == FS_TYPE_DEVFS ) ctx = &fs_context[FS_TYPE_DEVFS];
175	else
176	{
177	ctx = NULL;
178	assert( false , "illegal file system type = %d\n" , fs_type );
179	}
180
181	// allocate inum
182	error = vfs_ctx_inum_alloc( ctx , &inum );
183
184	if( error )
185	{
186	printk("\n[ERROR] in %s : cannot allocate inum\n", __FUNCTION__ );
187	return ENOMEM;
188	}
189
190	// allocate memory for mapper
191	mapper = mapper_create( fs_type );
192
193	if( mapper == NULL )
194	{
195	printk("\n[ERROR] in %s : cannot allocate mapper\n", __FUNCTION__ );
196	vfs_ctx_inum_release( ctx , inum );
197	return ENOMEM;
198	}
199
200	// allocate memory for VFS inode descriptor
201	req.type = KMEM_VFS_INODE;
202	req.size = sizeof(vfs_inode_t);
203	req.flags = AF_KERNEL \| AF_ZERO;
204	inode = (vfs_inode_t *)kmem_alloc( &req );
205
206	if( inode == NULL )
207	{
208	printk("\n[ERROR] in %s : cannot allocate inode descriptor\n", __FUNCTION__ );
209	vfs_ctx_inum_release( ctx , inum );
210	mapper_destroy( mapper );
211	return -1;
212	}
213
214	// initialize inode descriptor
215	inode->type = INODE_TYPE_FILE; // default value
216	inode->inum = inum;
217	inode->attr = attr;
218	inode->rights = rights;
219	inode->uid = uid;
220	inode->gid = gid;
221	inode->ctx = ctx;
222	inode->mapper = mapper;
223	inode->extend = NULL;
224	inode->links = 0;
225
226	// initialise inode field in mapper
227	mapper->inode = inode;
228
229	// initialize chidren dentries xhtab
230	xhtab_init( &inode->children , XHTAB_DENTRY_TYPE );
231
232	// initialize parents dentries xlist
233	xlist_root_init( XPTR( local_cxy , &inode->parents ) );
234
235	// initialize lock protecting size
236	remote_rwlock_init( XPTR( local_cxy , &inode->size_lock ), LOCK_VFS_SIZE );
237
238	// initialise lock protecting inode tree traversal
239	remote_rwlock_init( XPTR( local_cxy , &inode->main_lock ), LOCK_VFS_MAIN );
240
241	// return extended pointer on inode
242	*inode_xp = XPTR( local_cxy , inode );
243
244	#if DEBUG_VFS_INODE_CREATE
245	cycle = (uint32_t)hal_get_cycles();
246	if( DEBUG_VFS_INODE_CREATE < cycle )
247	printk("\n[%s] thread[%x,%x] exit for <%s> / inode [%x,%x] / cycle %d\n",
248	__FUNCTION__, this->process->pid, this->trdid, name, local_cxy, inode, cycle );
249	#endif
250
251	return 0;
252
253	} // end vfs_inode_create()
254
255	/////////////////////////////////////////////
256	void vfs_inode_destroy( vfs_inode_t * inode )
257	{
258	// release memory allocated for mapper
259	mapper_destroy( inode->mapper );
260
261	// release memory allocate for inode descriptor
262	kmem_req_t req;
263	req.ptr = inode;
264	req.type = KMEM_VFS_INODE;
265	kmem_free( &req );
266
267	} // end vfs_inode_destroy()
268
269	//////////////////////////////////////////////
270	uint32_t vfs_inode_get_size( xptr_t inode_xp )
271	{
272	// get inode cluster and local pointer
273	cxy_t cxy = GET_CXY( inode_xp );
274	vfs_inode_t * ptr = GET_PTR( inode_xp );
275
276	// build extended pointers on lock & size
277	xptr_t lock_xp = XPTR( cxy , &ptr->size_lock );
278	xptr_t size_xp = XPTR( cxy , &ptr->size );
279
280	// take lock in read mode
281	remote_rwlock_rd_acquire( lock_xp );
282
283	// get size
284	uint32_t size = hal_remote_l32( size_xp );
285
286	// release lock from read mode
287	remote_rwlock_rd_release( lock_xp );
288
289	return size;
290	}
291
292	///////////////////////////////////////////////
293	void vfs_inode_update_size( xptr_t inode_xp,
294	uint32_t size )
295	{
296	// get inode cluster and local pointer
297	cxy_t cxy = GET_CXY( inode_xp );
298	vfs_inode_t * ptr = GET_PTR( inode_xp );
299
300	// build extended pointers on lock & size
301	xptr_t lock_xp = XPTR( cxy , &ptr->size_lock );
302	xptr_t size_xp = XPTR( cxy , &ptr->size );
303
304	// take lock in write mode
305	remote_rwlock_wr_acquire( lock_xp );
306
307	// get current size
308	uint32_t current_size = hal_remote_l32( size_xp );
309
310	// set size if required
311	if( current_size < size ) hal_remote_s32( size_xp , size );
312
313	// release lock from write mode
314	remote_rwlock_wr_release( lock_xp );
315	}
316
317	////////////////////////////////////////
318	void vfs_inode_unlock( xptr_t inode_xp )
319	{
320	// get inode cluster and local pointer
321	cxy_t cxy = GET_CXY( inode_xp );
322	vfs_inode_t * ptr = GET_PTR( inode_xp );
323
324	// release the main lock
325	remote_busylock_release( XPTR( cxy , &ptr->main_lock ) );
326	}
327
328	//////////////////////////////////////
329	void vfs_inode_lock( xptr_t inode_xp )
330	{
331	// get inode cluster and local pointer
332	cxy_t cxy = GET_CXY( inode_xp );
333	vfs_inode_t * ptr = GET_PTR( inode_xp );
334
335	// get the main lock
336	remote_busylock_acquire( XPTR( cxy , &ptr->main_lock ) );
337	}
338
339	///////////////////////////////////////////
340	void vfs_inode_get_name( xptr_t inode_xp,
341	char * name )
342	{
343	cxy_t inode_cxy; // inode cluster identifier
344	vfs_inode_t * inode_ptr; // local pointer on inode
345	xptr_t parents_root_xp; // extended pointer on inode parents root
346
347	// get inode cluster and local pointer
348	inode_cxy = GET_CXY( inode_xp );
349	inode_ptr = GET_PTR( inode_xp );
350
351	// build extended pointer on parents dentries root
352	parents_root_xp = XPTR( inode_cxy , &inode_ptr->parents );
353
354	// check VFS root
355	if( xlist_is_empty( parents_root_xp ) ) // inode is the VFS root
356	{
357	strcpy( name , "/" );
358	}
359	else // not the VFS root
360	{
361	xptr_t dentry_xp;
362	cxy_t dentry_cxy;
363	vfs_dentry_t * dentry_ptr;
364
365	// get first name in list of parents
366	dentry_xp = XLIST_FIRST( parents_root_xp , vfs_dentry_t , parents );
367	dentry_cxy = GET_CXY( dentry_xp );
368	dentry_ptr = GET_PTR( dentry_xp );
369
370	hal_remote_strcpy( XPTR( local_cxy , name ) ,
371	XPTR( dentry_cxy , dentry_ptr->name ) );
372	}
373
374	} // end vfs_inode_get_name()
375
376	///////////////////////////////////////////////////////
377	error_t vfs_inode_load_all_pages( vfs_inode_t * inode )
378	{
379
380	assert( (inode != NULL) , "inode pointer is NULL\n" );
381
382	uint32_t page_id;
383	xptr_t page_xp;
384
385	mapper_t * mapper = inode->mapper;
386	uint32_t size = inode->size;
387
388	assert( (mapper != NULL) , "mapper pointer is NULL\n" );
389
390	#if DEBUG_VFS_INODE_LOAD_ALL
391	uint32_t cycle = (uint32_t)hal_get_cycles();
392	thread_t * this = CURRENT_THREAD;
393	char name[CONFIG_VFS_MAX_NAME_LENGTH];
394	vfs_inode_get_name( XPTR( local_cxy , inode ) , name );
395	if( DEBUG_VFS_INODE_LOAD_ALL < cycle )
396	printk("\n[%s] thread[%x,%x] enter for <%s> in cluster %x / cycle %d\n",
397	__FUNCTION__, this->process->pid, this->trdid, name, local_cxy, cycle );
398	#endif
399
400	// compute number of pages
401	uint32_t npages = size >> CONFIG_PPM_PAGE_SHIFT;
402	if( (size & CONFIG_PPM_PAGE_MASK) \|\| (size == 0) ) npages++;
403
404	// loop on pages
405	for( page_id = 0 ; page_id < npages ; page_id ++ )
406	{
407	// If the mage is missing, this function allocates the missing page,
408	// and load the page from IOC device into mapper
409	page_xp = mapper_remote_get_page( XPTR( local_cxy , mapper ), page_id );
410
411	if( page_xp == XPTR_NULL ) return -1;
412	}
413
414	#if DEBUG_VFS_INODE_LOAD_ALL
415	cycle = (uint32_t)hal_get_cycles();
416	if( DEBUG_VFS_INODE_LOAD_ALL < cycle )
417	printk("\n[%s] thread[%x,%x] exit for <%x> in cluster %x / cycle %d\n",
418	__FUNCTION__, this->process->pid, this->trdid, name, local_cxy, cycle );
419	#endif
420
421	return 0;
422
423	} // end vfs_inode_load_all_pages()
424
425	////////////////////////////////////////////////////////////////////////////////////////////
426	// VFS dentry descriptor related functions
427	//////////////////////////////////////////////////////////////////////////////////////////
428
429	///////////////////////////////////////////////////
430	error_t vfs_dentry_create( vfs_fs_type_t fs_type,
431	char * name,
432	xptr_t * dentry_xp )
433	{
434	vfs_ctx_t * ctx; // context descriptor
435	vfs_dentry_t * dentry; // dentry descriptor (to be allocated)
436	kmem_req_t req; // request to kernel memory allocator
437
438	#if DEBUG_VFS_DENTRY_CREATE
439	thread_t * this = CURRENT_THREAD;
440	uint32_t cycle = (uint32_t)hal_get_cycles();
441	if( DEBUG_VFS_DENTRY_CREATE < cycle )
442	printk("\n[%s] thread[%x,%x] enter for <%s> / cycle %d\n",
443	__FUNCTION__, this->process->pid, this->trdid, name, cycle );
444	#endif
445
446	// get pointer on context
447	if ( fs_type == FS_TYPE_FATFS ) ctx = &fs_context[FS_TYPE_FATFS];
448	else if( fs_type == FS_TYPE_RAMFS ) ctx = &fs_context[FS_TYPE_RAMFS];
449	else if( fs_type == FS_TYPE_DEVFS ) ctx = &fs_context[FS_TYPE_DEVFS];
450	else
451	{
452	ctx = NULL;
453	return -1;
454	}
455
456	// get name length
457	uint32_t length = strlen( name );
458
459	if( length >= CONFIG_VFS_MAX_NAME_LENGTH ) return EINVAL;
460
461	// allocate memory for dentry descriptor
462	req.type = KMEM_VFS_DENTRY;
463	req.size = sizeof(vfs_dentry_t);
464	req.flags = AF_KERNEL \| AF_ZERO;
465	dentry = (vfs_dentry_t *)kmem_alloc( &req );
466
467	if( dentry == NULL )
468	{
469	printk("\n[ERROR] in %s : cannot allocate dentry descriptor\n",
470	__FUNCTION__ );
471	return -1;
472	}
473
474	// initialize dentry descriptor
475	dentry->ctx = ctx;
476	dentry->length = length;
477	dentry->extend = NULL;
478	strcpy( dentry->name , name );
479
480	// return extended pointer on dentry
481	*dentry_xp = XPTR( local_cxy , dentry );
482
483	#if DEBUG_VFS_DENTRY_CREATE
484	cycle = (uint32_t)hal_get_cycles();
485	if( DEBUG_VFS_DENTRY_CREATE < cycle )
486	printk("\n[%s] thread[%x,%x] exit for <%s> / dentry [%x,%x] / cycle %d\n",
487	__FUNCTION__, this->process->pid, this->trdid, name, local_cxy, dentry, cycle );
488	#endif
489
490	return 0;
491
492	} // end vfs_dentry_create()
493
494	////////////////////////////////////////////////
495	void vfs_dentry_destroy( vfs_dentry_t * dentry )
496	{
497	// release memory allocated to dentry
498	kmem_req_t req;
499	req.ptr = dentry;
500	req.type = KMEM_VFS_DENTRY;
501	kmem_free( &req );
502
503	} // end vfs_dentry_destroy()
504
505
506	//////////////////////////////////////////////////////////////////////////////////////////
507	// VFS file descriptor related functions
508	//////////////////////////////////////////////////////////////////////////////////////////
509
510	/////////////////////////////////////////////
511	error_t vfs_file_create( vfs_inode_t * inode,
512	uint32_t attr,
513	xptr_t * file_xp )
514	{
515	vfs_file_t * file;
516	kmem_req_t req;
517
518	#if DEBUG_VFS_FILE_CREATE
519	thread_t * this = CURRENT_THREAD;
520	uint32_t cycle = (uint32_t)hal_get_cycles();
521	if( DEBUG_VFS_OPEN < cycle )
522	printk("\n[%s] thread[%x,%x] enter for inode %x in cluster %x / cycle %d\n",
523	__FUNCTION__, this->process->pid, this->trdid, inode, local_cxy, cycle );
524	#endif
525
526	// allocate memory for new file descriptor
527	req.type = KMEM_VFS_FILE;
528	req.size = sizeof(vfs_file_t);
529	req.flags = AF_KERNEL \| AF_ZERO;
530	file = (vfs_file_t *)kmem_alloc( &req );
531
532	if( file == NULL ) return ENOMEM;
533
534	// initializes new file descriptor
535	file->gc = 0;
536	file->type = inode->type;
537	file->attr = attr;
538	file->offset = 0;
539	file->refcount = 1;
540	file->inode = inode;
541	file->ctx = inode->ctx;
542	file->mapper = inode->mapper;
543
544	remote_rwlock_init( XPTR( local_cxy , &file->lock ), LOCK_VFS_FILE );
545
546	*file_xp = XPTR( local_cxy , file );
547
548	#if DEBUG_VFS_FILE_CREATE
549	cycle = (uint32_t)hal_get_cycles();
550	if( DEBUG_VFS_OPEN < cycle )
551	printk("\n[%s] thread[%x,%x] created file %x in cluster %x / cycle %d\n",
552	__FUNCTION__, this->process->pid, this->trdid, file, local_cxy, cycle );
553	#endif
554
555	return 0;
556
557	} // end vfs_file_create()
558
559	///////////////////////////////////////////
560	void vfs_file_destroy( vfs_file_t * file )
561	{
562
563	// check refcount
564	// assert( (file->refcount == 0) , "refcount non zero\n" );
565
566	kmem_req_t req;
567	req.ptr = file;
568	req.type = KMEM_VFS_FILE;
569	kmem_free( &req );
570
571	#if DEBUG_VFS_CLOSE
572	char name[CONFIG_VFS_MAX_NAME_LENGTH];
573	vfs_file_get_name( XPTR( local_cxy , file ) , name );
574	thread_t * this = CURRENT_THREAD;
575	uint32_t cycle = (uint32_t)hal_get_cycles();
576	if( DEBUG_VFS_CLOSE < cycle )
577	printk("\n[%s] thread[%x,%x] deleted file <%s> in cluster %x / cycle %d\n",
578	__FUNCTION__, this->process->pid, this->trdid, name, local_cxy, cycle );
579	#endif
580
581	} // end vfs_file_destroy()
582
583
584	////////////////////////////////////////
585	void vfs_file_count_up( xptr_t file_xp )
586	{
587	// get file cluster and local pointer
588	cxy_t file_cxy = GET_CXY( file_xp );
589	vfs_file_t * file_ptr = GET_PTR( file_xp );
590
591	// atomically increment count
592	hal_remote_atomic_add( XPTR( file_cxy , &file_ptr->refcount ) , 1 );
593	}
594
595	//////////////////////////////////////////
596	void vfs_file_count_down( xptr_t file_xp )
597	{
598	// get file cluster and local pointer
599	cxy_t file_cxy = GET_CXY( file_xp );
600	vfs_file_t * file_ptr = GET_PTR( file_xp );
601
602	// atomically decrement count
603	hal_remote_atomic_add( XPTR( file_cxy , &file_ptr->refcount ) , -1 );
604	}
605
606	///////////////////////////////////////
607	void vfs_file_get_name( xptr_t file_xp,
608	char * name )
609	{
610	// get cluster and local pointer on remote file
611	vfs_file_t * file_ptr = GET_PTR( file_xp );
612	cxy_t file_cxy = GET_CXY( file_xp );
613
614	// get pointers on remote inode
615	vfs_inode_t * inode_ptr = hal_remote_lpt( XPTR( file_cxy , &file_ptr->inode ) );
616	xptr_t inode_xp = XPTR( file_cxy , inode_ptr );
617
618	// call the relevant function
619	vfs_inode_get_name( inode_xp , name );
620	}
621
622
623	//////////////////////////////////////////////////////////////////////////////////////////
624	// "syscalls" API related functions
625	//////////////////////////////////////////////////////////////////////////////////////////
626
627	//////////////////////////////////////
628	error_t vfs_open( xptr_t root_xp,
629	char * path,
630	xptr_t process_xp,
631	uint32_t flags,
632	uint32_t mode,
633	xptr_t * new_file_xp,
634	uint32_t * new_file_id )
635	{
636	error_t error;
637	xptr_t inode_xp; // extended pointer on target inode
638	cxy_t inode_cxy; // inode cluster identifier
639	vfs_inode_t * inode_ptr; // inode local pointer
640	uint32_t file_attr; // file descriptor attributes
641	uint32_t lookup_mode; // lookup working mode
642	xptr_t file_xp; // extended pointer on created file descriptor
643	uint32_t file_id; // created file descriptor index in reference fd_array
644	xptr_t vfs_root_xp; // extended pointer on VFS root inode
645	vfs_inode_t * vfs_root_ptr; // local pointer on VFS root inode
646	cxy_t vfs_root_cxy; // VFS root inode cluster identifier
647	xptr_t lock_xp; // extended pointer on Inode Tree lock
648
649	if( mode != 0 )
650	{
651	printk("\n[ERROR] in %s : the mode parameter is not supported yet\n" );
652	return -1;
653	}
654
655	thread_t * this = CURRENT_THREAD;
656	process_t * process = this->process;
657
658	#if DEBUG_VFS_OPEN
659	uint32_t cycle = (uint32_t)hal_get_cycles();
660	if( DEBUG_VFS_OPEN < cycle )
661	printk("\n[%s] thread[%x,%x] enter for <%s> / root_inode (%x,%x) / cycle %d\n",
662	__FUNCTION__, process->pid, this->trdid, path, GET_CXY(root_xp), GET_PTR(root_xp), cycle );
663	#endif
664
665	// compute lookup working mode
666	lookup_mode = VFS_LOOKUP_OPEN;
667	if( (flags & O_DIR ) ) lookup_mode \|= VFS_LOOKUP_DIR;
668	if( (flags & O_CREAT ) ) lookup_mode \|= VFS_LOOKUP_CREATE;
669	if( (flags & O_EXCL ) ) lookup_mode \|= VFS_LOOKUP_EXCL;
670
671	// compute attributes for the created file
672	file_attr = 0;
673	if( (flags & O_RDONLY ) == 0 ) file_attr \|= FD_ATTR_WRITE_ENABLE;
674	if( (flags & O_WRONLY ) == 0 ) file_attr \|= FD_ATTR_READ_ENABLE;
675	if( (flags & O_SYNC ) ) file_attr \|= FD_ATTR_SYNC;
676	if( (flags & O_APPEND ) ) file_attr \|= FD_ATTR_APPEND;
677	if( (flags & O_CLOEXEC) ) file_attr \|= FD_ATTR_CLOSE_EXEC;
678
679	// build extended pointer on lock protecting Inode Tree
680	vfs_root_xp = process->vfs_root_xp;
681	vfs_root_ptr = GET_PTR( vfs_root_xp );
682	vfs_root_cxy = GET_CXY( vfs_root_xp );
683	lock_xp = XPTR( vfs_root_cxy , &vfs_root_ptr->main_lock );
684
685	// take lock protecting Inode Tree in read mode
686	remote_rwlock_rd_acquire( lock_xp );
687
688	// get extended pointer on target inode
689	error = vfs_lookup( root_xp,
690	path,
691	lookup_mode,
692	&inode_xp,
693	NULL );
694
695	// release lock protecting Inode Tree
696	remote_rwlock_rd_release( lock_xp );
697
698	if( error )
699	{
700	printk("\n[ERROR] in %s : cannot get inode <%s>\n",
701	__FUNCTION__ , path );
702	return -1;
703	}
704
705	// get target inode cluster and local pointer
706	inode_cxy = GET_CXY( inode_xp );
707	inode_ptr = GET_PTR( inode_xp );
708
709	#if (DEBUG_VFS_OPEN & 1)
710	cycle = (uint32_t)hal_get_cycles();
711	if( DEBUG_VFS_OPEN < cycle )
712	printk("\n[%s] thread[%x,%x] found inode(%x,%x) for <%s>\n",
713	__FUNCTION__, process->pid, this->trdid, inode_cxy, inode_ptr, path );
714	#endif
715
716	// create a new file descriptor in cluster containing inode
717	if( inode_cxy == local_cxy ) // target cluster is local
718	{
719	error = vfs_file_create( inode_ptr , file_attr , &file_xp );
720	}
721	else // target cluster is remote
722	{
723	rpc_vfs_file_create_client( inode_cxy , inode_ptr , file_attr , &file_xp , &error );
724	}
725
726	if( error ) return error;
727
728	#if (DEBUG_VFS_OPEN & 1)
729	cycle = (uint32_t)hal_get_cycles();
730	if( DEBUG_VFS_OPEN < cycle )
731	printk("\n[%s] thread[%x,%x] created file descriptor (%x,%x) for <%s>\n",
732	__FUNCTION__, process->pid, this->trdid, GET_CXY(file_xp), GET_PTR(file_xp), path );
733	#endif
734
735	// allocate and register a new file descriptor index in reference process
736	error = process_fd_register( process_xp , file_xp , &file_id );
737
738	if( error ) return error;
739
740	#if DEBUG_VFS_OPEN
741	cycle = (uint32_t)hal_get_cycles();
742	if( DEBUG_VFS_OPEN < cycle )
743	printk("\n[%s] thread[%x,%x] exit for <%s> / fdid %d / cluster %x / cycle %d\n",
744	__FUNCTION__, process->pid, this->trdid, path, file_id, GET_CXY( file_xp ), cycle );
745	#endif
746
747	// success
748	*new_file_xp = file_xp;
749	*new_file_id = file_id;
750	return 0;
751
752	} // end vfs_open()
753
754	//////////////////////////////////////
755	int vfs_user_move( bool_t to_buffer,
756	xptr_t file_xp,
757	void * buffer,
758	uint32_t size )
759	{
760	cxy_t file_cxy; // remote file descriptor cluster
761	vfs_file_t * file_ptr; // remote file descriptor local pointer
762	vfs_inode_type_t inode_type;
763	uint32_t file_offset; // current offset in file
764	mapper_t * mapper;
765	error_t error;
766
767	// check argument
768	assert( (file_xp != XPTR_NULL), "file_xp == XPTR_NULL\n" );
769
770	// get cluster and local pointer on remote file descriptor
771	file_cxy = GET_CXY( file_xp );
772	file_ptr = GET_PTR( file_xp );
773
774	// get inode type from remote file descriptor
775	inode_type = hal_remote_l32( XPTR( file_cxy , &file_ptr->type ) );
776
777	// check inode type
778	assert( (inode_type == INODE_TYPE_FILE), "inode type is not INODE_TYPE_FILE" );
779
780	// get mapper pointer and file offset from file descriptor
781	file_offset = hal_remote_l32( XPTR( file_cxy , &file_ptr->offset ) );
782	mapper = (mapper_t *)hal_remote_lpt( XPTR( file_cxy , &file_ptr->mapper ) );
783
784	// move data between mapper and buffer
785	error = mapper_move_user( XPTR( file_cxy , mapper ),
786	to_buffer,
787	file_offset,
788	buffer,
789	size );
790
791	// update file offset in file descriptor
792	hal_remote_atomic_add( XPTR( file_cxy , &file_ptr->offset ) , size );
793
794	if( error )
795	{
796	return -1;
797	}
798
799	return size;
800
801	} // end vfs_user_move()
802
803	////////////////////////////////////////////
804	error_t vfs_kernel_move( bool_t to_buffer,
805	xptr_t file_xp,
806	xptr_t buffer_xp,
807	uint32_t size )
808	{
809	cxy_t file_cxy; // remote file descriptor cluster
810	vfs_file_t * file_ptr; // remote file descriptor local pointer
811	vfs_inode_type_t inode_type; // remote file type
812	uint32_t file_offset; // current offset in file
813	mapper_t * mapper_ptr; // remote mapper local pointer
814	xptr_t mapper_xp; // remote mapper extended pointer
815	error_t error;
816
817	// check argument
818	assert( (file_xp != XPTR_NULL) , "file_xp == XPTR_NULL\n" );
819
820	// get cluster and local pointer on remote file descriptor
821	file_cxy = GET_CXY( file_xp );
822	file_ptr = GET_PTR( file_xp );
823
824	// get inode type from remote file descriptor
825	inode_type = hal_remote_l32( XPTR( file_cxy , &file_ptr->type ) );
826
827	// action depends on inode type
828	if( inode_type == INODE_TYPE_FILE )
829	{
830	// get mapper pointers and file offset from file descriptor
831	file_offset = hal_remote_l32( XPTR( file_cxy , &file_ptr->offset ) );
832	mapper_ptr = hal_remote_lpt( XPTR( file_cxy , &file_ptr->mapper ) );
833	mapper_xp = XPTR( file_cxy , mapper_ptr );
834
835	// move data between mapper and buffer
836	error = mapper_move_kernel( mapper_xp,
837	to_buffer,
838	file_offset,
839	buffer_xp,
840	size );
841	if( error ) return -1;
842	}
843	else
844	{
845	printk("\n[ERROR] in %s : inode is not a file", __FUNCTION__ );
846	return -1;
847	}
848
849	return 0;
850
851	} // end vfs_kernel_move()
852
853	//////////////////////////////////////
854	error_t vfs_lseek( xptr_t file_xp,
855	uint32_t offset,
856	uint32_t whence,
857	uint32_t * new_offset )
858	{
859	xptr_t offset_xp;
860	xptr_t lock_xp;
861	xptr_t size_xp;
862	cxy_t file_cxy;
863	vfs_file_t * file_ptr;
864	vfs_inode_t * inode_ptr;
865	uint32_t new;
866
867	// check argument
868	assert( (file_xp != XPTR_NULL) , "file_xp == XPTR_NULL\n" );
869
870	// get cluster and local pointer on remote file descriptor
871	file_cxy = GET_CXY( file_xp );
872	file_ptr = GET_PTR( file_xp );
873
874	// get local pointer on remote inode
875	inode_ptr = (vfs_inode_t *)hal_remote_lpt( XPTR( file_cxy , &file_ptr->inode ) );
876
877	// build extended pointers on lock, offset and size
878	offset_xp = XPTR( file_cxy , &file_ptr->offset );
879	lock_xp = XPTR( file_cxy , &file_ptr->lock );
880	size_xp = XPTR( file_cxy , &inode_ptr->size );
881
882	// take file descriptor lock
883	remote_rwlock_wr_acquire( lock_xp );
884
885	if ( whence == SEEK_CUR ) // new = current + offset
886	{
887	new = hal_remote_l32( offset_xp ) + offset;
888	}
889	else if ( whence == SEEK_SET ) // new = offset
890	{
891	new = offset;
892	}
893	else if ( whence == SEEK_END ) // new = size + offset
894	{
895	new = hal_remote_l32( size_xp ) + offset;
896	}
897	else
898	{
899	printk("\n[ERROR] in %s : illegal whence value\n", __FUNCTION__ );
900	remote_rwlock_wr_release( lock_xp );
901	return -1;
902	}
903
904	#if DEBUG_VFS_LSEEK
905	uint32_t cycle = (uint32_t)hal_get_cycles();
906	thread_t * this = CURRENT_THREAD;
907	char name[CONFIG_VFS_MAX_NAME_LENGTH];
908	vfs_inode_get_name( XPTR( file_cxy , inode_ptr ) , name );
909	if( cycle > DEBUG_VFS_LSEEK )
910	printk("\n[%s] thread[%x,%x] for <%s> / new offset %d / cycle %d\n",
911	__FUNCTION__ , this->process->pid, this->trdid, name, new, cycle );
912	#endif
913
914	// set new offset
915	hal_remote_s32( offset_xp , new );
916
917	// release file descriptor lock
918	remote_rwlock_wr_release( lock_xp );
919
920	// success
921	if ( new_offset != NULL ) *new_offset = new;
922	return 0;
923
924	} // vfs_lseek()
925
926	////////////////////////////////////
927	error_t vfs_close( xptr_t file_xp,
928	uint32_t file_id )
929	{
930	cxy_t file_cxy; // cluster containing the file descriptor.
931	vfs_file_t * file_ptr; // local ponter on file descriptor
932	cxy_t owner_cxy; // process owner cluster
933	pid_t pid; // process identifier
934	lpid_t lpid; // process local index
935	xptr_t root_xp; // root of xlist (processes , or dentries)
936	xptr_t lock_xp; // lock protecting the xlist
937	xptr_t iter_xp; // iterator on xlist
938	mapper_t * mapper_ptr; // local pointer on associated mapper
939	xptr_t mapper_xp; // extended pointer on mapper
940	vfs_inode_t * inode_ptr; // local pointer on associated inode
941	xptr_t inode_xp; // extended pointer on inode
942	uint32_t size; // current file size (from inode descriptor)
943	error_t error;
944
945	char name[CONFIG_VFS_MAX_NAME_LENGTH]; // file name
946
947	// check argument
948	assert( (file_xp != XPTR_NULL) , "file_xp is XPTR_NULL\n" );
949
950	thread_t * this = CURRENT_THREAD;
951	process_t * process = this->process;
952	cluster_t * cluster = LOCAL_CLUSTER;
953
954	// get file name
955	vfs_file_get_name( file_xp , name );
956
957	#if DEBUG_VFS_CLOSE
958	uint32_t cycle = (uint32_t)hal_get_cycles();
959	if( DEBUG_VFS_CLOSE < cycle )
960	printk("\n[%s] thread[%x,%x] enter for <%s> / cycle %d\n",
961	__FUNCTION__, process->pid, this->trdid, name, cycle );
962	#endif
963
964	// get cluster and local pointer on remote file descriptor
965	file_cxy = GET_CXY( file_xp );
966	file_ptr = GET_PTR( file_xp );
967
968	//////// 1) update all dirty pages from mapper to device
969
970	// get pointers on mapper associated to file
971	mapper_ptr = hal_remote_lpt( XPTR( file_cxy , &file_ptr->mapper ) );
972	mapper_xp = XPTR( file_cxy , mapper_ptr );
973
974	// copy all dirty pages from mapper to device
975	if( file_cxy == local_cxy )
976	{
977	error = mapper_sync( mapper_ptr );
978	}
979	else
980	{
981	rpc_mapper_sync_client( file_cxy,
982	mapper_ptr,
983	&error );
984	}
985
986	if( error )
987	{
988	printk("\n[ERROR] in %s : cannot synchronise dirty pages for <%s>\n",
989	__FUNCTION__, name );
990	return -1;
991	}
992
993	#if DEBUG_VFS_CLOSE
994	if( DEBUG_VFS_CLOSE < cycle )
995	printk("\n[%s] thread[%x,%x] synchronised mapper of <%s> to device\n",
996	__FUNCTION__, process->pid, this->trdid, name );
997	#endif
998
999	//////// 2) update file size in all parent directory mapper(s) and on device
1000
1001	// get pointers on remote inode
1002	inode_ptr = hal_remote_lpt( XPTR( file_cxy , &file_ptr->inode ) );
1003	inode_xp = XPTR( file_cxy , inode_ptr );
1004
1005	// get file size from remote inode
1006	size = hal_remote_l32( XPTR( file_cxy , &inode_ptr->size ) );
1007
1008	// get root of list of parents dentry
1009	root_xp = XPTR( file_cxy , &inode_ptr->parents );
1010
1011	// loop on all parents
1012	XLIST_FOREACH( root_xp , iter_xp )
1013	{
1014	// get pointers on parent directory dentry
1015	xptr_t parent_dentry_xp = XLIST_ELEMENT( iter_xp , vfs_dentry_t , parents );
1016	cxy_t parent_cxy = GET_CXY( parent_dentry_xp );
1017	vfs_dentry_t * parent_dentry_ptr = GET_PTR( parent_dentry_xp );
1018
1019	// get local pointer on parent directory inode
1020	vfs_inode_t * parent_inode_ptr = hal_remote_lpt( XPTR( parent_cxy,
1021	&parent_dentry_ptr->parent ) );
1022
1023	// get local pointer on parent directory mapper
1024	mapper_t * parent_mapper_ptr = hal_remote_lpt( XPTR( parent_cxy,
1025	&parent_inode_ptr->mapper ) );
1026
1027	// update dentry size in parent directory mapper
1028	if( parent_cxy == local_cxy )
1029	{
1030	error = vfs_fs_update_dentry( parent_inode_ptr,
1031	parent_dentry_ptr,
1032	size );
1033	}
1034	else
1035	{
1036	rpc_vfs_fs_update_dentry_client( parent_cxy,
1037	parent_inode_ptr,
1038	parent_dentry_ptr,
1039	size,
1040	&error );
1041	}
1042
1043	if( error )
1044	{
1045	printk("\n[ERROR] in %s : cannot update size in parent\n",
1046	__FUNCTION__ );
1047	return -1;
1048	}
1049
1050	#if DEBUG_VFS_CLOSE
1051	char parent_name[CONFIG_VFS_MAX_NAME_LENGTH];
1052	vfs_inode_get_name( XPTR( parent_cxy , parent_inode_ptr ) , parent_name );
1053	if( DEBUG_VFS_CLOSE < cycle )
1054	printk("\n[%s] thread[%x,%x] updated size of <%s> in parent <%s>\n",
1055	__FUNCTION__, process->pid, this->trdid, name, parent_name );
1056	#endif
1057
1058	// copy all dirty pages from parent mapper to device
1059	if( parent_cxy == local_cxy )
1060	{
1061	error = mapper_sync( parent_mapper_ptr );
1062	}
1063	else
1064	{
1065	rpc_mapper_sync_client( parent_cxy,
1066	parent_mapper_ptr,
1067	&error );
1068	}
1069
1070	if( error )
1071	{
1072	printk("\n[ERROR] in %s : cannot synchronise parent mapper to device\n",
1073	__FUNCTION__ );
1074	return -1;
1075	}
1076
1077	#if DEBUG_VFS_CLOSE
1078	if( DEBUG_VFS_CLOSE < cycle )
1079	printk("\n[%s] thread[%x,%x] synchonized mapper of parent <%s> to device\n",
1080	__FUNCTION__, process->pid, this->trdid, parent_name );
1081	#endif
1082
1083	}
1084
1085	//////// 3) loop on the process copies to reset all fd_array[file_id] entries
1086
1087	// get owner process cluster and lpid
1088	pid = process->pid;
1089	owner_cxy = CXY_FROM_PID( pid );
1090	lpid = LPID_FROM_PID( pid );
1091
1092	// get extended pointers on copies root and lock
1093	root_xp = XPTR( owner_cxy , &cluster->pmgr.copies_root[lpid] );
1094	lock_xp = XPTR( owner_cxy , &cluster->pmgr.copies_lock[lpid] );
1095
1096	// take the lock protecting the list of copies
1097	remote_queuelock_acquire( lock_xp );
1098
1099	XLIST_FOREACH( root_xp , iter_xp )
1100	{
1101	xptr_t process_xp = XLIST_ELEMENT( iter_xp , process_t , copies_list );
1102	cxy_t process_cxy = GET_CXY( process_xp );
1103	process_t * process_ptr = GET_PTR( process_xp );
1104
1105	xptr_t entry_xp = XPTR( process_cxy , &process_ptr->fd_array.array[file_id] );
1106	hal_remote_s64( entry_xp , XPTR_NULL );
1107	vfs_file_count_down( file_xp );
1108	hal_fence();
1109	}
1110
1111	// release the lock protecting the list of copies
1112	remote_queuelock_release( lock_xp );
1113
1114	#if DEBUG_VFS_CLOSE
1115	if( DEBUG_VFS_CLOSE < cycle )
1116	printk("\n[%s] thread[%x,%x] reset all fd-array copies for <%x>\n",
1117	__FUNCTION__, process->pid, this->trdid, name );
1118	#endif
1119
1120	//////// 4) release memory allocated to file descriptor in remote cluster
1121
1122	if( file_cxy == local_cxy ) // file cluster is local
1123	{
1124	vfs_file_destroy( file_ptr );
1125	}
1126	else // file cluster is local
1127	{
1128	rpc_vfs_file_destroy_client( file_cxy , file_ptr );
1129	}
1130
1131	#if DEBUG_VFS_CLOSE
1132	cycle = (uint32_t)hal_get_cycles();
1133	if( DEBUG_VFS_CLOSE < cycle )
1134	printk("\n[%s] thread[%x,%x] exit / <%s> closed / cycle %d\n",
1135	__FUNCTION__, process->pid, this->trdid, name, cycle );
1136	#endif
1137
1138	return 0;
1139
1140	} // end vfs_close()
1141
1142	////////////////////////////////////
1143	error_t vfs_mkdir( xptr_t root_xp,
1144	char * path,
1145	uint32_t rights )
1146	{
1147	error_t error;
1148	xptr_t vfs_root_xp; // extended pointer on VFS root inode
1149	vfs_inode_t * vfs_root_ptr; // local pointer on VFS root inode
1150	cxy_t vfs_root_cxy; // VFS root inode cluster identifier
1151	xptr_t lock_xp; // extended pointer on lock protecting Inode Tree
1152	xptr_t inode_xp; // extended pointer on new directory inode
1153	vfs_inode_t * inode_ptr; // local pointer on new directory inode
1154	cxy_t inode_cxy; // new directory inode cluster identifier
1155	xptr_t dentry_xp; // extended pointer on new dentry
1156	vfs_dentry_t * dentry_ptr; // new dentry local pointer
1157	xptr_t parent_xp; // extended pointer on parent inode
1158	vfs_inode_t * parent_ptr; // local pointer on parent inode
1159	cxy_t parent_cxy; // parent inode cluster identifier
1160	vfs_ctx_t * parent_ctx_ptr; // local pointer on parent inode context
1161	uint32_t parent_fs_type; // parent inode file system type
1162
1163	xptr_t parents_root_xp; // extended pointer on parents field in inode (root)
1164	xptr_t parents_entry_xp; // extended pointer on parents field in dentry
1165	xptr_t children_xhtab_xp; // extended pointer on children field in inode (root)
1166	xptr_t children_entry_xp; // extended pointer on children field in dentry
1167
1168	char last_name[CONFIG_VFS_MAX_NAME_LENGTH];
1169
1170	thread_t * this = CURRENT_THREAD;
1171	process_t * process = this->process;
1172
1173	#if DEBUG_VFS_MKDIR
1174	char root_name[CONFIG_VFS_MAX_NAME_LENGTH];
1175	vfs_inode_get_name( root_xp , root_name );
1176	uint32_t cycle = (uint32_t)hal_get_cycles();
1177	if( DEBUG_VFS_MKDIR < cycle )
1178	printk("\n[%s] thread[%x,%x] enter / root <%s> / path <%s> / cycle %d\n",
1179	__FUNCTION__, process->pid, this->trdid, root_name, path, cycle );
1180	#endif
1181
1182	// build extended pointer on lock protecting Inode Tree (in VFS root inode)
1183	vfs_root_xp = process->vfs_root_xp;
1184	vfs_root_ptr = GET_PTR( vfs_root_xp );
1185	vfs_root_cxy = GET_CXY( vfs_root_xp );
1186	lock_xp = XPTR( vfs_root_cxy , &vfs_root_ptr->main_lock );
1187
1188	// take the lock protecting Inode Tree in write mode
1189	remote_rwlock_wr_acquire( lock_xp );
1190
1191	// 1. get pointers on parent inode
1192	error = vfs_lookup( root_xp,
1193	path,
1194	VFS_LOOKUP_DIR \| VFS_LOOKUP_PARENT,
1195	&parent_xp,
1196	last_name );
1197	if( error )
1198	{
1199	remote_rwlock_wr_release( lock_xp );
1200	printk("\n[ERROR] in %s : cannot get parent inode for <%s>\n",
1201	__FUNCTION__, path );
1202	return -1;
1203	}
1204
1205	// get parent inode cluster and local pointer
1206	parent_cxy = GET_CXY( parent_xp );
1207	parent_ptr = GET_PTR( parent_xp );
1208
1209	#if( DEBUG_VFS_MKDIR & 1 )
1210	if( DEBUG_VFS_MKDIR < cycle )
1211	printk("\n[%s] thread[%x,%x] get parent inode (%x,%x) for <%s>\n",
1212	__FUNCTION__, process->pid, this->trdid, parent_cxy, parent_ptr, path );
1213	#endif
1214
1215	// get parent inode context, and FS type
1216	parent_ctx_ptr = hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->ctx ) );
1217	parent_fs_type = hal_remote_l32( XPTR( parent_cxy , &parent_ctx_ptr->type ) );
1218
1219	// 2. create one new dentry in parent cluster
1220	if( parent_cxy == local_cxy )
1221	{
1222	error = vfs_dentry_create( parent_fs_type,
1223	last_name,
1224	&dentry_xp );
1225	}
1226	else
1227	{
1228	rpc_vfs_dentry_create_client( parent_cxy,
1229	parent_fs_type,
1230	last_name,
1231	&dentry_xp,
1232	&error );
1233	}
1234
1235	if( error )
1236	{
1237	remote_rwlock_wr_release( lock_xp );
1238	printk("\n[ERROR] in %s : cannot create new dentry in cluster %x for <%s>\n",
1239	__FUNCTION__, parent_cxy, path );
1240	return -1;
1241	}
1242
1243	// get local pointer on dentry
1244	dentry_ptr = GET_PTR( dentry_xp );
1245
1246	#if( DEBUG_VFS_MKDIR & 1 )
1247	if( DEBUG_VFS_MKDIR < cycle )
1248	printk("\n[%s] thread[%x,%x] created new dentry (%x,%x) for <%s>\n",
1249	__FUNCTION__, process->pid, this->trdid, parent_cxy, dentry_ptr, path );
1250	#endif
1251
1252	// 3. create new directory inode
1253	// TODO : define attr / uid / gid
1254	uint32_t attr = 0;
1255	uint32_t uid = 0;
1256	uint32_t gid = 0;
1257
1258	// select a target cluster for new inode
1259	inode_cxy = cluster_random_select();
1260
1261	if( inode_cxy == local_cxy ) // target cluster is local
1262	{
1263	error = vfs_inode_create( parent_fs_type,
1264	attr,
1265	rights,
1266	uid,
1267	gid,
1268	&inode_xp );
1269	}
1270	else // target cluster is remote
1271	{
1272	rpc_vfs_inode_create_client( inode_cxy,
1273	parent_fs_type,
1274	attr,
1275	rights,
1276	uid,
1277	gid,
1278	&inode_xp,
1279	&error );
1280	}
1281
1282	if( error )
1283	{
1284	remote_rwlock_wr_release( lock_xp );
1285	printk("\n[ERROR] in %s : cannot create new inode in cluster %x for <%s>\n",
1286	__FUNCTION__ , inode_cxy , path );
1287	if( parent_cxy == local_cxy ) vfs_dentry_destroy( dentry_ptr );
1288	else rpc_vfs_dentry_destroy_client( parent_cxy , dentry_ptr );
1289	return -1;
1290	}
1291
1292	// get new inode local pointer
1293	inode_ptr = GET_PTR( inode_xp );
1294
1295	// update inode "type" field
1296	hal_remote_s32( XPTR( inode_cxy , &inode_ptr->type ) , INODE_TYPE_DIR );
1297
1298	#if(DEBUG_VFS_MKDIR & 1)
1299	if( DEBUG_VFS_MKDIR < cycle )
1300	printk("\n[%s] thread[%x,%x] created new inode (%x,%x) for <%s>\n",
1301	__FUNCTION__ , process->pid, this->trdid, inode_cxy, inode_ptr, path );
1302	#endif
1303
1304	// 4. register dentry in new inode list of parents
1305	parents_root_xp = XPTR( inode_cxy , &inode_ptr->parents );
1306	parents_entry_xp = XPTR( parent_cxy , &dentry_ptr->parents );
1307	xlist_add_first( parents_root_xp , parents_entry_xp );
1308	hal_remote_atomic_add( XPTR( inode_cxy , &inode_ptr->links ) , 1 );
1309
1310	// 5. register dentry in parent inode
1311	children_xhtab_xp = XPTR( parent_cxy , &parent_ptr->children );
1312	children_entry_xp = XPTR( parent_cxy , &dentry_ptr->children );
1313	xhtab_insert( children_xhtab_xp , last_name , children_entry_xp );
1314
1315	// 6. update "parent" and "child_xp" fields in dentry
1316	hal_remote_s64( XPTR( parent_cxy , &dentry_ptr->child_xp ) , inode_xp );
1317	hal_remote_spt( XPTR( parent_cxy , &dentry_ptr->parent ) , parent_ptr );
1318
1319	#if(DEBUG_VFS_MKDIR & 1)
1320	if( DEBUG_VFS_MKDIR < cycle )
1321	printk("\n[%s] thread[%x,%x] updated Inode Tree for <%s>\n",
1322	__FUNCTION__, process->pid, this->trdid, path );
1323	#endif
1324
1325	// 7. create the two special dentries <.> and <..> in new directory
1326	// both the new directory mapper, and the Inode Tree are updated
1327	error = vfs_add_special_dentries( inode_xp,
1328	parent_xp );
1329
1330	if( error )
1331	{
1332	remote_rwlock_wr_release( lock_xp );
1333	printk("\n[ERROR] in %s : cannot create new inode in cluster %x for <%s>\n",
1334	__FUNCTION__ , inode_cxy , path );
1335	if( parent_cxy == local_cxy ) vfs_dentry_destroy( dentry_ptr );
1336	else rpc_vfs_dentry_destroy_client( parent_cxy , dentry_ptr );
1337	return -1;
1338	}
1339
1340	// release the lock protecting Inode Tree
1341	remote_rwlock_wr_release( lock_xp );
1342
1343	// 8. update parent directory mapper
1344	// and synchronize the parent directory on IOC device
1345	if (parent_cxy == local_cxy)
1346	{
1347	error = vfs_fs_add_dentry( parent_ptr,
1348	dentry_ptr );
1349	}
1350	else
1351	{
1352	rpc_vfs_fs_add_dentry_client( parent_cxy,
1353	parent_ptr,
1354	dentry_ptr,
1355	&error );
1356	}
1357
1358	if( error )
1359	{
1360	printk("\n[ERROR] in %s : cannot update parent directory for <%s>\n",
1361	__FUNCTION__, path );
1362	return -1;
1363	}
1364
1365	#if(DEBUG_VFS_MKDIR & 1)
1366	if( DEBUG_VFS_MKDIR < cycle )
1367	printk("\n[%s] thread[%x,%x] updated parent dir (mapper and IOC) for <%s>\n",
1368	__FUNCTION__, process->pid, this->trdid, path );
1369	#endif
1370
1371	return 0;
1372
1373	} // end vfs_mkdir()
1374
1375	///////////////////////////////////////
1376	error_t vfs_link( xptr_t old_root_xp,
1377	char * old_path,
1378	xptr_t new_root_xp,
1379	char * new_path )
1380	{
1381	error_t error;
1382	xptr_t vfs_root_xp; // extended pointer on VFS root inode
1383	vfs_inode_t * vfs_root_ptr; // local pointer on VFS root inode
1384	cxy_t vfs_root_cxy; // VFS root inode cluster identifier
1385	xptr_t lock_xp; // extended pointer on lock protecting Inode Tree
1386	xptr_t inode_xp; // extended pointer on target inode
1387	vfs_inode_t * inode_ptr; // local pointer on target inode
1388	cxy_t inode_cxy; // target inode cluster identifier
1389	uint32_t inode_type; // target inode type
1390	vfs_ctx_t * inode_ctx_ptr; // local pointer on target inode context
1391	uint32_t inode_fs_type; // target inode file system type
1392	xptr_t dentry_xp; // extended pointer on new dentry
1393	vfs_dentry_t * dentry_ptr; // target dentry local pointer
1394	xptr_t new_parent_xp; // extended pointer on new parent inode
1395	vfs_inode_t * new_parent_ptr; // local pointer on new parent inode
1396	cxy_t new_parent_cxy; // new parent inode cluster identifier
1397
1398	xptr_t parents_root_xp; // extended pointer on parents field in inode (root)
1399	xptr_t parents_entry_xp; // extended pointer on parents field in dentry
1400	xptr_t children_xhtab_xp; // extended pointer on children field in inode (root)
1401	xptr_t children_entry_xp; // extended pointer on children field in dentry
1402
1403	char new_name[CONFIG_VFS_MAX_NAME_LENGTH];
1404
1405	thread_t * this = CURRENT_THREAD;
1406	process_t * process = this->process;
1407
1408	#if DEBUG_VFS_LINK
1409	char old_root_name[CONFIG_VFS_MAX_NAME_LENGTH];
1410	char new_root_name[CONFIG_VFS_MAX_NAME_LENGTH];
1411	vfs_inode_get_name( old_root_xp , old_root_name );
1412	vfs_inode_get_name( new_root_xp , new_root_name );
1413	uint32_t cycle = (uint32_t)hal_get_cycles();
1414	if( DEBUG_VFS_LINK < cycle )
1415	printk("\n[%s] thread[%x,%x] enter / old_root <%s> / old_path <%s> / "
1416	"new_root <%s> / new_path <%s> / cycle %d\n",
1417	__FUNCTION__, process->pid, this->trdid,
1418	old_root_name, old_path, new_root_name, new_path, cycle );
1419	#endif
1420
1421	// build extended pointer on lock protecting Inode Tree (in VFS root inode)
1422	vfs_root_xp = process->vfs_root_xp;
1423	vfs_root_ptr = GET_PTR( vfs_root_xp );
1424	vfs_root_cxy = GET_CXY( vfs_root_xp );
1425	lock_xp = XPTR( vfs_root_cxy , &vfs_root_ptr->main_lock );
1426
1427	// take the lock protecting Inode Tree in write mode
1428	remote_rwlock_wr_acquire( lock_xp );
1429
1430	// get extended pointer on target inode
1431	error = vfs_lookup( old_root_xp,
1432	old_path,
1433	0,
1434	&inode_xp,
1435	NULL );
1436	if( error )
1437	{
1438	remote_rwlock_wr_release( lock_xp );
1439	printk("\n[ERROR] in %s : cannot get target inode for <%s>\n",
1440	__FUNCTION__, old_path );
1441	return -1;
1442	}
1443
1444	#if( DEBUG_VFS_LINK & 1 )
1445	if( DEBUG_VFS_LINK < cycle )
1446	printk("\n[%s] thread[%x,%x] get child inode (%x,%x) for <%s>\n",
1447	__FUNCTION__, process->pid, this->trdid,
1448	GET_CXY(inode_xp), GET_PTR(inode_xp), old_path, cycle );
1449	#endif
1450
1451	// get extended pointer on parent inode in new path
1452	error = vfs_lookup( new_root_xp,
1453	new_path,
1454	VFS_LOOKUP_PARENT,
1455	&new_parent_xp,
1456	new_name );
1457	if( error )
1458	{
1459	remote_rwlock_wr_release( lock_xp );
1460	printk("\n[ERROR] in %s : cannot get parent inode for <%s>\n",
1461	__FUNCTION__, new_path );
1462	return -1;
1463	}
1464
1465	#if( DEBUG_VFS_LINK & 1 )
1466	if( DEBUG_VFS_LINK < cycle )
1467	printk("\n[%s] thread[%x,%x] get parent inode (%x,%x) for <%s>\n",
1468	__FUNCTION__, process->pid, this->trdid,
1469	GET_CXY(new_parent_xp), GET_PTR(new_parent_xp), new_path );
1470	#endif
1471
1472	// get target inode cluster and local pointer
1473	inode_cxy = GET_CXY( inode_xp );
1474	inode_ptr = GET_PTR( inode_xp );
1475
1476	// get target inode type, context, and FS type
1477	inode_type = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->type ) );
1478	inode_ctx_ptr = hal_remote_lpt( XPTR( inode_cxy , &inode_ptr->ctx ) );
1479	inode_fs_type = hal_remote_l32( XPTR( inode_cxy , &inode_ctx_ptr->type ) );
1480
1481	// get new parent inode cluster an local pointer
1482	new_parent_ptr = GET_PTR( new_parent_xp );
1483	new_parent_cxy = GET_CXY( new_parent_xp );
1484
1485	///////////////////////////////////////////////////////////////////////
1486	if( (inode_type == INODE_TYPE_FILE) \|\| (inode_type == INODE_TYPE_DIR) )
1487	{
1488	// 1. create one new dentry
1489	if( new_parent_cxy == local_cxy )
1490	{
1491	error = vfs_dentry_create( inode_fs_type,
1492	new_name,
1493	&dentry_xp );
1494	}
1495	else
1496	{
1497	rpc_vfs_dentry_create_client( new_parent_cxy,
1498	inode_fs_type,
1499	new_name,
1500	&dentry_xp,
1501	&error );
1502	}
1503
1504	if( error )
1505	{
1506	remote_rwlock_wr_release( lock_xp );
1507	printk("\n[ERROR] in %s : cannot create new dentry for <%s>\n",
1508	__FUNCTION__, new_path );
1509	return -1;
1510	}
1511
1512	// get local pointer on dentry
1513	dentry_ptr = GET_PTR( dentry_xp );
1514
1515	// 2. register dentry in target inode
1516	parents_root_xp = XPTR( inode_cxy , &inode_ptr->parents );
1517	parents_entry_xp = XPTR( new_parent_cxy , &dentry_ptr->parents );
1518	xlist_add_first( parents_root_xp , parents_entry_xp );
1519	hal_remote_atomic_add( XPTR( inode_cxy , &inode_ptr->links ) , 1 );
1520
1521	// 3. register dentry in parent inode
1522	children_xhtab_xp = XPTR( new_parent_cxy , &new_parent_ptr->children );
1523	children_entry_xp = XPTR( new_parent_cxy , &dentry_ptr->children );
1524	xhtab_insert( children_xhtab_xp , new_name , children_entry_xp );
1525
1526	// 4. update "parent" and "child_xp" fields in dentry
1527	hal_remote_s64( XPTR( new_parent_cxy , &dentry_ptr->child_xp ) , inode_xp );
1528	hal_remote_spt( XPTR( new_parent_cxy , &dentry_ptr->parent ) , new_parent_ptr );
1529
1530	#if(DEBUG_VFS_LINK & 1)
1531	if( DEBUG_VFS_LINK < cycle )
1532	printk("\n[%s] thread[%x,%x] updated Inode Tree / old <%s> / new <%s>\n",
1533	__FUNCTION__, process->pid, this->trdid, old_path, new_path );
1534	vfs_display( new_parent_xp );
1535	#endif
1536
1537	// release the lock protecting Inode Tree
1538	remote_rwlock_wr_release( lock_xp );
1539
1540	// 5. update new parent directory mapper in Inode Tree
1541	// and synchronize the parent directory on IOC device
1542	if (new_parent_cxy == local_cxy)
1543	{
1544	error = vfs_fs_add_dentry( new_parent_ptr,
1545	dentry_ptr );
1546	}
1547	else
1548	{
1549	rpc_vfs_fs_add_dentry_client( new_parent_cxy,
1550	new_parent_ptr,
1551	dentry_ptr,
1552	&error );
1553	}
1554	if( error )
1555	{
1556	printk("\n[ERROR] in %s : cannot update new parent directory for <%s>\n",
1557	__FUNCTION__, new_path );
1558	return -1;
1559	}
1560
1561	#if(DEBUG_VFS_LINK & 1)
1562	if( DEBUG_VFS_LINK < cycle )
1563	printk("\n[%s] thread[%x,%x] updated new parent dir (mapper and IOC) / old <%s> / new <%s>\n",
1564	__FUNCTION__, process->pid, this->trdid, old_path, new_path );
1565	#endif
1566	return 0;
1567	}
1568	else
1569	{
1570	// release the lock protecting Inode Tree
1571	remote_rwlock_wr_release( lock_xp );
1572
1573	printk("\n[ERROR] in %s : unsupported inode type %s\n",
1574	__FUNCTION__ , vfs_inode_type_str( inode_type ) );
1575	return -1;
1576	}
1577
1578	} // end vfs_link()
1579
1580	/////////////////////////////////////
1581	error_t vfs_unlink( xptr_t root_xp,
1582	char * path )
1583	{
1584	error_t error;
1585	xptr_t vfs_root_xp; // extended pointer on VFS root inode
1586	vfs_inode_t * vfs_root_ptr; // local_pointer on VFS root inode
1587	cxy_t vfs_root_cxy; // VFS root inode cluster identifier
1588	xptr_t lock_xp; // extended pointer on lock protecting Inode Tree
1589	xptr_t parent_xp; // extended pointer on target inode
1590	cxy_t parent_cxy; // target inode cluster identifier
1591	vfs_inode_t * parent_ptr; // target inode local pointer
1592	xptr_t inode_xp; // extended pointer on target inode
1593	cxy_t inode_cxy; // target inode cluster identifier
1594	vfs_inode_t * inode_ptr; // target inode local pointer
1595	uint32_t inode_links; // target inode links count
1596	vfs_inode_type_t inode_type; // target inode type
1597	uint32_t inode_children; // target inode number of children
1598	xptr_t dentry_xp; // extended pointer on dentry to unlink
1599	vfs_dentry_t * dentry_ptr; // local pointer on dentry to unlink
1600	vfs_ctx_t * ctx_ptr; // local pointer on FS context
1601	vfs_fs_type_t fs_type; // File system type
1602
1603	char name[CONFIG_VFS_MAX_NAME_LENGTH]; // name of link to remove
1604
1605	thread_t * this = CURRENT_THREAD;
1606	process_t * process = this->process;
1607
1608	#if DEBUG_VFS_UNLINK
1609	uint32_t cycle = (uint32_t)hal_get_cycles();
1610	char root_name[CONFIG_VFS_MAX_NAME_LENGTH];
1611	vfs_inode_get_name( root_xp , root_name );
1612	if( DEBUG_VFS_UNLINK < cycle )
1613	printk("\n[%s] thread[%x,%x] : enter for root <%s> / path <%s> / cycle %d\n",
1614	__FUNCTION__, process->pid, this->trdid, root_name, path, cycle );
1615	#endif
1616
1617	// build extended pointer on lock protecting Inode Tree (in VFS root inode)
1618	vfs_root_xp = process->vfs_root_xp;
1619	vfs_root_ptr = GET_PTR( root_xp );
1620	vfs_root_cxy = GET_CXY( root_xp );
1621	lock_xp = XPTR( vfs_root_cxy , &vfs_root_ptr->main_lock );
1622
1623	// take the lock protecting Inode Tree
1624	remote_rwlock_wr_acquire( lock_xp );
1625
1626	// get extended pointer on parent inode
1627	error = vfs_lookup( root_xp,
1628	path,
1629	VFS_LOOKUP_PARENT,
1630	&parent_xp,
1631	name );
1632	if( error )
1633	{
1634	remote_rwlock_wr_release( lock_xp );
1635	printk("\n[ERROR] in %s : cannot get parent inode for <%s> in <%s>\n",
1636	__FUNCTION__, name, path );
1637	return -1;
1638	}
1639
1640	// get parent inode cluster and local pointer
1641	parent_cxy = GET_CXY( parent_xp );
1642	parent_ptr = GET_PTR( parent_xp );
1643
1644	#if( DEBUG_VFS_UNLINK & 1 )
1645	char parent_name[CONFIG_VFS_MAX_NAME_LENGTH];
1646	vfs_inode_get_name( parent_xp , parent_name );
1647	if( DEBUG_VFS_UNLINK < cycle )
1648	printk("\n[%s] thread[%x,%x] : parent inode <%s> is (%x,%x)\n",
1649	__FUNCTION__, process->pid, this->trdid, parent_name, parent_cxy, parent_ptr );
1650	#endif
1651
1652	// build extended pointer on parent inode "children" xhtab
1653	xptr_t children_xp = XPTR( parent_cxy , &parent_ptr->children );
1654
1655	// try to get extended pointer on dentry from Inode Tree
1656	dentry_xp = xhtab_lookup( children_xp , name );
1657
1658	// when dentry not found in Inode Tree, try to get it from inode tree
1659
1660	if( dentry_xp == XPTR_NULL ) // miss target dentry in Inode Tree
1661	{
1662
1663	#if( DEBUG_VFS_UNLINK & 1 )
1664	if( DEBUG_VFS_UNLINK < cycle )
1665	printk("\n[%s] thread[%x,%x] : inode <%s> not found => scan parent mapper\n",
1666	__FUNCTION__, process->pid, this->trdid, name );
1667	#endif
1668	// get parent inode FS type
1669	ctx_ptr = hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->ctx ) );
1670	fs_type = hal_remote_l32( XPTR( parent_cxy , &ctx_ptr->type ) );
1671
1672	// select a cluster for new inode
1673	inode_cxy = cluster_random_select();
1674
1675	// speculatively insert a new child dentry/inode couple in inode tree
1676	error = vfs_add_child_in_parent( inode_cxy,
1677	fs_type,
1678	parent_xp,
1679	name,
1680	&dentry_xp,
1681	&inode_xp );
1682	if( error )
1683	{
1684	printk("\n[ERROR] in %s : cannot create inode <%s> in path <%s>\n",
1685	__FUNCTION__ , name, path );
1686
1687	vfs_remove_child_from_parent( dentry_xp );
1688	return -1;
1689	}
1690
1691	// get local pointers on new dentry and new inode descriptors
1692	inode_ptr = GET_PTR( inode_xp );
1693	dentry_ptr = GET_PTR( dentry_xp );
1694
1695	// scan parent mapper to find the missing dentry, and complete
1696	// initialisation of new dentry and new inode descriptors In Inode Tree
1697	if( parent_cxy == local_cxy )
1698	{
1699	error = vfs_fs_new_dentry( parent_ptr,
1700	name,
1701	inode_xp );
1702	}
1703	else
1704	{
1705	rpc_vfs_fs_new_dentry_client( parent_cxy,
1706	parent_ptr,
1707	name,
1708	inode_xp,
1709	&error );
1710	}
1711
1712	if ( error ) // dentry not found in parent mapper
1713	{
1714	printk("\n[ERROR] in %s : cannot get dentry <%s> in path <%s>\n",
1715	__FUNCTION__ , name, path );
1716	return -1;
1717	}
1718
1719	#if (DEBUG_VFS_UNLINK & 1)
1720	if( DEBUG_VFS_UNLINK < cycle )
1721	printk("\n[%s] thread[%x,%x] : created missing inode & dentry <%s> in cluster %x\n",
1722	__FUNCTION__, process->pid, this->trdid, name, inode_cxy );
1723	#endif
1724
1725	}
1726	else // found target dentry in Inode Tree
1727	{
1728	dentry_ptr = GET_PTR( dentry_xp );
1729
1730	// get pointer on target inode from dentry
1731	inode_xp = hal_remote_l64( XPTR( parent_cxy , &dentry_ptr->child_xp ) );
1732	inode_cxy = GET_CXY( inode_xp );
1733	inode_ptr = GET_PTR( inode_xp );
1734	}
1735
1736	// At this point the Inode Tree contains the target dentry and child inode
1737	// we can safely remove this dentry from both the parent mapper, and the Inode Tree.
1738
1739	#if( DEBUG_VFS_UNLINK & 1 )
1740	if( DEBUG_VFS_UNLINK < cycle )
1741	printk("\n[%s] thread[%x,%x] : dentry (%x,%x) / inode (%x,%x)\n",
1742	__FUNCTION__, process->pid, this->trdid, parent_cxy, dentry_ptr, inode_cxy, inode_ptr );
1743	#endif
1744
1745	// get target inode "type" and "links"
1746	inode_type = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->type ) );
1747	inode_links = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->links ) );
1748
1749	///////////////////////////////////////////////////////////////////////
1750	if( (inode_type == INODE_TYPE_FILE) \|\| (inode_type == INODE_TYPE_DIR) )
1751	{
1752
1753	#if( DEBUG_VFS_UNLINK & 1 )
1754	if( DEBUG_VFS_UNLINK < cycle )
1755	printk("\n[%s] thread[%x,%x] : unlink inode <%s> / type %s / %d links\n",
1756	__FUNCTION__, process->pid, this->trdid, name, vfs_inode_type_str(inode_type), inode_links );
1757	#endif
1758
1759	// 1. Release clusters allocated to target inode
1760	// and synchronize the FAT on IOC device if last link.
1761	if( inode_links == 1 )
1762	{
1763	// build extended pointer on target inode "children" number
1764	xptr_t inode_children_xp = XPTR( inode_cxy , &inode_ptr->children.items );
1765
1766	printk("\n@@@ in %s : children_xp = (%x,%x)\n",
1767	__FUNCTION__, inode_cxy, &inode_ptr->children.items );
1768
1769	// get target inode number of children
1770	inode_children = hal_remote_l32( inode_children_xp );
1771
1772	// check no children
1773	if( inode_children != 0 )
1774	{
1775	remote_rwlock_wr_release( lock_xp );
1776	printk("\n[ERROR] in %s : cannot remove <%s> inode that has children\n",
1777	__FUNCTION__, path );
1778	return -1;
1779	}
1780
1781	// release clusters on IOC device
1782	error = vfs_fs_release_inode( inode_xp );
1783
1784	if( error )
1785	{
1786	remote_rwlock_wr_release( lock_xp );
1787	printk("\n[ERROR] in %s : cannot update FAT mapper to remove <%s> inode\n",
1788	__FUNCTION__ , path );
1789	return -1;
1790	}
1791
1792	#if(DEBUG_VFS_UNLINK & 1)
1793	if( DEBUG_VFS_UNLINK < cycle )
1794	printk("\n[%s] thread[%x,%x] removed <%s> inode from FAT (mapper and IOC device)\n",
1795	__FUNCTION__, process->pid, this->trdid, path );
1796	#endif
1797	}
1798
1799	// 2. update parent directory mapper
1800	// and synchronize the parent directory on IOC device
1801	if (parent_cxy == local_cxy)
1802	{
1803	error = vfs_fs_remove_dentry( parent_ptr,
1804	dentry_ptr );
1805	}
1806	else
1807	{
1808	rpc_vfs_fs_remove_dentry_client( parent_cxy,
1809	parent_ptr,
1810	dentry_ptr,
1811	&error );
1812	}
1813
1814	if( error )
1815	{
1816	remote_rwlock_wr_release( lock_xp );
1817	printk("\n[ERROR] in %s : cannot update dentry on device for <%s>\n",
1818	__FUNCTION__ , path );
1819	return -1;
1820	}
1821
1822	#if(DEBUG_VFS_UNLINK & 1)
1823	if( DEBUG_VFS_UNLINK < cycle )
1824	printk("\n[%s] thread[%x,%x] removed <%s> inode from parent dir (mapper and IOC device)\n",
1825	__FUNCTION__, process->pid, this->trdid, path );
1826	#endif
1827	// 3. remove dentry from Inode Tree (and associated chils inode when last link)
1828	vfs_remove_child_from_parent( dentry_xp );
1829
1830	// release the lock protecting Inode Tree
1831	remote_rwlock_wr_release( lock_xp );
1832
1833	#if DEBUG_VFS_UNLINK
1834	if( DEBUG_VFS_UNLINK < cycle )
1835	printk("\n[%s] thread[%x,%x] exit / removed <%s> inode from Inode Tree / cycle %d\n",
1836	__FUNCTION__, process->pid, this->trdid, path, cycle );
1837	#endif
1838	return 0;
1839	}
1840	else
1841	{
1842	remote_rwlock_wr_release( lock_xp );
1843	printk("\n[ERROR] in %s : unsupported inode type %s\n",
1844	__FUNCTION__ , vfs_inode_type_str( inode_type ) );
1845	return -1;
1846	}
1847
1848	} // end vfs_unlink()
1849
1850	////////////////////////////////////////////////
1851	error_t vfs_stat( xptr_t root_inode_xp,
1852	char * path,
1853	struct stat * st )
1854	{
1855	error_t error;
1856	xptr_t inode_xp; // extended pointer on target inode
1857	vfs_inode_t * inode_ptr; // local pointer on target inode
1858	cxy_t inode_cxy; // target inode cluster identifier
1859	xptr_t vfs_root_xp; // extended pointer on VFS root inode
1860	vfs_inode_t * vfs_root_ptr; // local_pointer on VFS root inode
1861	cxy_t vfs_root_cxy; // VFS root inode cluster identifier
1862	xptr_t lock_xp; // extended pointer on lock protecting Inode Tree
1863
1864	thread_t * this = CURRENT_THREAD;
1865	process_t * process = this->process;
1866
1867	// build extended pointer on lock protecting Inode Tree (in VFS root inode)
1868	vfs_root_xp = process->vfs_root_xp;
1869	vfs_root_ptr = GET_PTR( vfs_root_xp );
1870	vfs_root_cxy = GET_CXY( vfs_root_xp );
1871	lock_xp = XPTR( vfs_root_cxy , &vfs_root_ptr->main_lock );
1872
1873	// get the lock protecting Inode Tree in read mode
1874	remote_rwlock_rd_acquire( lock_xp );
1875
1876	// get extended pointer on target inode
1877	error = vfs_lookup( root_inode_xp,
1878	path,
1879	0,
1880	&inode_xp,
1881	NULL );
1882
1883	// release the lock protecting Inode Tree
1884	remote_rwlock_rd_release( lock_xp );
1885
1886	if( error )
1887	{
1888	printk("\n[ERROR] in %s : cannot found inode <%s>\n",
1889	__FUNCTION__ , path );
1890	return -1;
1891	}
1892
1893	// get cluster and local pointer on inode descriptor
1894	inode_ptr = GET_PTR( inode_xp );
1895	inode_cxy = GET_CXY( inode_xp );
1896
1897	// get relevant infos from inode descriptor
1898	uint32_t inum = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->inum ) );
1899	uint32_t size = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->size ) );
1900	uint32_t uid = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->uid ) );
1901	uint32_t gid = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->gid ) );
1902	uint32_t type = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->type ) );
1903	uint32_t rights = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->rights ) );
1904
1905	// set stat structure fields
1906	st->st_ino = inum;
1907	st->st_gid = gid;
1908	st->st_uid = uid;
1909	st->st_size = size;
1910	st->st_mode = (type << 16) \| rights;
1911
1912	#if DEBUG_VFS_STAT
1913	uint32_t cycle = (uint32_t)hal_get_cycles();
1914	if( DEBUG_VFS_STAT < cycle )
1915	printk("\n[%s] thread[%x,%x] set stat %x for inode %x in cluster %x / cycle %d\n"
1916	" %s / inum %d / size %d\n",
1917	__FUNCTION__, process->pid, this->trdid, st, inode_ptr, inode_cxy, cycle,
1918	vfs_inode_type_str( type ), inum, size );
1919	#endif
1920
1921	return 0;
1922
1923	} // end vfs_stat()
1924
1925	////////////////////////////////////
1926	error_t vfs_chdir( xptr_t root_xp,
1927	char * path )
1928	{
1929	error_t error;
1930	xptr_t inode_xp; // extended pointer on target inode
1931	cxy_t inode_cxy; // target inode cluster identifier
1932	vfs_inode_t * inode_ptr; // target inode local pointer
1933	vfs_inode_type_t inode_type; // target inode type
1934	xptr_t vfs_root_xp; // extended pointer on VFS root inode
1935	vfs_inode_t * vfs_root_ptr; // local_pointer on VFS root inode
1936	cxy_t vfs_root_cxy; // VFS root inode cluster identifier
1937	xptr_t main_lock_xp; // extended pointer on lock protecting Inode Tree
1938	xptr_t ref_xp; // extended pointer on reference process
1939	process_t * ref_ptr; // local pointer on reference process
1940	cxy_t ref_cxy; // reference process cluster
1941	xptr_t cwd_lock_xp; // extended pointer on lock protecting CWD change
1942	xptr_t cwd_xp_xp; // extended pointer on cwd_xp in reference process
1943
1944	thread_t * this = CURRENT_THREAD;
1945	process_t * process = this->process;
1946
1947	#if DEBUG_VFS_CHDIR
1948	uint32_t cycle = (uint32_t)hal_get_cycles();
1949	if( DEBUG_VFS_CHDIR < cycle )
1950	printk("\n[%s] thread[%x,%x] enter for path <%s> / cycle %d\n",
1951	__FUNCTION__, process->pid, this->trdid, path, cycle );
1952	#endif
1953
1954	// build extended pointer on lock protecting Inode Tree (in VFS root inode)
1955	vfs_root_xp = process->vfs_root_xp;
1956	vfs_root_ptr = GET_PTR( vfs_root_xp );
1957	vfs_root_cxy = GET_CXY( vfs_root_xp );
1958	main_lock_xp = XPTR( vfs_root_cxy , &vfs_root_ptr->main_lock );
1959
1960	// take lock protecting Inode Tree in read mode
1961	remote_rwlock_rd_acquire( main_lock_xp );
1962
1963	// get extended pointer on target inode
1964	error = vfs_lookup( root_xp,
1965	path,
1966	VFS_LOOKUP_DIR,
1967	&inode_xp,
1968	NULL );
1969
1970	// release lock protecting Inode Tree in read mode
1971	remote_rwlock_rd_release( main_lock_xp );
1972
1973	if( error )
1974	{
1975	printk("\n[ERROR] in %s : <%s> not found\n",
1976	__FUNCTION__, path );
1977	return -1;
1978	}
1979
1980	// get inode type from remote file
1981	inode_cxy = GET_CXY( inode_xp );
1982	inode_ptr = GET_PTR( inode_xp );
1983	inode_type = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->type ) );
1984
1985	if( inode_type != INODE_TYPE_DIR )
1986	{
1987	printk("\n[ERROR] in %s : <%s> is not a directory\n",
1988	__FUNCTION__, path );
1989	return -1;
1990	}
1991
1992	// build extended pointer on cwd_lock and cwd_xp
1993	ref_xp = process->ref_xp;
1994	ref_ptr = GET_PTR( ref_xp );
1995	ref_cxy = GET_CXY( ref_xp );
1996	cwd_lock_xp = XPTR( ref_cxy , &ref_ptr->cwd_lock );
1997	cwd_xp_xp = XPTR( ref_cxy , &ref_ptr->cwd_xp );
1998
1999	// take lock protecting CWD changes
2000	remote_busylock_acquire( cwd_lock_xp );
2001
2002	// update cwd_xp field in reference process descriptor
2003	hal_remote_s64( cwd_xp_xp , inode_xp );
2004
2005	// release lock protecting CWD changes
2006	remote_busylock_release( cwd_lock_xp );
2007
2008	#if DEBUG_VFS_CHDIR
2009	cycle = (uint32_t)hal_get_cycles();
2010	if( DEBUG_VFS_CHDIR < cycle )
2011	printk("\n[%s] thread[%x,%x] exit : inode (%x,%x) / &cwd_xp (%x,%x) / cycle %d\n",
2012	__FUNCTION__, process->pid, this->trdid, inode_cxy, inode_ptr,
2013	GET_CXY(cwd_xp_xp), GET_PTR(cwd_xp_xp), cycle );
2014	#endif
2015
2016	return 0;
2017
2018	} // end vfs_chdir()
2019
2020	///////////////////////////////////
2021	error_t vfs_chmod( xptr_t cwd_xp,
2022	char * path,
2023	uint32_t rights )
2024	{
2025	error_t error;
2026	xptr_t inode_xp; // extended pointer on target inode
2027	cxy_t inode_cxy; // inode cluster identifier
2028	vfs_inode_t * inode_ptr; // inode local pointer
2029	vfs_inode_type_t inode_type; // target inode type
2030
2031	// set lookup working mode
2032	assert( (rights == 0), __FUNCTION__,
2033	"access rights non implemented yet\n" );
2034
2035	// get extended pointer on target inode
2036	error = vfs_lookup( cwd_xp,
2037	path,
2038	0,
2039	&inode_xp,
2040	NULL );
2041
2042	if( error ) return error;
2043
2044	// get inode cluster and local pointer
2045	inode_cxy = GET_CXY( inode_xp );
2046	inode_ptr = GET_PTR( inode_xp );
2047
2048	// get inode type from remote inode
2049	inode_type = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->type ) );
2050
2051	// TODO implement this function
2052
2053	assert( false , "not implemented\n" );
2054
2055	return 0;
2056	}
2057
2058	///////////////////////////////////
2059	error_t vfs_mkfifo( xptr_t cwd_xp,
2060	char * path,
2061	uint32_t rights )
2062	{
2063	assert( false , "not implemented cwd_xp: %x, path <%s>, rights %x\n",
2064	cwd_xp, path, rights );
2065	return 0;
2066	}
2067
2068
2069
2070	//////////////////////////////////////////////////////////////////////////////////////////
2071	// Distributed Inode Tree access related functions
2072	//////////////////////////////////////////////////////////////////////////////////////////
2073
2074	//////////////////////////////////////////////////////////////////////////
2075	// This static function is called by the vfs_display() function.
2076	// that is supposed to take the TXT0 lock.
2077	//////////////////////////////////////////////////////////////////////////
2078	static void vfs_recursive_display( xptr_t inode_xp,
2079	xptr_t name_xp,
2080	uint32_t indent )
2081	{
2082	cxy_t inode_cxy;
2083	vfs_inode_t * inode_ptr;
2084	vfs_inode_type_t inode_type;
2085	uint32_t inode_size;
2086	uint32_t inode_inum;
2087	uint32_t inode_attr;
2088	uint32_t inode_dirty;
2089	xptr_t children_xp; // extended pointer on children xhtab
2090
2091	xptr_t child_dentry_xp;
2092	cxy_t child_dentry_cxy;
2093	vfs_dentry_t * child_dentry_ptr;
2094	xptr_t child_inode_xp;
2095	xptr_t child_dentry_name_xp;
2096	mapper_t * mapper_ptr;
2097
2098	char name[CONFIG_VFS_MAX_NAME_LENGTH];
2099
2100	char * indent_str[] = { "", // level 0
2101	" ", // level 1
2102	" ", // level 2
2103	" ", // level 3
2104	" ", // level 4
2105	" ", // level 5
2106	" ", // level 6
2107	" ", // level 7
2108	" ", // level 8
2109	" ", // level 9
2110	" ", // level 10
2111	" ", // level 11
2112	" ", // level 12
2113	" ", // level 13
2114	" ", // level 14
2115	" " }; // level 15
2116
2117	assert( (inode_xp != XPTR_NULL) , "inode_xp cannot be NULL\n" );
2118	assert( (name_xp != XPTR_NULL) , "name_xp cannot be NULL\n" );
2119	assert( (indent < 16) , "depth cannot be larger than 15\n" );
2120
2121	// get current inode cluster and local pointer
2122	inode_cxy = GET_CXY( inode_xp );
2123	inode_ptr = GET_PTR( inode_xp );
2124
2125	// get inode type, size, attr, mapper, and inum
2126	inode_type = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->type ) );
2127	inode_size = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->size ) );
2128	inode_inum = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->inum ) );
2129	inode_attr = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->attr ) );
2130	mapper_ptr = hal_remote_lpt( XPTR( inode_cxy , &inode_ptr->mapper ) );
2131
2132	// make a local copy of node name
2133	hal_remote_strcpy( XPTR( local_cxy , name ) , name_xp );
2134
2135	// compute dirty
2136	inode_dirty = ((inode_attr & INODE_ATTR_DIRTY) != 0);
2137
2138	// display inode
2139	nolock_printk("%s<%s> : %s / inum %d / %d bytes / dirty %d / cxy %x / inode %x / mapper %x\n",
2140	indent_str[indent], name, vfs_inode_type_str( inode_type ),
2141	inode_inum, inode_size, inode_dirty, inode_cxy, inode_ptr, mapper_ptr );
2142
2143	// scan directory entries when current inode is a directory
2144	// don't scan the the "." and ".." directories to break loops
2145	if( (inode_type == INODE_TYPE_DIR) &&
2146	(strcmp( name , "." ) != 0) &&
2147	(strcmp( name , ".." ) != 0) )
2148	{
2149	// get extended pointer on directory entries xhtab
2150	children_xp = XPTR( inode_cxy , &inode_ptr->children );
2151
2152	// get xhtab lock
2153	xhtab_lock( children_xp );
2154
2155	// get first dentry from xhtab
2156	child_dentry_xp = xhtab_get_first( children_xp );
2157
2158	while( child_dentry_xp != XPTR_NULL )
2159	{
2160	// get dentry cluster and local pointer
2161	child_dentry_cxy = GET_CXY( child_dentry_xp );
2162	child_dentry_ptr = GET_PTR( child_dentry_xp );
2163
2164	// get extended pointer on child inode
2165	child_inode_xp = hal_remote_l64( XPTR( child_dentry_cxy,
2166	&child_dentry_ptr->child_xp ) );
2167
2168	// get extended pointer on dentry name
2169	child_dentry_name_xp = XPTR( child_dentry_cxy , &child_dentry_ptr->name );
2170
2171	// recursive call on inode display
2172	vfs_recursive_display( child_inode_xp,
2173	child_dentry_name_xp,
2174	indent+1 );
2175
2176	// get next dentry
2177	child_dentry_xp = xhtab_get_next( children_xp );
2178	}
2179
2180	// release xhtab lock
2181	xhtab_unlock( children_xp );
2182	}
2183	} // end vfs_recursive_display()
2184
2185	///////////////////////////////////
2186	void vfs_display( xptr_t inode_xp )
2187	{
2188	xptr_t name_xp;
2189	xptr_t dentry_xp;
2190	cxy_t dentry_cxy;
2191	vfs_dentry_t * dentry_ptr;
2192	xptr_t parents_root_xp; // root of parent dentries xlist
2193
2194	// get target inode cluster and local pointer
2195	cxy_t inode_cxy = GET_CXY( inode_xp );
2196	vfs_inode_t * inode_ptr = GET_PTR( inode_xp );
2197
2198	// build extended pointer on parents dentries root
2199	parents_root_xp = XPTR( inode_cxy , &inode_ptr->parents );
2200
2201	// check VFS root
2202	if( xlist_is_empty( parents_root_xp ) ) // inode is the VFS root
2203	{
2204	// build extended pointer on root name
2205	name_xp = XPTR( local_cxy , "/" );
2206	}
2207	else
2208	{
2209	// get first parent dentry cluster and pointers
2210	dentry_xp = XLIST_FIRST( parents_root_xp , vfs_dentry_t , parents );
2211	dentry_cxy = GET_CXY( dentry_xp );
2212	dentry_ptr = GET_PTR( dentry_xp );
2213
2214	// get extended pointer on dentry name
2215	name_xp = XPTR( dentry_cxy , &dentry_ptr->name );
2216	}
2217
2218	// get pointers on TXT0 chdev
2219	xptr_t txt0_xp = chdev_dir.txt_tx[0];
2220	cxy_t txt0_cxy = GET_CXY( txt0_xp );
2221	chdev_t * txt0_ptr = GET_PTR( txt0_xp );
2222
2223	// get extended pointer on remote TXT0 chdev lock
2224	xptr_t lock_xp = XPTR( txt0_cxy , &txt0_ptr->wait_lock );
2225
2226	// get TXT0 lock in busy waiting mode
2227	remote_busylock_acquire( lock_xp );
2228
2229	// print header
2230	nolock_printk("\n***** file system state\n\n");
2231
2232	// call recursive function
2233	vfs_recursive_display( inode_xp , name_xp , 0 );
2234
2235	// release lock
2236	remote_busylock_release( lock_xp );
2237
2238	} // end vfs_display()
2239
2240	/*
2241	//////////////////////////////////////////////////////////////////////////////////////////
2242	// This static function is used by the vfs_lookup() function.
2243	// It takes an extended pointer on a remote inode (parent directory inode),
2244	// and check access_rights violation for the calling thread.
2245	// It can be used by any thread running in any cluster.
2246	//////////////////////////////////////////////////////////////////////////////////////////
2247	// @ inode_xp : extended pointer on inode.
2248	// @ client_uid : client thread user ID
2249	// @ client_gid : client thread group ID
2250	// @ return true if access rights are violated.
2251	//////////////////////////////////////////////////////////////////////////////////////////
2252	static bool_t vfs_access_denied( xptr_t inode_xp,
2253	uint32_t client_uid,
2254	uint32_t client_gid )
2255	{
2256	// get found inode cluster and local pointer
2257	cxy_t inode_cxy = GET_CXY( inode_xp );
2258	vfs_inode_t * inode_ptr = GET_PTR( inode_xp );
2259
2260	// get inode access mode, UID, and GID
2261	// TODO uint32_t mode = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->mode ) );
2262	uid_t uid = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->uid ) );
2263	gid_t gid = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->gid ) );
2264
2265	// FIXME : me must use mode
2266	if( (uid == client_uid) \|\| (gid == client_gid) ) return false;
2267	else return true;
2268	}
2269	*/
2270
2271	//////////////////////////////////////////////////////////////////////////////////////////
2272	// This static function is used by the vfs_lookup() function.
2273	// It takes an extended pointer on a remote parent directory inode, a directory
2274	// entry name, and returns an extended pointer on the child inode.
2275	// It can be used by any thread running in any cluster.
2276	//////////////////////////////////////////////////////////////////////////////////////////
2277	// @ parent_xp : extended pointer on parent inode in remote cluster.
2278	// @ name : dentry name
2279	// @ child_xp : [out] buffer for extended pointer on child inode.
2280	// @ return true if success / return false if not found.
2281	//////////////////////////////////////////////////////////////////////////////////////////
2282	static bool_t vfs_get_child( xptr_t parent_xp,
2283	char * name,
2284	xptr_t * child_xp )
2285	{
2286	xptr_t xhtab_xp; // extended pointer on hash table for children dentries
2287	xptr_t dentry_xp; // extended pointer on children dentry
2288	cxy_t dentry_cxy;
2289	vfs_dentry_t * dentry_ptr;
2290
2291	// get parent inode cluster and local pointer
2292	cxy_t parent_cxy = GET_CXY( parent_xp );
2293	vfs_inode_t * parent_ptr = GET_PTR( parent_xp );
2294
2295	// get extended pointer on hash table of children directory entries
2296	xhtab_xp = XPTR( parent_cxy , &parent_ptr->children );
2297
2298	// get pointers on matching dentry
2299	dentry_xp = xhtab_lookup( xhtab_xp , name );
2300	dentry_cxy = GET_CXY( dentry_xp );
2301	dentry_ptr = GET_PTR( dentry_xp );
2302
2303	if( dentry_xp == XPTR_NULL )
2304	{
2305	return false;
2306	}
2307	else
2308	{
2309	*child_xp = (xptr_t)hal_remote_l64( XPTR( dentry_cxy , &dentry_ptr->child_xp ) );
2310	return true;
2311	}
2312
2313	} // end vfs_get_child()
2314
2315	//////////////////////////////////////////////////////////////////////////////////////////
2316	// This static function is used by the vfs_lookup() function.
2317	// It takes the <current> pointer on a buffer containing a complete pathname, and return
2318	// in the <name> buffer, allocated by the caller, a single name in the path.
2319	// It return also in the <next> pointer the next character to analyse in the path.
2320	// Finally it returns a <last> boolean, that is true when the returned <name> is the
2321	// last name in the path. The names are supposed to be separated by one or several '/'
2322	// characters, that are not written in the <name> buffer.
2323	//
2324	// WARNING: the leading characters '/' in the path are skiped before analysis.
2325	// The path "/" identifies the VFS root, and is therefore anaysed as an empty
2326	// string. This empty string is dignaled by the (-1) return value.
2327	//////////////////////////////////////////////////////////////////////////////////////////
2328	// @ current : pointer on first character to analyse in buffer containing the path.
2329	// @ name : [out] pointer on buffer allocated by the caller for the returned name.
2330	// @ next : [out] pointer on next character to analyse in buffer containing the path.
2331	// @ last : [out] true if the returned name is the last (NUL character found).
2332	// @ return 0 if success / return -1 if string empty (first chracter is NUL).
2333	//////////////////////////////////////////////////////////////////////////////////////////
2334	static error_t vfs_get_name_from_path( char * current,
2335	char * name,
2336	char ** next,
2337	bool_t * last )
2338	{
2339	char * ptr = current;
2340
2341	// skip leading '/' characters
2342	while( *ptr == '/' ) ptr++;
2343
2344	// signal empty string
2345	if( *ptr == 0 )
2346	{
2347	*last = true;
2348	return -1;
2349	}
2350
2351	// copy all characters in name until NUL or '/'
2352	while( (ptr != 0) && (ptr !='/') ) (name++) = (ptr++);
2353
2354	// set NUL terminating character in name buffer
2355	*(name++) = 0;
2356
2357	// return last an next
2358	if( *ptr == 0 ) // last found character is NUL => last name in path
2359	{
2360	*last = true;
2361	}
2362	else // last found character is '/' => skip it
2363	{
2364	*last = false;
2365	*next = ptr + 1;
2366	}
2367
2368	return 0;
2369
2370	} // end vfs_get name_from_path()
2371
2372	///////////////////////////////////////////////
2373	error_t vfs_lookup( xptr_t root_xp,
2374	char * pathname,
2375	uint32_t lookup_mode,
2376	xptr_t * inode_xp,
2377	char * last_name )
2378	{
2379	char name[CONFIG_VFS_MAX_NAME_LENGTH]; // one name in path
2380
2381	xptr_t parent_xp; // extended pointer on parent inode
2382	cxy_t parent_cxy; // cluster for parent inode
2383	vfs_inode_t * parent_ptr; // local pointer on parent inode
2384	xptr_t dentry_xp; // extended pointer on dentry
2385	xptr_t child_xp; // extended pointer on child inode
2386	cxy_t child_cxy; // cluster for child inode
2387	vfs_inode_t * child_ptr; // local pointer on child inode
2388	vfs_fs_type_t fs_type; // File system type
2389	vfs_ctx_t * ctx_ptr; // local pointer on FS context
2390	char * current; // current pointer on path
2391	char * next; // next value for current pointer
2392	bool_t last; // true when the name is the last in path
2393	bool_t found; // true when a child has been found
2394	bool_t dir; // searched inode is a directory
2395	bool_t create; // searched inode must be created if not found
2396	bool_t excl; // searched inode must not exist
2397	bool_t par; // searched inode is the parent
2398	thread_t * this; // pointer on calling thread descriptor
2399	process_t * process; // pointer on calling process descriptor
2400	error_t error;
2401
2402	this = CURRENT_THREAD;
2403	process = this->process;
2404
2405	// check pathname / root_xp consistency
2406	assert( ((pathname[0] != '/') \|\| (root_xp == process->vfs_root_xp)),
2407	"root inode must be VFS root for path <%s>\n", pathname );
2408
2409	#if DEBUG_VFS_LOOKUP
2410	uint32_t cycle = (uint32_t)hal_get_cycles();
2411	char root_name[CONFIG_VFS_MAX_NAME_LENGTH];
2412	vfs_inode_get_name( root_xp , root_name );
2413	if( DEBUG_VFS_LOOKUP < cycle )
2414	printk("\n[%s] thread[%x,%x] enter / root <%s> / path <%s> / mode %x / cycle %d\n",
2415	__FUNCTION__, process->pid, this->trdid, root_name, pathname, lookup_mode, cycle );
2416	#endif
2417
2418	// compute lookup flags
2419	dir = (lookup_mode & VFS_LOOKUP_DIR) == VFS_LOOKUP_DIR;
2420	create = (lookup_mode & VFS_LOOKUP_CREATE) == VFS_LOOKUP_CREATE;
2421	excl = (lookup_mode & VFS_LOOKUP_EXCL) == VFS_LOOKUP_EXCL;
2422	par = (lookup_mode & VFS_LOOKUP_PARENT) == VFS_LOOKUP_PARENT;
2423
2424	// initialise loop variables
2425	parent_xp = root_xp;
2426	current = pathname;
2427	next = NULL;
2428	last = false;
2429	child_xp = XPTR_NULL;
2430
2431	// loop on nodes in pathname
2432	// load from device if one node in path not found in Inode Tree
2433	// exit loop when last name found (i.e. last == true)
2434	while( 1 )
2435	{
2436	// get parent inode cluster and local pointer
2437	parent_cxy = GET_CXY( parent_xp );
2438	parent_ptr = GET_PTR( parent_xp );
2439
2440	// get one "name" from path, and "last" flag
2441	error = vfs_get_name_from_path( current , name , &next , &last );
2442
2443	// handle VFS root case
2444	if ( error )
2445	{
2446
2447	#if DEBUG_VFS_LOOKUP
2448	cycle = (uint32_t)hal_get_cycles();
2449	if( DEBUG_VFS_LOOKUP < cycle )
2450	printk("\n[%s] thread[%x,%x] exit / parent inode(%x,%x) / <%s> / cycle %d\n",
2451	__FUNCTION__ , process->pid, this->trdid, parent_cxy, parent_ptr, pathname, cycle );
2452	#endif
2453	*inode_xp = process->vfs_root_xp;
2454	break;
2455	}
2456
2457	#if (DEBUG_VFS_LOOKUP & 1)
2458	if( DEBUG_VFS_LOOKUP < cycle )
2459	printk("\n[%s] thread[%x,%x] look for <%s> in <%s> / last = %d\n",
2460	__FUNCTION__, process->pid, this->trdid, name, pathname, last );
2461	#endif
2462
2463	// search the child dentry matching name in parent inode
2464	found = vfs_get_child( parent_xp,
2465	name,
2466	&child_xp );
2467
2468	// get child inode local pointer and cluster
2469	child_ptr = GET_PTR( child_xp );
2470	child_cxy = GET_CXY( child_xp );
2471
2472	// analyse found & last, depending on lookup_mode
2473	if( found == false ) // not found in Inode Tree
2474	{
2475	// when a inode is not found in the Inode Tree:
2476	// - if (last and par) the Inode Tree is not modified
2477	// - else we speculatively introduce a new (dentry/inode) in inode tree,
2478	// and scan the parent directory mapper to initialise it.
2479	// . if it is not found in the parent mapper:
2480	// - if(last and create), a brand new file or directory is created
2481	// - else, an error is reported
2482	// . if it is found in parent mapper:
2483	// - if( last and excl ), an error is reported
2484	// - else the new child (inode & dentry) is initialised in Inode Tree
2485	// - if the child is a directory, the child mapper is loaded from device
2486
2487	if( last && par ) // does nothing
2488	{
2489
2490	#if (DEBUG_VFS_LOOKUP & 1)
2491	if( DEBUG_VFS_LOOKUP < cycle )
2492	printk("\n[%s] thread[%x,%x] child not found but only parent requested in <%s>\n",
2493	__FUNCTION__, process->pid, this->trdid, pathname );
2494	#endif
2495	}
2496	else // try to get it from parent mapper
2497	{
2498
2499	#if (DEBUG_VFS_LOOKUP & 1)
2500	if( DEBUG_VFS_LOOKUP < cycle )
2501	printk("\n[%s] thread[%x,%x] miss <%s> inode in Inode Tree => build from parent mapper\n",
2502	__FUNCTION__, process->pid, this->trdid, name );
2503	#endif
2504	// get parent inode FS type
2505	ctx_ptr = hal_remote_lpt( XPTR( parent_cxy,&parent_ptr->ctx ) );
2506	fs_type = hal_remote_l32( XPTR( parent_cxy , &ctx_ptr->type ) );
2507
2508	// select a cluster for new inode
2509	child_cxy = cluster_random_select();
2510
2511	// insert a new child dentry/inode couple in inode tree
2512	error = vfs_add_child_in_parent( child_cxy,
2513	fs_type,
2514	parent_xp,
2515	name,
2516	&dentry_xp,
2517	&child_xp );
2518	if( error )
2519	{
2520	printk("\n[ERROR] in %s : cannot create inode <%s> in path <%s>\n",
2521	__FUNCTION__ , name, pathname );
2522	return -1;
2523	}
2524
2525	// get child inode local pointer
2526	child_ptr = GET_PTR( child_xp );
2527
2528	#if (DEBUG_VFS_LOOKUP & 1)
2529	if( DEBUG_VFS_LOOKUP < cycle )
2530	printk("\n[%s] thread[%x,%x] created missing inode <%s> in cluster %x\n",
2531	__FUNCTION__, process->pid, this->trdid, name, child_cxy );
2532	#endif
2533	// scan parent mapper to find the missing dentry, and complete
2534	// the initialisation of dentry and child inode descriptors
2535	if( parent_cxy == local_cxy )
2536	{
2537	error = vfs_fs_new_dentry( parent_ptr,
2538	name,
2539	child_xp );
2540	}
2541	else
2542	{
2543	rpc_vfs_fs_new_dentry_client( parent_cxy,
2544	parent_ptr,
2545	name,
2546	child_xp,
2547	&error );
2548	}
2549
2550	if ( error ) // child not found in parent mapper
2551	{
2552	if ( last && create ) // add a brand new dentry in parent
2553	{
2554	error = vfs_new_dentry_init( parent_xp,
2555	dentry_xp,
2556	child_xp );
2557	if ( error )
2558	{
2559	printk("\n[ERROR] in %s : cannot init inode <%s> in path <%s>\n",
2560	__FUNCTION__, name, pathname );
2561	vfs_remove_child_from_parent( dentry_xp );
2562	return -1;
2563	}
2564
2565	#if (DEBUG_VFS_LOOKUP & 1)
2566	if( DEBUG_VFS_LOOKUP < cycle )
2567	printk("\n[%s] thread[%x,%x] child <%s> not found in parent mapper => create it\n",
2568	__FUNCTION__, process->pid, this->trdid, name );
2569	#endif
2570	}
2571	else // not last or not create => error
2572	{
2573	printk("\n[ERROR] in %s : <%s> node not found in parent for <%s>\n",
2574	__FUNCTION__ , name , pathname );
2575	vfs_remove_child_from_parent( dentry_xp );
2576	return -1;
2577	}
2578	}
2579	else // child has been found in parent mapper
2580	{
2581	// check the excl
2582	if( last && create && excl )
2583	{
2584	printk("\n[ERROR] in %s : node already exist <%s>\n",
2585	__FUNCTION__, name );
2586	return -1;
2587	}
2588
2589	#if (DEBUG_VFS_LOOKUP & 1)
2590	if( DEBUG_VFS_LOOKUP < cycle )
2591	printk("\n[%s] thread[%x,%x] initialised inode <%s> from parent mapper\n",
2592	__FUNCTION__, process->pid, this->trdid, name );
2593	#endif
2594	// load child mapper from device if child is a directory (prefetch)
2595	uint32_t type = hal_remote_l32( XPTR( child_cxy , &child_ptr->type ) );
2596	if( type == INODE_TYPE_DIR )
2597	{
2598	if( child_cxy == local_cxy )
2599	{
2600	error = vfs_inode_load_all_pages( child_ptr );
2601	}
2602	else
2603	{
2604	rpc_vfs_inode_load_all_pages_client( child_cxy,
2605	child_ptr,
2606	&error );
2607	}
2608	if ( error )
2609	{
2610	printk("\n[ERROR] in %s : cannot load <%s> from device\n",
2611	__FUNCTION__ , name );
2612	vfs_remove_child_from_parent( dentry_xp );
2613	return -1;
2614	}
2615
2616	#if (DEBUG_VFS_LOOKUP & 1)
2617	if( DEBUG_VFS_LOOKUP < cycle )
2618	printk("\n[%s] thread[%x,%x] loaded directory mapper for <%s> from IOC\n",
2619	__FUNCTION__ , process->pid, this->trdid, name );
2620	#endif
2621	}
2622	}
2623	}
2624	}
2625	else // child directly found in inode tree
2626	{
2627
2628	#if (DEBUG_VFS_LOOKUP & 1)
2629	if( DEBUG_VFS_LOOKUP < cycle )
2630	printk("\n[%s] thread[%x,%x] found <%s> in Inode Tree / inode (%x,%x)\n",
2631	__FUNCTION__, process->pid, this->trdid, name, child_cxy, child_ptr );
2632	#endif
2633	// check the excl flag
2634	if( last && create && excl )
2635	{
2636	printk("\n[ERROR] in %s : node <%s> already exist\n",
2637	__FUNCTION__, name );
2638	return -1;
2639	}
2640	}
2641
2642	// TODO check access rights here [AG]
2643	// error = vfs_access_denied( child_xp,
2644	// client_uid,
2645	// client_gid );
2646	// if( error )
2647	// {
2648	// printk("\n[ERROR] in %s : thread %x / permission denied for %s\n",
2649	// __FUNCTION__ , this , name );
2650	// return EACCES;
2651	// }
2652
2653	// take lock on child inode and release lock on parent
2654	// vfs_inode_lock( child_xp );
2655	// vfs_inode_unlock( parent_xp );
2656
2657	// exit when last
2658	if ( last ) // last inode in path => return relevant info
2659	{
2660	if ( par ) // return parent inode and child name
2661	{
2662
2663	#if DEBUG_VFS_LOOKUP
2664	cycle = (uint32_t)hal_get_cycles();
2665	if( DEBUG_VFS_LOOKUP < cycle )
2666	printk("\n[%s] thread[%x,%x] exit / parent inode(%x,%x) / <%s> / cycle %d\n",
2667	__FUNCTION__ , process->pid, this->trdid, parent_cxy, parent_ptr, pathname, cycle );
2668	#endif
2669	*inode_xp = parent_xp;
2670	strcpy( last_name , name );
2671	break;
2672	}
2673	else // return child inode name
2674	{
2675
2676	#if DEBUG_VFS_LOOKUP
2677	cycle = (uint32_t)hal_get_cycles();
2678	if( DEBUG_VFS_LOOKUP < cycle )
2679	printk("\n[%s] thread[%x,%x] exit / child inode (%x,%x) / <%s> / cycle %d\n",
2680	__FUNCTION__ , process->pid, this->trdid, child_cxy, child_ptr, pathname, cycle );
2681	#endif
2682	*inode_xp = child_xp;
2683	break;
2684	}
2685	}
2686	else // not the last inode in path => update loop variables
2687	{
2688	parent_xp = child_xp;
2689	current = next;
2690	}
2691	}
2692
2693	return 0;
2694
2695	} // end vfs_lookup()
2696
2697	////////////////////////////////////////////////
2698	error_t vfs_new_dentry_init( xptr_t parent_xp,
2699	xptr_t dentry_xp,
2700	xptr_t child_xp )
2701	{
2702	error_t error;
2703	uint32_t cluster;
2704	uint32_t child_type;
2705	uint32_t child_size;
2706
2707	#if DEBUG_VFS_NEW_CHILD_INIT
2708	char parent_name[CONFIG_VFS_MAX_NAME_LENGTH];
2709	char child_name[CONFIG_VFS_MAX_NAME_LENGTH];
2710	vfs_inode_get_name( parent_xp , parent_name );
2711	vfs_inode_get_name( child_xp , child_name );
2712	uint32_t cycle = (uint32_t)hal_get_cycles();
2713	thread_t * this = CURRENT_THREAD;
2714	if( DEBUG_VFS_NEW_CHILD_INIT < cycle )
2715	printk("\n[%s] thread[%x,%x] enter / parent <%s> / child <%s> / cycle %d\n",
2716	__FUNCTION__ , this->process->pid, this->trdid, parent_name, child_name, cycle );
2717	#endif
2718
2719	// get parent inode cluster and local pointer
2720	cxy_t parent_cxy = GET_CXY( parent_xp );
2721	vfs_inode_t * parent_ptr = GET_PTR( parent_xp );
2722
2723	// get dentry local pointer
2724	vfs_dentry_t * dentry_ptr = GET_PTR( dentry_xp );
2725
2726	// get child inode cluster and local pointer
2727	cxy_t child_cxy = GET_CXY( child_xp );
2728	vfs_inode_t * child_ptr = GET_PTR( child_xp );
2729
2730	// 1. allocate one free cluster to child inode
2731	// depending on the child inode FS type
2732	vfs_ctx_t * ctx = hal_remote_lpt( XPTR( child_cxy , &child_ptr->ctx ) );
2733
2734	error = vfs_fs_cluster_alloc( ctx->type,
2735	&cluster );
2736	if ( error )
2737	{
2738	printk("\n[ERROR] in %s : cannot find a free VFS cluster\n",
2739	__FUNCTION__ );
2740	return -1;
2741	}
2742
2743	#if( DEBUG_VFS_NEW_CHILD_INIT & 1)
2744	if( DEBUG_VFS_NEW_CHILD_INIT < cycle )
2745	printk("\n[%s] thread[%x,%x] allocated one FAT cluster to <%s>\n",
2746	__FUNCTION__ , this->process->pid, this->trdid, child_name );
2747	#endif
2748
2749	// 2. update the child inode descriptor
2750	child_type = hal_remote_l32( XPTR( child_cxy , &child_ptr->type ) );
2751	child_size = (child_type == INODE_TYPE_DIR) ? 4096 : 0;
2752
2753	hal_remote_s32( XPTR( child_cxy , &child_ptr->size ) , child_size );
2754	hal_remote_spt( XPTR( child_cxy , &child_ptr->extend ) , (void*)(intptr_t)cluster );
2755
2756	// 3. update the parent inode mapper, and
2757	// update the dentry extension if required
2758	if( local_cxy == parent_cxy )
2759	{
2760	error = vfs_fs_add_dentry( parent_ptr,
2761	dentry_ptr );
2762	}
2763	else
2764	{
2765	rpc_vfs_fs_add_dentry_client( parent_cxy,
2766	parent_ptr,
2767	dentry_ptr,
2768	&error );
2769	}
2770	if ( error )
2771	{
2772	printk("\n[ERROR] in %s : cannot register child in parent directory\n",
2773	__FUNCTION__ );
2774	return -1;
2775	}
2776
2777	#if DEBUG_VFS_NEW_CHILD_INIT
2778	cycle = (uint32_t)hal_get_cycles();
2779	if( DEBUG_VFS_NEW_CHILD_INIT < cycle )
2780	printk("\n[%s] thread[%x,%x] exit / parent <%s> / child <%s> / cycle %d\n",
2781	__FUNCTION__ , this->process->pid, this->trdid, parent_name, child_name, cycle );
2782	#endif
2783
2784	return 0;
2785
2786	} // end vfs_new_dentry_init()
2787
2788	///////////////////////////////////////////////////
2789	error_t vfs_add_special_dentries( xptr_t child_xp,
2790	xptr_t parent_xp )
2791	{
2792	error_t error;
2793	vfs_inode_t * child_ptr; // local pointer on child inode directory
2794	cxy_t child_cxy; // child inode directory cluster identifier
2795	vfs_inode_t * parent_ptr; // local pointer on parent inode directory
2796	cxy_t parent_cxy; // parent inode directory cluster identifier
2797	vfs_ctx_t * ctx_ptr; // local pointer on child inode FS context
2798	vfs_fs_type_t fs_type; // FS type of child inode
2799	xptr_t dentry_xp; // extended pointer on dentry (used for . and ..)
2800	vfs_dentry_t * dentry_ptr; // local pointer on dentry (used for . and ..)
2801
2802	// xptr_t parents_root_xp; // extended pointer on inode "parents" field
2803	// xptr_t parents_entry_xp; // extended pointer on dentry "parents" field
2804	xptr_t children_xhtab_xp; // extended pointer on inode "children" field
2805	xptr_t children_entry_xp; // extended pointer on dentry "children" field
2806
2807	#if DEBUG_VFS_ADD_SPECIAL
2808	uint32_t cycle = (uint32_t)hal_get_cycles();
2809	thread_t * this = CURRENT_THREAD;
2810	char child_name[CONFIG_VFS_MAX_NAME_LENGTH];
2811	char parent_name[CONFIG_VFS_MAX_NAME_LENGTH];
2812	vfs_inode_get_name( child_xp , child_name );
2813	vfs_inode_get_name( parent_xp , parent_name );
2814	if( DEBUG_VFS_ADD_SPECIAL < cycle )
2815	printk("\n[%s] thread[%x,%x] enter for child <%s> in parent <%s> / cycle %d\n",
2816	__FUNCTION__, this->process->pid, this->trdid, child_name, parent_name, cycle );
2817	#endif
2818
2819	// get new directory cluster and local pointer
2820	child_cxy = GET_CXY( child_xp );
2821	child_ptr = GET_PTR( child_xp );
2822
2823	// get parent directory cluster and local pointer
2824	parent_cxy = GET_CXY( parent_xp );
2825	parent_ptr = GET_PTR( parent_xp );
2826
2827	// get child inode FS type
2828	ctx_ptr = hal_remote_lpt( XPTR( child_cxy , &child_ptr->ctx ) );
2829	fs_type = hal_remote_l32( XPTR( child_cxy , &ctx_ptr->type ) );
2830
2831	//////////////////////////// create <.>
2832	if( child_cxy == local_cxy )
2833	{
2834	error = vfs_dentry_create( fs_type,
2835	".",
2836	&dentry_xp );
2837	}
2838	else
2839	{
2840	rpc_vfs_dentry_create_client( child_cxy,
2841	fs_type,
2842	".",
2843	&dentry_xp,
2844	&error );
2845	}
2846	if( error )
2847	{
2848	printk("\n[ERROR] in %s : cannot create dentry <.> in cluster %x\n",
2849	__FUNCTION__ , child_cxy );
2850	return -1;
2851	}
2852
2853	// get <.> dentry local pointer
2854	dentry_ptr = GET_PTR( dentry_xp );
2855
2856	#if(DEBUG_VFS_ADD_SPECIAL & 1)
2857	if( DEBUG_VFS_ADD_SPECIAL < cycle )
2858	printk("\n[%s] thread[%x,%x] created dentry <.> (%x,%x)\n",
2859	__FUNCTION__, this->process->pid, this->trdid, child_cxy, dentry_ptr );
2860	#endif
2861
2862	// register <.> dentry in child inode xhtab of children
2863	children_xhtab_xp = XPTR( child_cxy , &child_ptr->children );
2864	children_entry_xp = XPTR( child_cxy , &dentry_ptr->children );
2865	error = xhtab_insert( children_xhtab_xp , "." , children_entry_xp );
2866	if( error )
2867	{
2868	printk("\n[ERROR] in %s : cannot register dentry <.> in xhtab\n",
2869	__FUNCTION__ );
2870	return -1;
2871	}
2872
2873
2874	// don't register <.> dentry in child_inode xlist of parents
2875	// parents_root_xp = XPTR( child_cxy , &child_ptr->parents );
2876	// parents_entry_xp = XPTR( child_cxy , &dentry_ptr->parents );
2877	// xlist_add_first( parents_root_xp , parents_entry_xp );
2878	// hal_remote_atomic_add( XPTR( child_cxy , &child_ptr->links ) , 1 );
2879
2880	// update "parent" and "child_xp" fields in <.> dentry
2881	hal_remote_s64( XPTR( child_cxy , &dentry_ptr->child_xp ) , child_xp );
2882	hal_remote_spt( XPTR( child_cxy , &dentry_ptr->parent ) , child_ptr );
2883
2884	#if(DEBUG_VFS_ADD_SPECIAL & 1)
2885	if( DEBUG_VFS_ADD_SPECIAL < cycle )
2886	printk("\n[%s] thread[%x,%x] linked dentry <.> to parent and child inodes\n",
2887	__FUNCTION__, this->process->pid, this->trdid );
2888	#endif
2889
2890	// introduce <.> dentry into child directory mapper
2891	if( child_cxy == local_cxy )
2892	{
2893	error = vfs_fs_add_dentry( child_ptr,
2894	dentry_ptr );
2895	}
2896	else
2897	{
2898	rpc_vfs_fs_add_dentry_client( child_cxy,
2899	child_ptr,
2900	dentry_ptr,
2901	&error );
2902	}
2903	if( error )
2904	{
2905	printk("\n[ERROR] in %s : cannot introduce dentry <..> in mapper %x\n",
2906	__FUNCTION__ );
2907	return -1;
2908	}
2909
2910	#if(DEBUG_VFS_ADD_SPECIAL & 1)
2911	if( DEBUG_VFS_ADD_SPECIAL < cycle )
2912	printk("\n[%s] thread[%x,%x] registered dentry <.> in child mapper\n",
2913	__FUNCTION__, this->process->pid, this->trdid );
2914	#endif
2915
2916	///////////////////////////// create <..> dentry
2917	if( child_cxy == local_cxy )
2918	{
2919	error = vfs_dentry_create( fs_type,
2920	"..",
2921	&dentry_xp );
2922	}
2923	else
2924	{
2925	rpc_vfs_dentry_create_client( child_cxy,
2926	fs_type,
2927	"..",
2928	&dentry_xp,
2929	&error );
2930	}
2931	if( error )
2932	{
2933	printk("\n[ERROR] in %s : cannot create dentry <..> in cluster %x\n",
2934	__FUNCTION__ , child_cxy );
2935	return -1;
2936	}
2937
2938	// get <..> dentry local pointer
2939	dentry_ptr = GET_PTR( dentry_xp );
2940
2941	#if(DEBUG_VFS_ADD_SPECIAL & 1)
2942	if( DEBUG_VFS_ADD_SPECIAL < cycle )
2943	printk("\n[%s] thread[%x,%x] created dentry <..> (%x,%x)\n",
2944	__FUNCTION__, this->process->pid, this->trdid, child_cxy, dentry_ptr );
2945	#endif
2946
2947	// register <..> dentry in child_inode xhtab of children
2948	children_xhtab_xp = XPTR( child_cxy , &child_ptr->children );
2949	children_entry_xp = XPTR( child_cxy , &dentry_ptr->children );
2950	error = xhtab_insert( children_xhtab_xp , ".." , children_entry_xp );
2951	if( error )
2952	{
2953	printk("\n[ERROR] in %s : cannot register dentry <..> in xhtab\n",
2954	__FUNCTION__ );
2955	return -1;
2956	}
2957
2958	// don't register <..> dentry in parent_inode xlist of parents
2959	// parents_root_xp = XPTR( parent_cxy , &parent_ptr->parents );
2960	// parents_entry_xp = XPTR( child_cxy , &dentry_ptr->parents );
2961	// xlist_add_first( parents_root_xp , parents_entry_xp );
2962	// hal_remote_atomic_add( XPTR( parent_cxy , &parent_ptr->links ) , 1 );
2963
2964	// update "parent" and "child_xp" fields in <..> dentry
2965	hal_remote_s64( XPTR( child_cxy , &dentry_ptr->child_xp ) , parent_xp );
2966	hal_remote_spt( XPTR( child_cxy , &dentry_ptr->parent ) , child_ptr );
2967
2968	#if(DEBUG_VFS_ADD_SPECIAL & 1)
2969	if( DEBUG_VFS_ADD_SPECIAL < cycle )
2970	printk("\n[%s] thread[%x,%x] linked dentry <..> to parent and child inodes\n",
2971	__FUNCTION__, this->process->pid, this->trdid );
2972	#endif
2973
2974	// introduce <..> dentry into child directory mapper
2975	if( child_cxy == local_cxy )
2976	{
2977	error = vfs_fs_add_dentry( child_ptr,
2978	dentry_ptr );
2979	}
2980	else
2981	{
2982	rpc_vfs_fs_add_dentry_client( child_cxy,
2983	child_ptr,
2984	dentry_ptr,
2985	&error );
2986	}
2987	if( error )
2988	{
2989	printk("\n[ERROR] in %s : cannot introduce dentry <..> in mapper %x\n",
2990	__FUNCTION__ );
2991	return -1;
2992	}
2993
2994	#if(DEBUG_VFS_ADD_SPECIAL & 1)
2995	if( DEBUG_VFS_ADD_SPECIAL < cycle )
2996	printk("\n[%s] thread[%x,%x] registered dentry <..> in child mapper\n",
2997	__FUNCTION__, this->process->pid, this->trdid );
2998	#endif
2999
3000	#if DEBUG_VFS_ADD_SPECIAL
3001	cycle = (uint32_t)hal_get_cycles();
3002	if( DEBUG_VFS_ADD_SPECIAL < cycle )
3003	printk("\n[%s] thread[%x,%x] exit for child <%s> in parent <%s> / cycle %d\n",
3004	__FUNCTION__, this->process->pid, this->trdid, child_name, parent_name, cycle );
3005	#endif
3006
3007	return 0;
3008
3009	} // end vfs_add_special_dentries()
3010
3011	//////////////////////////////////////////
3012	error_t vfs_get_path( xptr_t inode_xp,
3013	char * buffer,
3014	char ** first,
3015	uint32_t max_size )
3016	{
3017	xptr_t dentry_xp; // extended pointer on current dentry
3018	vfs_dentry_t * dentry_ptr; // local pointer on current dentry
3019	cxy_t dentry_cxy; // current dentry cluster identifier
3020	xptr_t name_xp; // extended pointer on current dentry name
3021	uint32_t length; // length of current dentry name
3022	int32_t index; // slot index in buffer
3023	xptr_t current_xp; // extended pointer on current inode
3024	vfs_inode_t * current_ptr; // local pointer on current inode
3025	cxy_t current_cxy; // current inode cluster identifier
3026	xptr_t vfs_root_xp; // extended pointer on VFS root inode
3027	vfs_inode_t * vfs_root_ptr; // local pointer on VFS root inode
3028	cxy_t vfs_root_cxy; // VFS root inode cluster identifier
3029	xptr_t lock_xp; // extended pointer on Inode Tree lock
3030	xptr_t parents_root_xp; // extended pointer on current inode parents root
3031	bool_t found; // condition to exit the while loop
3032
3033	thread_t * this = CURRENT_THREAD;
3034	process_t * process = this->process;
3035
3036	#if DEBUG_VFS_GET_PATH
3037	uint32_t cycle = (uint32_t)hal_get_cycles();
3038	if( DEBUG_VFS_GET_PATH < cycle )
3039	printk("\n[%s] thread[%x,%x] enter : inode (%x,%x) / cycle %d\n",
3040	__FUNCTION__ , process->pid, this->trdid,
3041	GET_CXY( inode_xp ), GET_PTR( inode_xp ), cycle );
3042	#endif
3043
3044	// set the NUL character in buffer / initialise buffer index
3045	buffer[max_size - 1] = 0;
3046	index = (int32_t)(max_size - 1);
3047
3048	// initialize current inode
3049	current_xp = inode_xp;
3050
3051	// build extended pointer on lock protecting Inode Tree
3052	vfs_root_xp = process->vfs_root_xp;
3053	vfs_root_ptr = GET_PTR( vfs_root_xp );
3054	vfs_root_cxy = GET_CXY( vfs_root_xp );
3055	lock_xp = XPTR( vfs_root_cxy , &vfs_root_ptr->main_lock );
3056
3057	// take lock protecting Inode Tree in read mode
3058	remote_rwlock_rd_acquire( lock_xp );
3059
3060	// traverse Inode Tree from target inode to VFS root
3061	// selecting always the first parent dentry
3062	// the buffer is written in "reverse order" (from target inode to root)
3063	// exit the while loop when the VFS root has been found
3064	do
3065	{
3066	// get current inode cluster and local pointer
3067	current_cxy = GET_CXY( current_xp );
3068	current_ptr = GET_PTR( current_xp );
3069
3070	// build extended pointer on parents dentries root
3071	parents_root_xp = XPTR( current_cxy , &current_ptr->parents );
3072
3073	// compute exit condition <=> current inode is VFS root
3074	found = xlist_is_empty( parents_root_xp );
3075
3076	if( found ) // parent is the VFS root
3077	{
3078	if( index == (int32_t)(max_size - 1) )
3079	{
3080	// update index
3081	index--;
3082
3083	// set separator
3084	buffer[index] = '/';
3085
3086	// check buffer overflow
3087	assert( (index >= 0) , "kernel buffer too small\n" );
3088
3089	}
3090	}
3091	else // not the VFS root
3092	{
3093	// get first parent dentry cluster and pointers
3094	dentry_xp = XLIST_FIRST( parents_root_xp , vfs_dentry_t , parents );
3095	dentry_cxy = GET_CXY( dentry_xp );
3096	dentry_ptr = GET_PTR( dentry_xp );
3097
3098	// get extended pointer on dentry name and name length
3099	name_xp = XPTR( dentry_cxy , dentry_ptr->name );
3100	length = hal_remote_l32( XPTR( dentry_cxy , &dentry_ptr->length ) );
3101
3102	#if (DEBUG_VFS_GET_PATH & 1)
3103	char debug_name[CONFIG_VFS_MAX_NAME_LENGTH];
3104	hal_remote_strcpy( XPTR( local_cxy , debug_name ) , name_xp );
3105	if( DEBUG_VFS_GET_PATH < cycle )
3106	printk("\n[%s] thread(%x,%s) get current dentry <%s> in cluster %x\n",
3107	__FUNCTION__ , process->pid, this->trdid, debug_name, current_cxy );
3108	#endif
3109	// update index
3110	index -= (length + 1);
3111
3112	// check buffer overflow
3113	assert( (index >= 0) , "kernel buffer too small\n" );
3114
3115	// update pathname
3116	hal_remote_memcpy( XPTR( local_cxy , &buffer[index + 1] ) ,
3117	name_xp , length );
3118
3119	// set separator
3120	buffer[index] = '/';
3121
3122	// get extended pointer on parent inode
3123	current_xp = XPTR( dentry_cxy ,
3124	hal_remote_lpt( XPTR( dentry_cxy , &dentry_ptr->parent ) ) );
3125	}
3126	}
3127	while( found == false );
3128
3129	// release lock protecting Inode Tree in read mode
3130	remote_rwlock_rd_release( lock_xp );
3131
3132	#if DEBUG_VFS_GET_PATH
3133	cycle = (uint32_t)hal_get_cycles();
3134	if( DEBUG_VFS_GET_PATH < cycle )
3135	printk("\n[%s] thread[%x,%x] exit : path <%s> / cycle %d\n",
3136	__FUNCTION__ , process->pid, this->trdid, &buffer[index], cycle );
3137	#endif
3138
3139	// return pointer on first character in buffer
3140	*first = &buffer[index];
3141	return 0;
3142
3143	} // end vfs_get_path()
3144
3145
3146	////////////////////////////////////////////////////////////////////
3147	error_t vfs_add_child_in_parent( cxy_t child_cxy,
3148	vfs_fs_type_t fs_type,
3149	xptr_t parent_inode_xp,
3150	char * name,
3151	xptr_t * child_dentry_xp,
3152	xptr_t * child_inode_xp )
3153	{
3154	error_t error;
3155	cxy_t parent_cxy; // parent inode cluster identifier
3156	vfs_inode_t * parent_inode_ptr; // parent inode local pointer
3157	xptr_t new_dentry_xp; // extended pointer on created dentry
3158	vfs_dentry_t * new_dentry_ptr; // created dentry local pointer
3159	xptr_t new_inode_xp; // extended pointer on created child inode
3160	vfs_inode_t * new_inode_ptr; // local pointer on created child inode
3161
3162	xptr_t parents_root_xp; // extended pointer on child inode "parents" field
3163	xptr_t parents_entry_xp; // extended pointer on child dentry "parents" field
3164	xptr_t children_xhtab_xp; // extended pointer on parent inode "children" field
3165	xptr_t children_entry_xp; // extended pointer on child dentry "children" field
3166
3167	// get parent inode cluster and pointer
3168	parent_cxy = GET_CXY( parent_inode_xp );
3169	parent_inode_ptr = GET_PTR( parent_inode_xp );
3170
3171	#if DEBUG_VFS_ADD_CHILD
3172	char parent_name[CONFIG_VFS_MAX_NAME_LENGTH];
3173	vfs_inode_get_name( parent_inode_xp , parent_name );
3174	uint32_t cycle = (uint32_t)hal_get_cycles();
3175	thread_t * this = CURRENT_THREAD;
3176	if( DEBUG_VFS_ADD_CHILD < cycle )
3177	printk("\n[%s] thread[%x,%x] enter / child <%s> / parent <%s> / cycle %d\n",
3178	__FUNCTION__, this->process->pid, this->trdid, name,
3179	parent_name, (uint32_t)hal_get_cycles() );
3180	#endif
3181
3182	// 1. create dentry in parent cluster
3183	if( parent_cxy == local_cxy ) // parent cluster is local
3184	{
3185	error = vfs_dentry_create( fs_type,
3186	name,
3187	&new_dentry_xp );
3188	}
3189	else // parent cluster is remote
3190	{
3191	rpc_vfs_dentry_create_client( parent_cxy,
3192	fs_type,
3193	name,
3194	&new_dentry_xp,
3195	&error );
3196	}
3197
3198	if( error )
3199	{
3200	printk("\n[ERROR] in %s : cannot create dentry <%s> in cluster %x\n",
3201	__FUNCTION__ , name , parent_cxy );
3202	return -1;
3203	}
3204
3205	// get dentry local pointer
3206	new_dentry_ptr = GET_PTR( new_dentry_xp );
3207
3208	#if(DEBUG_VFS_ADD_CHILD & 1)
3209	if( DEBUG_VFS_ADD_CHILD < cycle )
3210	printk("\n[%s] thread[%x,%x] / dentry <%s> created (%x,%x)\n",
3211	__FUNCTION__, this->process->pid, this->trdid, name, parent_cxy, new_dentry_ptr );
3212	#endif
3213
3214	// 2. create child inode in child cluster
3215	// TODO : define attr / mode / uid / gid
3216	uint32_t attr = 0;
3217	uint32_t mode = 0;
3218	uint32_t uid = 0;
3219	uint32_t gid = 0;
3220
3221	if( child_cxy == local_cxy ) // child cluster is local
3222	{
3223	error = vfs_inode_create( fs_type,
3224	attr,
3225	mode,
3226	uid,
3227	gid,
3228	&new_inode_xp );
3229	}
3230	else // child cluster is remote
3231	{
3232	rpc_vfs_inode_create_client( child_cxy,
3233	fs_type,
3234	attr,
3235	mode,
3236	uid,
3237	gid,
3238	&new_inode_xp,
3239	&error );
3240	}
3241
3242	if( error )
3243	{
3244	printk("\n[ERROR] in %s : cannot create inode in cluster %x\n",
3245	__FUNCTION__ , child_cxy );
3246
3247	if( parent_cxy == local_cxy ) vfs_dentry_destroy( new_dentry_ptr );
3248	else rpc_vfs_dentry_destroy_client( parent_cxy , new_dentry_ptr );
3249	return -1;
3250	}
3251
3252	// get new inode local pointer
3253	new_inode_ptr = GET_PTR( new_inode_xp );
3254
3255	#if(DEBUG_VFS_ADD_CHILD & 1)
3256	if( DEBUG_VFS_ADD_CHILD < cycle )
3257	printk("\n[%s] thread[%x,%x] / inode <%s> created (%x,%x)\n",
3258	__FUNCTION__ , this->process->pid, this->trdid, name , child_cxy, new_inode_ptr );
3259	#endif
3260
3261	// 3. register new_dentry in new_inode xlist of parents
3262	parents_root_xp = XPTR( child_cxy , &new_inode_ptr->parents );
3263	parents_entry_xp = XPTR( parent_cxy, &new_dentry_ptr->parents );
3264	xlist_add_first( parents_root_xp , parents_entry_xp );
3265	hal_remote_atomic_add( XPTR( child_cxy , &new_inode_ptr->links ) , 1 );
3266
3267	#if(DEBUG_VFS_ADD_CHILD & 1)
3268	if( DEBUG_VFS_ADD_CHILD < cycle )
3269	printk("\n[%s] thread[%x,%x] / dentry (%x,%x) registered in child inode (%x,%x)\n",
3270	__FUNCTION__, this->process->pid, this->trdid,
3271	parent_cxy, new_dentry_ptr, child_cxy, new_inode_ptr );
3272	#endif
3273
3274	// register new_dentry in parent_inode xhtab of children
3275	children_xhtab_xp = XPTR( parent_cxy , &parent_inode_ptr->children );
3276	children_entry_xp = XPTR( parent_cxy , &new_dentry_ptr->children );
3277	xhtab_insert( children_xhtab_xp , name , children_entry_xp );
3278
3279	#if(DEBUG_VFS_ADD_CHILD & 1)
3280	if( DEBUG_VFS_ADD_CHILD < cycle )
3281	printk("\n[%s] thread[%x,%x] / dentry (%x,%x) registered in parent inode (%x,%x)\n",
3282	__FUNCTION__, this->process->pid, this->trdid,
3283	parent_cxy, new_dentry_ptr, parent_cxy, parent_inode_ptr );
3284	#endif
3285
3286	// update "parent" and "child_xp" fields in new_dentry
3287	hal_remote_s64( XPTR( parent_cxy , &new_dentry_ptr->child_xp ) , new_inode_xp );
3288	hal_remote_spt( XPTR( parent_cxy , &new_dentry_ptr->parent ) , parent_inode_ptr );
3289
3290	#if DEBUG_VFS_ADD_CHILD
3291	cycle = (uint32_t)hal_get_cycles();
3292	if( DEBUG_VFS_ADD_CHILD < cycle )
3293	printk("\n[%s] thread[%x,%x] exit for <%s> / cycle %d\n",
3294	__FUNCTION__, this->process->pid, this->trdid, name, (uint32_t)hal_get_cycles() );
3295	#endif
3296
3297	// return extended pointer on dentry & child inode
3298	*child_dentry_xp = new_dentry_xp;
3299	*child_inode_xp = new_inode_xp;
3300	return 0;
3301
3302	} // end vfs_add_child_in_parent()
3303
3304	/////////////////////////////////////////////////////
3305	void vfs_remove_child_from_parent( xptr_t dentry_xp )
3306	{
3307	cxy_t parent_cxy; // parent inode cluster identifier
3308	cxy_t child_cxy; // child inode cluster identifier
3309	vfs_dentry_t * dentry_ptr; // local pointer on dentry
3310	xptr_t child_inode_xp; // extended pointer on child inode
3311	vfs_inode_t * child_inode_ptr; // local pointer on child inode
3312	vfs_inode_t * parent_inode_ptr; // local pointer on parent inode
3313	uint32_t links; // number of child inode parents
3314
3315	char dentry_name[CONFIG_VFS_MAX_NAME_LENGTH];
3316
3317	// get parent cluster and dentry local pointer
3318	parent_cxy = GET_CXY( dentry_xp );
3319	dentry_ptr = GET_PTR( dentry_xp );
3320
3321	// get a local copy of dentry name
3322	hal_remote_strcpy( XPTR( local_cxy , dentry_name ),
3323	XPTR( parent_cxy , &dentry_ptr->name ) );
3324
3325	// get parent_inode local pointer
3326	parent_inode_ptr = hal_remote_lpt( XPTR( parent_cxy , &dentry_ptr->parent ) );
3327
3328	// get child cluster and child_inode pointers
3329	child_inode_xp = hal_remote_l64( XPTR( parent_cxy , &dentry_ptr->child_xp ) );
3330	child_cxy = GET_CXY( child_inode_xp );
3331	child_inode_ptr = GET_PTR( child_inode_xp );
3332
3333	// remove dentry from parent_inode
3334	xhtab_remove( XPTR( parent_cxy , &parent_inode_ptr->children ),
3335	dentry_name,
3336	XPTR( parent_cxy , &dentry_ptr->children ) );
3337
3338	// remove dentry from child_inode
3339	xlist_unlink( XPTR( parent_cxy , &dentry_ptr->parents ) );
3340	links = hal_remote_atomic_add( XPTR( child_cxy , &child_inode_ptr->links ) , -1 );
3341
3342	// delete dentry descriptor
3343	if( parent_cxy == local_cxy )
3344	{
3345	vfs_dentry_destroy( dentry_ptr );
3346	}
3347	else
3348	{
3349	rpc_vfs_dentry_destroy_client( parent_cxy,
3350	dentry_ptr );
3351	}
3352
3353	// delete child_inode descriptor if last link
3354	if( links == 1 )
3355	{
3356	if( child_cxy == local_cxy )
3357	{
3358	vfs_inode_destroy( child_inode_ptr );
3359	}
3360	else
3361	{
3362	rpc_vfs_inode_destroy_client( child_cxy , child_inode_ptr );
3363	}
3364	}
3365
3366	} // end vfs_remove_child_from_parent()
3367
3368
3369
3370
3371	//////////////////////////////////////////////////////////////////////////////////////////
3372	// API used by VFS to access a specific FS
3373	//////////////////////////////////////////////////////////////////////////////////////////
3374
3375	//////////////////////////////////////////////
3376	error_t vfs_fs_move_page( xptr_t page_xp,
3377	cmd_type_t cmd_type )
3378	{
3379	error_t error = 0;
3380
3381	assert( (page_xp != XPTR_NULL) , "page pointer is NULL\n" );
3382
3383	page_t * page_ptr = GET_PTR( page_xp );
3384	cxy_t page_cxy = GET_CXY( page_xp );
3385
3386	// get local pointer on page mapper
3387	mapper_t * mapper = hal_remote_lpt( XPTR( page_cxy , &page_ptr->mapper ) );
3388
3389	assert( (mapper != NULL) , "no mapper for page\n" );
3390
3391	// get FS type
3392	vfs_fs_type_t fs_type = hal_remote_l32( XPTR( page_cxy , &mapper->type ) );
3393
3394	// call relevant FS function
3395	if( fs_type == FS_TYPE_FATFS )
3396	{
3397	error = fatfs_move_page( page_xp , cmd_type );
3398	}
3399	else if( fs_type == FS_TYPE_RAMFS )
3400	{
3401	assert( false , "should not be called for RAMFS\n" );
3402	}
3403	else if( fs_type == FS_TYPE_DEVFS )
3404	{
3405	assert( false , "should not be called for DEVFS\n" );
3406	}
3407	else
3408	{
3409	assert( false , "undefined file system type\n" );
3410	}
3411
3412	return error;
3413
3414	} // end vfs_fs_move_page()
3415
3416	////////////////////////////////////////////////
3417	error_t vfs_fs_add_dentry( vfs_inode_t * inode,
3418	vfs_dentry_t * dentry )
3419	{
3420	error_t error = 0;
3421
3422	assert( (inode != NULL) , "inode pointer is NULL\n" );
3423	assert( (dentry != NULL) , "dentry pointer is NULL\n" );
3424
3425	mapper_t * mapper = inode->mapper;
3426
3427	assert( (mapper != NULL) , "mapper pointer is NULL\n" );
3428
3429	// get FS type
3430	vfs_fs_type_t fs_type = mapper->type;
3431
3432	// call relevant FS function
3433	if( fs_type == FS_TYPE_FATFS )
3434	{
3435	error = fatfs_add_dentry( inode , dentry );
3436	}
3437	else if( fs_type == FS_TYPE_RAMFS )
3438	{
3439	error = 0; // does nothing for RAMFS
3440	}
3441	else if( fs_type == FS_TYPE_DEVFS )
3442	{
3443	error = 0; // does nothing for DEVFS
3444	}
3445	else
3446	{
3447	assert( false , "undefined file system type\n" );
3448	}
3449
3450	return error;
3451
3452	} // end vfs_fs_add_dentry()
3453
3454	///////////////////////////////////////////////////
3455	error_t vfs_fs_remove_dentry( vfs_inode_t * inode,
3456	vfs_dentry_t * dentry )
3457	{
3458	error_t error = 0;
3459
3460	assert( (inode != NULL) , "inode pointer is NULL\n" );
3461	assert( (dentry != NULL) , "dentry pointer is NULL\n" );
3462
3463	mapper_t * mapper = inode->mapper;
3464
3465	assert( (mapper != NULL) , "mapper pointer is NULL\n" );
3466
3467	// get FS type
3468	vfs_fs_type_t fs_type = mapper->type;
3469
3470	// call relevant FS function
3471	if( fs_type == FS_TYPE_FATFS )
3472	{
3473	error = fatfs_remove_dentry( inode , dentry );
3474	}
3475	else if( fs_type == FS_TYPE_RAMFS )
3476	{
3477	error = 0; // does nothing for RAMFS
3478	}
3479	else if( fs_type == FS_TYPE_DEVFS )
3480	{
3481	error = 0; // does nothing for DEVFS
3482	}
3483	else
3484	{
3485	assert( false , "undefined file system type\n" );
3486	}
3487
3488	return error;
3489
3490	} // end vfs_fs_remove_dentry()
3491
3492	////////////////////////////////////////////////
3493	error_t vfs_fs_new_dentry( vfs_inode_t * parent,
3494	char * name,
3495	xptr_t child_xp )
3496	{
3497	error_t error = 0;
3498
3499	// check arguments
3500	assert( (parent != NULL) , "parent pointer is NULL\n");
3501	assert( (child_xp != XPTR_NULL) , "child pointer is NULL\n");
3502
3503	// get parent inode FS type
3504	vfs_fs_type_t fs_type = parent->ctx->type;
3505
3506	// call relevant FS function
3507	if( fs_type == FS_TYPE_FATFS )
3508	{
3509	error = fatfs_new_dentry( parent , name , child_xp );
3510	}
3511	else if( fs_type == FS_TYPE_RAMFS )
3512	{
3513	assert( false , "should not be called for RAMFS\n" );
3514	}
3515	else if( fs_type == FS_TYPE_DEVFS )
3516	{
3517	assert( false , "should not be called for DEVFS\n" );
3518	}
3519	else
3520	{
3521	assert( false , "undefined file system type\n" );
3522	}
3523
3524	return error;
3525
3526	} // end vfs_fs_new_dentry()
3527
3528	///////////////////////////////////////////////////
3529	error_t vfs_fs_update_dentry( vfs_inode_t * inode,
3530	vfs_dentry_t * dentry,
3531	uint32_t size )
3532	{
3533	error_t error = 0;
3534
3535	// check arguments
3536	assert( (inode != NULL) , "inode pointer is NULL\n");
3537	assert( (dentry != NULL) , "dentry pointer is NULL\n");
3538
3539	// get parent inode FS type
3540	vfs_fs_type_t fs_type = inode->ctx->type;
3541
3542	// call relevant FS function
3543	if( fs_type == FS_TYPE_FATFS )
3544	{
3545	error = fatfs_update_dentry( inode , dentry , size );
3546	}
3547	else if( fs_type == FS_TYPE_RAMFS )
3548	{
3549	assert( false , "should not be called for RAMFS\n" );
3550	}
3551	else if( fs_type == FS_TYPE_DEVFS )
3552	{
3553	assert( false , "should not be called for DEVFS\n" );
3554	}
3555	else
3556	{
3557	assert( false , "undefined file system type\n" );
3558	}
3559
3560	return error;
3561
3562	} // end vfs_fs_update_dentry()
3563
3564	///////////////////////////////////////////////////
3565	error_t vfs_fs_get_user_dir( vfs_inode_t * inode,
3566	struct dirent * array,
3567	uint32_t max_dirent,
3568	uint32_t min_dentry,
3569	bool_t detailed,
3570	uint32_t * entries,
3571	bool_t * done )
3572	{
3573	error_t error = 0;
3574
3575	// check arguments
3576	assert( (inode != NULL) , "parent pointer is NULL\n");
3577	assert( (array != NULL) , "child pointer is NULL\n");
3578	assert( (detailed == false) , "detailed argument not supported\n");
3579
3580	// check inode type
3581	if( inode->type != INODE_TYPE_DIR )
3582	{
3583	printk("\n[ERROR] in %s : target inode is not a directory\n",
3584	__FUNCTION__ );
3585	return -1;
3586	}
3587
3588	// get parent inode FS type
3589	vfs_fs_type_t fs_type = inode->ctx->type;
3590
3591	// call relevant FS function
3592	if( fs_type == FS_TYPE_FATFS )
3593	{
3594	error = fatfs_get_user_dir( inode,
3595	array,
3596	max_dirent,
3597	min_dentry,
3598	detailed,
3599	entries,
3600	done );
3601	}
3602	else if( fs_type == FS_TYPE_RAMFS )
3603	{
3604	assert( false , "should not be called for RAMFS\n" );
3605	}
3606	else if( fs_type == FS_TYPE_DEVFS )
3607	{
3608	error = devfs_get_user_dir( inode,
3609	array,
3610	max_dirent,
3611	min_dentry,
3612	detailed,
3613	entries,
3614	done );
3615	}
3616	else
3617	{
3618	assert( false , "undefined file system type\n" );
3619	}
3620
3621	return error;
3622
3623	} // end vfs_fs_get_user_dir()
3624
3625	////////////////////////////////////////////////
3626	error_t vfs_fs_sync_inode( vfs_inode_t * inode )
3627	{
3628	error_t error = 0;
3629
3630	// check arguments
3631	assert( (inode != NULL) , "inode pointer is NULL\n");
3632
3633	// get inode FS type
3634	vfs_fs_type_t fs_type = inode->ctx->type;
3635
3636	// call relevant FS function
3637	if( fs_type == FS_TYPE_FATFS )
3638	{
3639	error = fatfs_sync_inode( inode );
3640	}
3641	else if( fs_type == FS_TYPE_RAMFS )
3642	{
3643	assert( false , "should not be called for RAMFS\n" );
3644	}
3645	else if( fs_type == FS_TYPE_DEVFS )
3646	{
3647	assert( false , "should not be called for DEVFS\n" );
3648	}
3649	else
3650	{
3651	assert( false , "undefined file system type\n" );
3652	}
3653
3654	return error;
3655
3656	} // end vfs_fs_sync_inode()
3657
3658	////////////////////////////////////////////////
3659	error_t vfs_fs_sync_fat( vfs_fs_type_t fs_type )
3660	{
3661	error_t error = 0;
3662
3663	// call relevant FS function
3664	if( fs_type == FS_TYPE_FATFS )
3665	{
3666	error = fatfs_sync_fat();
3667	}
3668	else if( fs_type == FS_TYPE_RAMFS )
3669	{
3670	assert( false , "should not be called for RAMFS\n" );
3671	}
3672	else if( fs_type == FS_TYPE_DEVFS )
3673	{
3674	assert( false , "should not be called for DEVFS\n" );
3675	}
3676	else
3677	{
3678	assert( false , "undefined file system type\n" );
3679	}
3680
3681	return error;
3682
3683	} // end vfs_fs_sync_fat()
3684
3685	//////////////////////////////////////////////////////
3686	error_t vfs_fs_sync_free_info( vfs_fs_type_t fs_type )
3687	{
3688	error_t error = 0;
3689
3690	// call relevant FS function
3691	if( fs_type == FS_TYPE_FATFS )
3692	{
3693	error = fatfs_sync_free_info();
3694	}
3695	else if( fs_type == FS_TYPE_RAMFS )
3696	{
3697	assert( false , "should not be called for RAMFS\n" );
3698	}
3699	else if( fs_type == FS_TYPE_DEVFS )
3700	{
3701	assert( false , "should not be called for DEVFS\n" );
3702	}
3703	else
3704	{
3705	assert( false , "undefined file system type\n" );
3706	}
3707
3708	return error;
3709
3710	} // end vfs_fs_sync_fat()
3711
3712	/////////////////////////////////////////////////
3713	error_t vfs_fs_cluster_alloc( uint32_t fs_type,
3714	uint32_t * cluster )
3715	{
3716	error_t error = 0;
3717
3718	// call relevant FS function
3719	if( fs_type == FS_TYPE_FATFS )
3720	{
3721	error = fatfs_cluster_alloc( cluster );
3722	}
3723	else if( fs_type == FS_TYPE_RAMFS )
3724	{
3725	assert( false , "should not be called for RAMFS\n" );
3726	}
3727	else if( fs_type == FS_TYPE_DEVFS )
3728	{
3729	assert( false , "should not be called for DEVFS\n" );
3730	}
3731	else
3732	{
3733	assert( false , "undefined file system type\n" );
3734	}
3735
3736	return error;
3737
3738	} // end vfs_fs_alloc_cluster()
3739
3740	////////////////////////////////////////////////
3741	error_t vfs_fs_release_inode( xptr_t inode_xp )
3742	{
3743	error_t error = 0;
3744
3745	assert( (inode_xp != XPTR_NULL) , "inode pointer is NULL\n")
3746
3747	vfs_inode_t * inode_ptr = GET_PTR( inode_xp );
3748	cxy_t inode_cxy = GET_CXY( inode_xp );
3749
3750	// get local pointer on page mapper
3751	mapper_t * mapper = hal_remote_lpt( XPTR( inode_cxy , &inode_ptr->mapper ) );
3752
3753	assert( (mapper != NULL) , "mapper pointer is NULL\n")
3754
3755	// get FS type from mapper
3756	vfs_fs_type_t fs_type = hal_remote_l32( XPTR( inode_cxy , &mapper->type ) );
3757
3758	// call relevant FS function
3759	if( fs_type == FS_TYPE_FATFS )
3760	{
3761	error = fatfs_release_inode( inode_xp );
3762	}
3763	else if( fs_type == FS_TYPE_RAMFS )
3764	{
3765	assert( false , "should not be called for RAMFS\n" );
3766	}
3767	else if( fs_type == FS_TYPE_DEVFS )
3768	{
3769	assert( false , "should not be called for DEVFS\n" );
3770	}
3771	else
3772	{
3773	assert( false , "undefined file system type\n" );
3774	}
3775
3776	return error;
3777
3778	} // end vfs_fs_release_inode()
3779
3780

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

Download in other formats: