Context Navigation

vfs.c @ 508

Last change on this file since 508 was 492, checked in by viala@…, 6 years ago

Refactoring assert calling to conform with new assert macro.

Made with this command for the general case.
find ./kernel/ hal/ -name "*.c" | xargs sed -i -e '/assert(/ s/,[ ]*FUNCTION[ ]*,/,/'

And some done by hand.

File size: 68.9 KB

Rev	Line
[1]	1	/*
	2	* vfs.c - Virtual File System implementation.
	3	*
	4	* Author Mohamed Lamine Karaoui (2015)
[437]	5	* Alain Greiner (2016,2017,2018)
[1]	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
[14]	26	#include <kernel_config.h>
[457]	27	#include <hal_kernel_types.h>
[1]	28	#include <hal_atomic.h>
	29	#include <hal_special.h>
	30	#include <readlock.h>
	31	#include <spinlock.h>
	32	#include <printk.h>
	33	#include <list.h>
	34	#include <xlist.h>
	35	#include <slist.h>
	36	#include <xhtab.h>
[430]	37	#include <string.h>
[23]	38	#include <rpc.h>
[1]	39	#include <errno.h>
	40	#include <kmem.h>
	41	#include <mapper.h>
	42	#include <thread.h>
[337]	43	#include <chdev.h>
[1]	44	#include <process.h>
[23]	45	#include <vfs.h>
[1]	46	#include <fatfs.h>
	47	#include <ramfs.h>
[23]	48	#include <devfs.h>
	49	#include <syscalls.h>
[1]	50
	51
	52	//////////////////////////////////////////////////////////////////////////////////////////
[50]	53	// Extern variables
[1]	54	//////////////////////////////////////////////////////////////////////////////////////////
	55
[337]	56	extern vfs_ctx_t fs_context[FS_TYPES_NR]; // allocated in kernel_init.c
[188]	57
[337]	58	extern chdev_directory_t chdev_dir; // allocated in kernel_init.c
[50]	59
[1]	60	//////////////////////////////////////////////////////////////////////////////////////////
	61	// Context related functions
	62	//////////////////////////////////////////////////////////////////////////////////////////
	63
[188]	64	////////////////////////////////////////
	65	void vfs_ctx_init( vfs_fs_type_t type,
	66	uint32_t attr,
	67	uint32_t total_clusters,
	68	uint32_t cluster_size,
	69	xptr_t vfs_root_xp,
	70	void * extend )
	71	{
	72	vfs_ctx_t * vfs_ctx = &fs_context[type];
	73
	74	vfs_ctx->type = type;
	75	vfs_ctx->attr = attr;
	76	vfs_ctx->total_clusters = total_clusters;
	77	vfs_ctx->cluster_size = cluster_size;
	78	vfs_ctx->vfs_root_xp = vfs_root_xp;
	79	vfs_ctx->extend = extend;
	80
	81	spinlock_init( &vfs_ctx->lock );
	82
	83	bitmap_init( vfs_ctx->bitmap , BITMAP_SIZE(CONFIG_VFS_MAX_INODES) );
	84	}
	85
[23]	86	////////////////////////////////////////////
[1]	87	error_t vfs_ctx_inum_alloc( vfs_ctx_t * ctx,
	88	uint32_t * inum )
	89	{
	90	// get lock on inum allocator
	91	spinlock_lock( &ctx->lock );
	92
	93	// get lid from local inum allocator
[23]	94	uint32_t lid = bitmap_ffc( ctx->bitmap , CONFIG_VFS_MAX_INODES );
[1]	95
[473]	96	if( lid == 0xFFFFFFFF ) // no more free slot => error
[1]	97	{
	98	// release lock
	99	spinlock_unlock( &ctx->lock );
	100
	101	// return error
	102	return 1;
	103	}
	104	else // found => return inum
	105	{
	106	// set slot allocated
[23]	107	bitmap_set( ctx->bitmap , lid );
[1]	108
	109	// release lock
	110	spinlock_unlock( &ctx->lock );
	111
	112	// return inum
	113	*inum = (((uint32_t)local_cxy) << 16) \| (lid & 0xFFFF);
	114	return 0;
	115	}
	116	}
	117
	118	////////////////////////////////////////////
	119	void vfs_ctx_inum_release( vfs_ctx_t * ctx,
	120	uint32_t inum )
	121	{
[23]	122	bitmap_clear( ctx->bitmap , inum & 0xFFFF );
[1]	123	}
	124
	125	//////////////////////////////////////////////////////////////////////////////////////////
	126	// Inode related functions
	127	//////////////////////////////////////////////////////////////////////////////////////////
	128
[188]	129	char * vfs_inode_type_str( uint32_t type )
	130	{
	131	if ( type == INODE_TYPE_FILE ) return "FILE";
	132	else if( type == INODE_TYPE_DIR ) return "DIR ";
	133	else if( type == INODE_TYPE_FIFO ) return "FIFO";
	134	else if( type == INODE_TYPE_PIPE ) return "PIPE";
	135	else if( type == INODE_TYPE_SOCK ) return "SOCK";
	136	else if( type == INODE_TYPE_DEV ) return "DEV ";
	137	else if( type == INODE_TYPE_SYML ) return "SYML";
	138	else return "undefined";
	139	}
	140
[23]	141	//////////////////////////////////////////////////////
	142	error_t vfs_inode_create( xptr_t dentry_xp,
	143	vfs_fs_type_t fs_type,
	144	vfs_inode_type_t inode_type,
[188]	145	void * extend,
[23]	146	uint32_t attr,
	147	uint32_t rights,
	148	uid_t uid,
	149	gid_t gid,
	150	xptr_t * inode_xp )
[1]	151	{
	152	mapper_t * mapper; // associated mapper( to be allocated)
	153	vfs_inode_t * inode; // inode descriptor (to be allocated)
	154	uint32_t inum; // inode identifier (to be allocated)
	155	vfs_ctx_t * ctx; // file system context
	156	kmem_req_t req; // request to kernel memory allocator
	157	error_t error;
	158
[438]	159	#if DEBUG_VFS_INODE_CREATE
[433]	160	uint32_t cycle = (uint32_t)hal_get_cycles();
[438]	161	if( DEBUG_VFS_INODE_CREATE < cycle )
[433]	162	printk("\n[DBG] %s : thread %x enter / dentry = %x in cluster %x / cycle %d\n",
	163	__FUNCTION__, CURRENT_THREAD, GET_PTR(dentry_xp), GET_CXY(dentry_xp), cycle );
	164	#endif
[279]	165
[23]	166	// check fs type and get pointer on context
	167	if ( fs_type == FS_TYPE_FATFS ) ctx = &fs_context[FS_TYPE_FATFS];
	168	else if( fs_type == FS_TYPE_RAMFS ) ctx = &fs_context[FS_TYPE_RAMFS];
	169	else if( fs_type == FS_TYPE_DEVFS ) ctx = &fs_context[FS_TYPE_DEVFS];
[1]	170	else
	171	{
	172	ctx = NULL;
[492]	173	assert( false , "illegal file system type = %d\n" , fs_type );
[1]	174	}
	175
	176	// allocate inum
	177	error = vfs_ctx_inum_alloc( ctx , &inum );
	178
	179	if( error )
	180	{
	181	printk("\n[ERROR] in %s : cannot allocate inum\n", __FUNCTION__ );
	182	return ENOMEM;
	183	}
	184
	185	// allocate memory for mapper
[246]	186	mapper = mapper_create( fs_type );
[1]	187
	188	if( mapper == NULL )
	189	{
	190	printk("\n[ERROR] in %s : cannot allocate mapper\n", __FUNCTION__ );
	191	vfs_ctx_inum_release( ctx , inum );
	192	return ENOMEM;
	193	}
	194
[23]	195	// allocate memory for VFS inode descriptor
[1]	196	req.type = KMEM_VFS_INODE;
	197	req.size = sizeof(vfs_inode_t);
	198	req.flags = AF_KERNEL \| AF_ZERO;
	199	inode = (vfs_inode_t *)kmem_alloc( &req );
	200
	201	if( inode == NULL )
	202	{
	203	printk("\n[ERROR] in %s : cannot allocate inode descriptor\n", __FUNCTION__ );
	204	vfs_ctx_inum_release( ctx , inum );
	205	mapper_destroy( mapper );
	206	return ENOMEM;
	207	}
	208
	209	// initialize inode descriptor
	210	inode->gc = 0;
[23]	211	inode->type = inode_type;
[1]	212	inode->inum = inum;
	213	inode->attr = attr;
[23]	214	inode->rights = rights;
[1]	215	inode->uid = uid;
	216	inode->gid = gid;
	217	inode->refcount = 0;
	218	inode->parent_xp = dentry_xp;
	219	inode->ctx = ctx;
[246]	220	inode->mapper = mapper;
[188]	221	inode->extend = extend;
[1]	222
[246]	223	// initialise inode field in mapper
	224	mapper->inode = inode;
	225
[1]	226	// initialise threads waiting queue
	227	xlist_root_init( XPTR( local_cxy , &inode->wait_root ) );
	228
[204]	229	// initialize dentries hash table
	230	xhtab_init( &inode->children , XHTAB_DENTRY_TYPE );
[1]	231
	232	// initialize inode locks
[10]	233	remote_rwlock_init( XPTR( local_cxy , &inode->data_lock ) );
[1]	234	remote_spinlock_init( XPTR( local_cxy , &inode->main_lock ) );
	235
[438]	236	#if DEBUG_VFS_INODE_CREATE
[436]	237	cycle = (uint32_t)hal_get_cycles();
[438]	238	if( DEBUG_VFS_INODE_CREATE < cycle )
[433]	239	printk("\n[DBG] %s : thread %x exit / inode = %x in cluster %x / cycle %d\n",
	240	__FUNCTION__, CURRENT_THREAD, inode, local_cxy, cycle );
	241	#endif
[401]	242
[1]	243	// return extended pointer on inode
	244	*inode_xp = XPTR( local_cxy , inode );
	245	return 0;
	246
	247	} // end vfs_inode_create()
	248
[459]	249	////////////////////////////////////////////////
	250	error_t vfs_inode_destroy( vfs_inode_t * inode )
[1]	251	{
[492]	252	assert( (inode->refcount == 0) , "inode refcount non zero\n" );
[1]	253
	254	// release memory allocated for mapper
	255	mapper_destroy( inode->mapper );
	256
	257	// release memory allocate for inode descriptor
	258	kmem_req_t req;
	259	req.ptr = inode;
	260	req.type = KMEM_VFS_INODE;
	261	kmem_free( &req );
	262
[459]	263	return 0;
	264
[1]	265	} // end vfs_inode_destroy()
	266
[238]	267	/////////////////////////////////////////////
	268	error_t vfs_inode_load( vfs_inode_t * parent,
	269	char * name,
	270	xptr_t child_xp )
	271	{
[246]	272
[438]	273	#if DEBUG_VFS_INODE_LOAD
[433]	274	uint32_t cycle = (uint32_t)hal_get_cycles();
[438]	275	if( DEBUG_VFS_INODE_LOAD < cycle )
[433]	276	printk("\n[DBG] %s : thread %x enter for <%s> / cycle %d\n",
	277	__FUNCTION__, CURRENT_THREAD , name , cycle );
	278	#endif
	279
[238]	280	error_t error = 0;
	281
[492]	282	assert( (parent != NULL) , "parent pointer is NULL\n");
[238]	283
[492]	284	assert( (child_xp != XPTR_NULL) , "child pointer is NULL\n");
[238]	285
	286	// get parent inode FS type
	287	vfs_fs_type_t fs_type = parent->ctx->type;
	288
	289	// call relevant FS function
	290	if( fs_type == FS_TYPE_FATFS )
	291	{
	292	error = fatfs_inode_load( parent , name , child_xp );
	293	}
	294	else if( fs_type == FS_TYPE_RAMFS )
	295	{
[492]	296	assert( false , "should not be called for RAMFS\n" );
[238]	297	}
	298	else if( fs_type == FS_TYPE_DEVFS )
	299	{
[492]	300	assert( false , "should not be called for DEVFS\n" );
[238]	301	}
	302	else
	303	{
[492]	304	assert( false , "undefined file system type\n" );
[238]	305	}
	306
[438]	307	#if DEBUG_VFS_INODE_LOAD
[433]	308	cycle = (uint32_t)hal_get_cycles();
[438]	309	if( DEBUG_VFS_INODE_LOAD < cycle )
[433]	310	printk("\n[DBG] %s : thread %x exit for <%s> / cycle %d\n",
	311	__FUNCTION__, CURRENT_THREAD , name , cycle );
	312	#endif
[246]	313
[238]	314	return error;
	315
[459]	316	} // end vfs_inode_load()
[238]	317
[1]	318	////////////////////////////////////////////
	319	void vfs_inode_remote_up( xptr_t inode_xp )
	320	{
	321	// get inode cluster and local pointer
	322	cxy_t inode_cxy = GET_CXY( inode_xp );
[473]	323	vfs_inode_t * inode_ptr = GET_PTR( inode_xp );
[1]	324
	325	hal_remote_atomic_add( XPTR( inode_cxy , &inode_ptr->refcount ) , 1 );
	326	}
	327
	328	//////////////////////////////////////////////
	329	void vfs_inode_remote_down( xptr_t inode_xp )
	330	{
	331	// get inode cluster and local pointer
	332	cxy_t inode_cxy = GET_CXY( inode_xp );
[473]	333	vfs_inode_t * inode_ptr = GET_PTR( inode_xp );
[1]	334
	335	hal_remote_atomic_add( XPTR( inode_cxy , &inode_ptr->refcount ) , -1 );
	336	}
	337
	338	//////////////////////////////////////////////
	339	uint32_t vfs_inode_get_size( xptr_t inode_xp )
	340	{
	341	// get inode cluster and local pointer
	342	cxy_t cxy = GET_CXY( inode_xp );
[473]	343	vfs_inode_t * ptr = GET_PTR( inode_xp );
[1]	344
	345	// get size
[10]	346	remote_rwlock_rd_lock( XPTR( cxy , &ptr->data_lock ) );
[1]	347	uint32_t size = hal_remote_lw( XPTR( cxy , &ptr->size ) );
[10]	348	remote_rwlock_rd_unlock( XPTR( cxy , &ptr->data_lock ) );
[1]	349	return size;
	350	}
	351
[101]	352	////////////////////////////////////////////
	353	void vfs_inode_set_size( xptr_t inode_xp,
[409]	354	uint32_t size )
[1]	355	{
	356	// get inode cluster and local pointer
	357	cxy_t cxy = GET_CXY( inode_xp );
[473]	358	vfs_inode_t * ptr = GET_PTR( inode_xp );
[1]	359
	360	// set size
[10]	361	remote_rwlock_wr_unlock( XPTR( cxy , &ptr->data_lock ) );
[1]	362	hal_remote_sw( XPTR( cxy , &ptr->size ) , size );
[10]	363	remote_rwlock_wr_unlock( XPTR( cxy , &ptr->data_lock ) );
[1]	364	}
	365
[101]	366	////////////////////////////////////////
	367	void vfs_inode_unlock( xptr_t inode_xp )
[1]	368	{
	369	// get inode cluster and local pointer
	370	cxy_t cxy = GET_CXY( inode_xp );
[473]	371	vfs_inode_t * ptr = GET_PTR( inode_xp );
[1]	372
	373	// release the main lock
	374	remote_spinlock_unlock( XPTR( cxy , &ptr->main_lock ) );
	375	}
	376
[101]	377	//////////////////////////////////////
	378	void vfs_inode_lock( xptr_t inode_xp )
[1]	379	{
	380	// get inode cluster and local pointer
	381	cxy_t cxy = GET_CXY( inode_xp );
[473]	382	vfs_inode_t * ptr = GET_PTR( inode_xp );
[1]	383
	384	// get the main lock
	385	remote_spinlock_lock( XPTR( cxy , &ptr->main_lock ) );
	386	}
	387
[101]	388	/////////////////////////////////////////
[409]	389	void vfs_inode_get_name( xptr_t inode_xp,
	390	char * name )
[101]	391	{
[204]	392	cxy_t inode_cxy;
	393	vfs_inode_t * inode_ptr;
	394	xptr_t dentry_xp;
	395	cxy_t dentry_cxy;
	396	vfs_dentry_t * dentry_ptr;
	397
	398	// get inode cluster and local pointer
	399	inode_cxy = GET_CXY( inode_xp );
[473]	400	inode_ptr = GET_PTR( inode_xp );
[204]	401
	402	// get parent dentry
	403	dentry_xp = hal_remote_lwd( XPTR( inode_cxy , &inode_ptr->parent_xp ) );
	404
	405	// get local copy of name
	406	if( dentry_xp == XPTR_NULL ) // it is the VFS root
	407	{
	408	strcpy( name , "/" );
	409	}
	410	else // not the VFS root
	411	{
	412	dentry_cxy = GET_CXY( dentry_xp );
[473]	413	dentry_ptr = GET_PTR( dentry_xp );
[204]	414
	415	hal_remote_strcpy( XPTR( local_cxy , name ) ,
	416	XPTR( dentry_cxy , &dentry_ptr->name ) );
	417	}
[409]	418	} // end vfs_inode_get_name()
[204]	419
	420	////////////////////////////////////////////////////////////////////////////////////////////
[1]	421	// Dentry related functions
	422	//////////////////////////////////////////////////////////////////////////////////////////
	423
[23]	424	///////////////////////////////////////////////////
	425	error_t vfs_dentry_create( vfs_fs_type_t fs_type,
	426	char * name,
	427	vfs_inode_t * parent,
	428	xptr_t * dentry_xp )
[1]	429	{
	430	vfs_ctx_t * ctx; // context descriptor
	431	vfs_dentry_t * dentry; // dentry descriptor (to be allocated)
	432	kmem_req_t req; // request to kernel memory allocator
[459]	433	error_t error;
[1]	434
[438]	435	#if DEBUG_VFS_DENTRY_CREATE
[433]	436	uint32_t cycle = (uint32_t)hal_get_cycles();
[438]	437	if( DEBUG_VFS_DENTRY_CREATE < cycle )
[459]	438	printk("\n[DBG] %s : thread %x in process %x enter for <%s> / parent_inode %x / cycle %d\n",
	439	__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, name, parent, cycle );
[433]	440	#endif
[296]	441
[188]	442	// get pointer on context
[23]	443	if ( fs_type == FS_TYPE_FATFS ) ctx = &fs_context[FS_TYPE_FATFS];
	444	else if( fs_type == FS_TYPE_RAMFS ) ctx = &fs_context[FS_TYPE_RAMFS];
	445	else if( fs_type == FS_TYPE_DEVFS ) ctx = &fs_context[FS_TYPE_DEVFS];
[459]	446	else
[1]	447	{
	448	ctx = NULL;
[459]	449	return EINVAL;
[1]	450	}
	451
	452	// get name length
	453	uint32_t length = strlen( name );
	454
[459]	455	if( length >= CONFIG_VFS_MAX_NAME_LENGTH ) return EINVAL;
[437]	456
[1]	457	// allocate memory for dentry descriptor
	458	req.type = KMEM_VFS_DENTRY;
	459	req.size = sizeof(vfs_dentry_t);
	460	req.flags = AF_KERNEL \| AF_ZERO;
	461	dentry = (vfs_dentry_t *)kmem_alloc( &req );
	462
[459]	463	if( dentry == NULL ) return ENOMEM;
[437]	464
[1]	465	// initialize dentry descriptor
[23]	466
[1]	467	dentry->ctx = ctx;
	468	dentry->length = length;
	469	dentry->parent = parent;
	470	strcpy( dentry->name , name );
	471
[438]	472	#if( DEBUG_VFS_DENTRY_CREATE & 1 )
[437]	473	cycle = (uint32_t)hal_get_cycles();
[438]	474	if( DEBUG_VFS_DENTRY_CREATE < cycle )
[437]	475	printk("\n[DBG] %s : dentry initialised\n", __FUNCTION__ );
	476	#endif
	477
[23]	478	// register dentry in hash table rooted in parent inode
[459]	479	error = xhtab_insert( XPTR( local_cxy , &parent->children ),
	480	name,
	481	XPTR( local_cxy , &dentry->list ) );
[23]	482
[459]	483	if( error ) return EINVAL;
	484
[438]	485	#if( DEBUG_VFS_DENTRY_CREATE & 1 )
[437]	486	cycle = (uint32_t)hal_get_cycles();
[438]	487	if( DEBUG_VFS_DENTRY_CREATE < cycle )
[437]	488	printk("\n[DBG] %s : dentry registerd in htab\n", __FUNCTION__ );
	489	#endif
	490
[23]	491	// return extended pointer on dentry
[1]	492	*dentry_xp = XPTR( local_cxy , dentry );
	493
[438]	494	#if DEBUG_VFS_DENTRY_CREATE
[433]	495	cycle = (uint32_t)hal_get_cycles();
[438]	496	if( DEBUG_VFS_DENTRY_CREATE < cycle )
[459]	497	printk("\n[DBG] %s : thread %x in process %x exit for <%s> / dentry %x / cycle %d\n",
	498	__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, name, dentry, cycle );
[433]	499	#endif
[296]	500
[1]	501	return 0;
	502
	503	} // end vfs_dentry_create()
	504
[459]	505	///////////////////////////////////////////////////
	506	error_t vfs_dentry_destroy( vfs_dentry_t * dentry )
[1]	507	{
[459]	508	error_t error;
[1]	509
[459]	510	assert( (dentry->refcount == 0) , __FUNCTION__ , "dentry refcount non zero\n" );
	511
	512	// get pointer on parent inode
	513	vfs_inode_t * parent = dentry->parent;
	514
	515	// remove this dentry from parent inode htab
	516	error = xhtab_remove( XPTR( local_cxy , &parent->children ),
	517	dentry->name,
	518	XPTR( local_cxy , &dentry->list ) );
	519
	520	if( error ) return EINVAL;
	521
	522	// release memory allocated to dentry
[1]	523	kmem_req_t req;
	524	req.ptr = dentry;
	525	req.type = KMEM_VFS_DENTRY;
	526	kmem_free( &req );
[459]	527
	528	return 0;
[1]	529	}
	530
	531
[188]	532
[1]	533	//////////////////////////////////////////////////////////////////////////////////////////
	534	// File descriptor related functions
	535	//////////////////////////////////////////////////////////////////////////////////////////
	536
[23]	537	/////////////////////////////////////////////
	538	error_t vfs_file_create( vfs_inode_t * inode,
	539	uint32_t attr,
	540	xptr_t * file_xp )
	541	{
	542	vfs_file_t * file;
	543	kmem_req_t req;
	544
	545	// allocate memory for new file descriptor
	546	req.type = KMEM_VFS_FILE;
	547	req.size = sizeof(vfs_file_t);
	548	req.flags = AF_KERNEL \| AF_ZERO;
	549	file = (vfs_file_t *)kmem_alloc( &req );
	550
	551	if( file == NULL ) return ENOMEM;
	552
	553	// initializes new file descriptor
	554	file->gc = 0;
	555	file->type = inode->type;
	556	file->attr = attr;
	557	file->offset = 0;
[337]	558	file->refcount = 1;
[23]	559	file->inode = inode;
	560	file->ctx = inode->ctx;
	561	file->mapper = inode->mapper;
	562
	563	remote_rwlock_init( XPTR( local_cxy , &file->lock ) );
	564
	565	*file_xp = XPTR( local_cxy , file );
[459]	566
	567	#if DEBUG_VFS_OPEN
	568	uint32_t cycle = (uint32_t)hal_get_cycles();
	569	if( DEBUG_VFS_OPEN < cycle )
	570	printk("\n[DBG] %s : thread %x in process %x created file %x in cluster %x / cycle %d\n",
	571	__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, file, local_cxy, cycle );
	572	#endif
	573
[23]	574	return 0;
	575
	576	} // end vfs_file_create()
	577
	578	///////////////////////////////////////////
	579	void vfs_file_destroy( vfs_file_t * file )
	580	{
	581	if( file->refcount )
	582	{
[492]	583	assert( false , "refcount non zero\n" );
[23]	584	}
	585
	586	kmem_req_t req;
	587	req.ptr = file;
	588	req.type = KMEM_VFS_FILE;
	589	kmem_free( &req );
	590
[459]	591	#if DEBUG_VFS_CLOSE
	592	uint32_t cycle = (uint32_t)hal_get_cycles();
	593	if( DEBUG_VFS_CLOSE < cycle )
	594	printk("\n[DBG] %s : thread %x in process %x deleted file %x in cluster %x / cycle %d\n",
	595	__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, file, local_cxy, cycle );
	596	#endif
	597
[23]	598	} // end vfs_file_destroy()
	599
	600
[1]	601	////////////////////////////////////////
	602	void vfs_file_count_up( xptr_t file_xp )
	603	{
	604	// get file cluster and local pointer
	605	cxy_t file_cxy = GET_CXY( file_xp );
[459]	606	vfs_file_t * file_ptr = GET_PTR( file_xp );
[1]	607
	608	// atomically increment count
	609	hal_remote_atomic_add( XPTR( file_cxy , &file_ptr->refcount ) , 1 );
	610	}
	611
	612	//////////////////////////////////////////
	613	void vfs_file_count_down( xptr_t file_xp )
	614	{
	615	// get file cluster and local pointer
	616	cxy_t file_cxy = GET_CXY( file_xp );
[459]	617	vfs_file_t * file_ptr = GET_PTR( file_xp );
[1]	618
	619	// atomically decrement count
	620	hal_remote_atomic_add( XPTR( file_cxy , &file_ptr->refcount ) , -1 );
	621	}
	622
[23]	623	//////////////////////////////////////////////////////////////////////////////////////////
	624	// File access related functions
	625	//////////////////////////////////////////////////////////////////////////////////////////
	626
[407]	627	//////////////////////////////////////
	628	error_t vfs_open( process_t * process,
	629	char * path,
	630	uint32_t flags,
	631	uint32_t mode,
	632	xptr_t * new_file_xp,
	633	uint32_t * new_file_id )
[1]	634	{
[23]	635	error_t error;
	636	xptr_t inode_xp; // extended pointer on target inode
	637	cxy_t inode_cxy; // inode cluster identifier
	638	vfs_inode_t * inode_ptr; // inode local pointer
	639	uint32_t file_attr; // file descriptor attributes
	640	uint32_t lookup_mode; // lookup working mode
	641	xptr_t file_xp; // extended pointer on created file descriptor
	642	uint32_t file_id; // created file descriptor index in reference fd_array
[1]	643
[473]	644	assert( (mode == 0), __FUNCTION__,
	645	"the mode parameter is not supported yet\n" );
	646
[438]	647	#if DEBUG_VFS_OPEN
[433]	648	uint32_t cycle = (uint32_t)hal_get_cycles();
[438]	649	if( DEBUG_VFS_OPEN < cycle )
[459]	650	printk("\n[DBG] %s : thread %x in process %x enter for <%s> / cycle %d\n",
	651	__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, path, cycle );
[433]	652	#endif
[101]	653
[23]	654	// compute lookup working mode
	655	lookup_mode = VFS_LOOKUP_OPEN;
	656	if( (flags & O_DIR ) ) lookup_mode \|= VFS_LOOKUP_DIR;
	657	if( (flags & O_CREAT ) ) lookup_mode \|= VFS_LOOKUP_CREATE;
	658	if( (flags & O_EXCL ) ) lookup_mode \|= VFS_LOOKUP_EXCL;
	659
	660	// compute attributes for the created file
	661	file_attr = 0;
[407]	662	if( (flags & O_RDONLY ) == 0 ) file_attr \|= FD_ATTR_WRITE_ENABLE;
	663	if( (flags & O_WRONLY ) == 0 ) file_attr \|= FD_ATTR_READ_ENABLE;
[23]	664	if( (flags & O_SYNC ) ) file_attr \|= FD_ATTR_SYNC;
	665	if( (flags & O_APPEND ) ) file_attr \|= FD_ATTR_APPEND;
	666	if( (flags & O_CLOEXEC) ) file_attr \|= FD_ATTR_CLOSE_EXEC;
[1]	667
[23]	668	// get extended pointer on target inode
[407]	669	error = vfs_lookup( process->vfs_cwd_xp , path , lookup_mode , &inode_xp );
[23]	670
	671	if( error ) return error;
	672
	673	// get target inode cluster and local pointer
	674	inode_cxy = GET_CXY( inode_xp );
[473]	675	inode_ptr = GET_PTR( inode_xp );
[23]	676
	677	// create a new file descriptor in cluster containing inode
	678	if( inode_cxy == local_cxy ) // target cluster is local
[1]	679	{
[23]	680	error = vfs_file_create( inode_ptr , file_attr , &file_xp );
[1]	681	}
[23]	682	else // target cluster is remote
	683	{
	684	rpc_vfs_file_create_client( inode_cxy , inode_ptr , file_attr , &file_xp , &error );
	685	}
[1]	686
[23]	687	if( error ) return error;
[1]	688
[407]	689	// allocate and register a new file descriptor index in reference process
	690	error = process_fd_register( process , file_xp , &file_id );
[1]	691
[23]	692	if( error ) return error;
[1]	693
[438]	694	#if DEBUG_VFS_OPEN
[433]	695	cycle = (uint32_t)hal_get_cycles();
[438]	696	if( DEBUG_VFS_OPEN < cycle )
[459]	697	printk("\n[DBG] %s : thread %x in process %x exit for <%s> / fdid %d / cluster %x / cycle %d\n",
	698	__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, path,
	699	file_id, GET_CXY( file_xp ), cycle );
[433]	700	#endif
[238]	701
[23]	702	// success
	703	*new_file_xp = file_xp;
	704	*new_file_id = file_id;
	705	return 0;
[1]	706
[23]	707	} // end vfs_open()
	708
[407]	709	//////////////////////////////////////
	710	int vfs_user_move( bool_t to_buffer,
	711	xptr_t file_xp,
	712	void * buffer,
	713	uint32_t size )
[23]	714	{
[492]	715	assert( ( file_xp != XPTR_NULL ) , "file_xp == XPTR_NULL" );
[23]	716
	717	cxy_t file_cxy; // remote file descriptor cluster
	718	vfs_file_t * file_ptr; // remote file descriptor local pointer
	719	vfs_inode_type_t inode_type;
	720	uint32_t file_offset; // current offset in file
	721	mapper_t * mapper;
	722	error_t error;
	723
	724	// get cluster and local pointer on remote file descriptor
	725	file_cxy = GET_CXY( file_xp );
[473]	726	file_ptr = GET_PTR( file_xp );
[23]	727
	728	// get inode type from remote file descriptor
	729	inode_type = hal_remote_lw( XPTR( file_cxy , &file_ptr->type ) );
	730
[492]	731	assert( (inode_type == INODE_TYPE_FILE) ,
[407]	732	"inode type is not INODE_TYPE_FILE" );
[23]	733
[407]	734	// get mapper pointer and file offset from file descriptor
	735	file_offset = hal_remote_lw( XPTR( file_cxy , &file_ptr->offset ) );
	736	mapper = (mapper_t *)hal_remote_lpt( XPTR( file_cxy , &file_ptr->mapper ) );
[23]	737
[407]	738	// move data between mapper and buffer
	739	if( file_cxy == local_cxy )
	740	{
	741	error = mapper_move_user( mapper,
	742	to_buffer,
	743	file_offset,
	744	buffer,
	745	size );
[23]	746	}
[407]	747	else
[23]	748	{
[407]	749	rpc_mapper_move_buffer_client( file_cxy,
	750	mapper,
	751	to_buffer,
	752	true, // user buffer
	753	file_offset,
	754	(uint64_t)(intptr_t)buffer,
	755	size,
	756	&error );
	757	}
	758
	759	if( error ) return -1;
	760	else return size;
	761
[313]	762	} // end vfs_user_move()
[23]	763
[317]	764	////////////////////////////////////////////
	765	error_t vfs_kernel_move( bool_t to_buffer,
	766	xptr_t file_xp,
	767	xptr_t buffer_xp,
	768	uint32_t size )
	769	{
[492]	770	assert( ( file_xp != XPTR_NULL ) , "file_xp == XPTR_NULL" );
[317]	771
	772	cxy_t file_cxy; // remote file descriptor cluster
	773	vfs_file_t * file_ptr; // remote file descriptor local pointer
	774	vfs_inode_type_t inode_type;
	775	uint32_t file_offset; // current offset in file
	776	mapper_t * mapper;
	777	error_t error;
	778
	779	// get cluster and local pointer on remote file descriptor
	780	file_cxy = GET_CXY( file_xp );
[473]	781	file_ptr = GET_PTR( file_xp );
[317]	782
	783	// get inode type from remote file descriptor
	784	inode_type = hal_remote_lw( XPTR( file_cxy , &file_ptr->type ) );
	785
	786	// action depends on inode type
	787	if( inode_type == INODE_TYPE_FILE )
	788	{
	789	// get mapper pointer and file offset from file descriptor
	790	file_offset = hal_remote_lw( XPTR( file_cxy , &file_ptr->offset ) );
	791	mapper = (mapper_t *)hal_remote_lpt( XPTR( file_cxy , &file_ptr->mapper ) );
	792
	793	// move data between mapper and buffer
	794	if( file_cxy == local_cxy )
	795	{
	796	error = mapper_move_kernel( mapper,
	797	to_buffer,
	798	file_offset,
	799	buffer_xp,
	800	size );
	801	}
	802	else
	803	{
	804	rpc_mapper_move_buffer_client( file_cxy,
	805	mapper,
	806	to_buffer,
	807	false, // kernel buffer
	808	file_offset,
	809	buffer_xp,
	810	size,
	811	&error );
	812	}
	813
	814	if( error ) return -1;
	815	else return 0;
	816	}
	817	else
	818	{
	819	printk("\n[ERROR] in %s : inode is not a file", __FUNCTION__ );
	820	return -1;
	821	}
	822	} // end vfs_kernel_move()
	823
[23]	824	//////////////////////////////////////
	825	error_t vfs_lseek( xptr_t file_xp,
	826	uint32_t offset,
	827	uint32_t whence,
	828	uint32_t * new_offset )
	829	{
[266]	830	xptr_t offset_xp;
	831	xptr_t lock_xp;
	832	cxy_t file_cxy;
	833	vfs_file_t * file_ptr;
	834	vfs_inode_t * inode_ptr;
	835	uint32_t new;
	836
[492]	837	assert( (file_xp != XPTR_NULL) , "file_xp == XPTR_NULL" );
[266]	838
	839	// get cluster and local pointer on remote file descriptor
	840	file_cxy = GET_CXY( file_xp );
[473]	841	file_ptr = GET_PTR( file_xp );
[266]	842
	843	// build extended pointers on lock and offset
	844	offset_xp = XPTR( file_cxy , &file_ptr->offset );
	845	lock_xp = XPTR( file_cxy , &file_ptr->lock );
	846
	847	// take file descriptor lock
	848	remote_rwlock_wr_lock( lock_xp );
	849
	850	if ( whence == SEEK_CUR ) // new = current + offset
	851	{
	852	new = hal_remote_lw( offset_xp ) + offset;
	853	}
	854	else if ( whence == SEEK_SET ) // new = offset
	855	{
	856	new = offset;
	857	}
	858	else if ( whence == SEEK_END ) // new = size + offset
	859	{
	860	// get local pointer on remote inode
	861	inode_ptr = (vfs_inode_t *)hal_remote_lpt( XPTR( file_cxy , &file_ptr->inode ) );
	862
	863	new = hal_remote_lw( XPTR( file_cxy , &inode_ptr->size ) ) + offset;
	864	}
	865	else
	866	{
	867	printk("\n[ERROR] in %s : illegal whence value\n", __FUNCTION__ );
	868	remote_rwlock_wr_unlock( lock_xp );
	869	return -1;
	870	}
	871
	872	// set new offset
	873	hal_remote_sw( offset_xp , new );
	874
	875	// release file descriptor lock
	876	remote_rwlock_wr_unlock( lock_xp );
	877
	878	// success
[271]	879	if ( new_offset != NULL )
	880	*new_offset = new;
[1]	881	return 0;
	882
[23]	883	} // vfs_lseek()
	884
	885	///////////////////////////////////
	886	error_t vfs_close( xptr_t file_xp,
	887	uint32_t file_id )
[1]	888	{
[459]	889	cluster_t * cluster; // local pointer on local cluster
	890	cxy_t file_cxy; // cluster containing the file descriptor.
	891	vfs_file_t * file_ptr; // local ponter on file descriptor
	892	cxy_t owner_cxy; // process owner cluster
	893	lpid_t lpid; // process local index
	894	xptr_t root_xp; // root of list of process copies
	895	xptr_t lock_xp; // lock protecting the list of copies
	896	xptr_t iter_xp; // iterator on list of process copies
	897	xptr_t process_xp; // extended pointer on one process copy
	898	cxy_t process_cxy; // process copy cluster
	899	process_t * process_ptr; // process copy local pointer
	900
[492]	901	assert( (file_xp != XPTR_NULL) , "file_xp == XPTR_NULL" );
[23]	902
[492]	903	assert( (file_id < CONFIG_PROCESS_FILE_MAX_NR) , "illegal file_id" );
[23]	904
	905	thread_t * this = CURRENT_THREAD;
	906	process_t * process = this->process;
	907
[459]	908	#if DEBUG_VFS_CLOSE
	909	uint32_t cycle = (uint32_t)hal_get_cycles();
	910	if( DEBUG_VFS_CLOSE < cycle )
	911	printk("\n[DBG] %s : thread %x in process %x enter / fdid %d / cycle %d\n",
	912	__FUNCTION__, this->trdid, process->pid, file_id, cycle );
	913	#endif
[1]	914
[23]	915	// get local pointer on local cluster manager
[459]	916	cluster = LOCAL_CLUSTER;
[23]	917
	918	// get owner process cluster and lpid
[459]	919	owner_cxy = CXY_FROM_PID( process->pid );
	920	lpid = LPID_FROM_PID( process->pid );
[23]	921
	922	// get extended pointers on copies root and lock
[459]	923	root_xp = XPTR( owner_cxy , &cluster->pmgr.copies_root[lpid] );
	924	lock_xp = XPTR( owner_cxy , &cluster->pmgr.copies_lock[lpid] );
[23]	925
[459]	926	// 1) loop on the process descriptor copies to reset all fd_array[file_id] entries
	927
	928	// take the lock protecting the list of copies
[23]	929	remote_spinlock_lock( lock_xp );
	930
	931	XLIST_FOREACH( root_xp , iter_xp )
[1]	932	{
[459]	933	process_xp = XLIST_ELEMENT( iter_xp , process_t , copies_list );
	934	process_cxy = GET_CXY( process_xp );
	935	process_ptr = GET_PTR( process_xp );
[1]	936
[459]	937	#if (DEBUG_VFS_CLOSE & 1 )
	938	if( DEBUG_VFS_CLOSE < cycle )
	939	printk("\n[DBG] %s : reset fd_array[%d] for process %x in cluster %x\n",
	940	__FUNCTION__, file_id, process_ptr, process_cxy );
	941	#endif
[23]	942
[459]	943	// fd_array lock is required for atomic write of a 64 bits word
	944	// xptr_t fd_array_lock_xp = XPTR( process_cxy , &process_ptr->fd_array.lock );
	945
	946	xptr_t entry_xp = XPTR( process_cxy , &process_ptr->fd_array.array[file_id] );
	947
	948	// remote_rwlock_wr_lock( fd_array_lock_xp );
	949
[23]	950	hal_remote_swd( entry_xp , XPTR_NULL );
[459]	951
	952	// remote_rwlock_wr_unlock( fd_array_lock_xp );
[23]	953
[459]	954	vfs_file_count_down( file_xp );
	955
[124]	956	hal_fence();
[23]	957	}
	958
[459]	959	// release the lock protecting the list of copies
	960	remote_spinlock_unlock( lock_xp );
	961
	962	#if (DEBUG_VFS_CLOSE & 1)
	963	if( DEBUG_VFS_CLOSE < cycle )
	964	printk("\n[DBG] %s : thread %x in process %x reset all fd-array copies\n",
	965	__FUNCTION__, this->trdid, process->pid );
	966	#endif
	967
[23]	968	// 2) release memory allocated to file descriptor in remote cluster
[459]	969
	970	// get cluster and local pointer on remote file descriptor
	971	file_cxy = GET_CXY( file_xp );
	972	file_ptr = GET_PTR( file_xp );
	973
[23]	974	if( file_cxy == local_cxy ) // file cluster is local
[1]	975	{
[23]	976	vfs_file_destroy( file_ptr );
	977	}
	978	else // file cluster is local
	979	{
	980	rpc_vfs_file_destroy_client( file_cxy , file_ptr );
	981	}
[1]	982
[459]	983	#if DEBUG_VFS_CLOSE
	984	cycle = (uint32_t)hal_get_cycles();
	985	if( DEBUG_VFS_CLOSE < cycle )
	986	printk("\n[DBG] %s : thread %x in process %x exit / fdid %d closed / cycle %d\n",
	987	__FUNCTION__, this->trdid, process->pid, file_id, cycle );
	988	#endif
	989
[23]	990	return 0;
[1]	991
[23]	992	} // end vfs_close()
[1]	993
	994	////////////////////////////////////
[23]	995	error_t vfs_unlink( xptr_t cwd_xp,
	996	char * path )
[1]	997	{
[492]	998	assert( false , "not implemented cwd_xp %x, path <%s> \n",
	999	cwd_xp, path );
[1]	1000	return 0;
[407]	1001	}
[1]	1002
[407]	1003	////////////////////////////////////////
	1004	error_t vfs_stat( xptr_t file_xp,
	1005	struct stat * k_stat )
[1]	1006	{
[492]	1007	assert( false , "not implemented file_xp: %x, k_stat ptr %x\n",
	1008	file_xp, k_stat );
[1]	1009	return 0;
	1010	}
	1011
[407]	1012	/////////////////////////////////////////////
	1013	error_t vfs_readdir( xptr_t file_xp,
	1014	struct dirent * k_dirent )
[1]	1015	{
[492]	1016	assert( false , "not implemented file_xp: %x, k_dirent ptr %x\n",
	1017	file_xp, k_dirent );
[1]	1018	return 0;
	1019	}
	1020
	1021	//////////////////////////////////////
[23]	1022	error_t vfs_mkdir( xptr_t file_xp,
	1023	char * path,
	1024	uint32_t mode )
[1]	1025	{
[492]	1026	assert( false , "not implemented file_xp: %x, path <%s>, mode: %x\n",
	1027	file_xp, path, mode );
[1]	1028	return 0;
	1029	}
	1030
[23]	1031	////////////////////////////////////
	1032	error_t vfs_rmdir( xptr_t file_xp,
	1033	char * path )
[1]	1034	{
[492]	1035	assert( false , "not implemented file_xp: %x, path <%s>\n",
	1036	file_xp, path );
[1]	1037	return 0;
	1038	}
	1039
[23]	1040	///////////////////////////////////
	1041	error_t vfs_chdir( xptr_t cwd_xp,
	1042	char * path )
[1]	1043	{
[23]	1044	error_t error;
	1045	xptr_t inode_xp; // extended pointer on target inode
	1046	cxy_t inode_cxy; // target inode cluster identifier
	1047	vfs_inode_t * inode_ptr; // target inode local pointer
	1048	uint32_t mode; // lookup working mode
	1049	vfs_inode_type_t inode_type; // target inode type
	1050
	1051	// set lookup working mode
	1052	mode = 0;
	1053
	1054	// get extended pointer on target inode
	1055	error = vfs_lookup( cwd_xp , path , mode , &inode_xp );
	1056
	1057	if( error ) return error;
	1058
	1059	// get inode cluster and local pointer
	1060	inode_cxy = GET_CXY( inode_xp );
[473]	1061	inode_ptr = GET_PTR( inode_xp );
[23]	1062
	1063	// get inode type from remote file
	1064	inode_type = hal_remote_lw( XPTR( inode_cxy , &inode_ptr->type ) );
	1065
	1066	if( inode_type != INODE_TYPE_DIR )
	1067	{
	1068	CURRENT_THREAD->errno = ENOTDIR;
	1069	return -1;
	1070	}
	1071
[492]	1072	assert( false , "not implemented\n" );
[1]	1073	return 0;
	1074	}
	1075
[23]	1076	///////////////////////////////////
	1077	error_t vfs_chmod( xptr_t cwd_xp,
	1078	char * path,
	1079	uint32_t rights )
[1]	1080	{
[23]	1081	error_t error;
	1082	xptr_t inode_xp; // extended pointer on target inode
	1083	cxy_t inode_cxy; // inode cluster identifier
	1084	vfs_inode_t * inode_ptr; // inode local pointer
	1085	vfs_inode_type_t inode_type; // target inode type
	1086
	1087	// set lookup working mode
[473]	1088	assert( (rights == 0), __FUNCTION__,
	1089	"access rights non implemented yet\n" );
[23]	1090
	1091	// get extended pointer on target inode
[473]	1092	error = vfs_lookup( cwd_xp , path , 0 , &inode_xp );
[23]	1093
	1094	if( error ) return error;
	1095
	1096	// get inode cluster and local pointer
	1097	inode_cxy = GET_CXY( inode_xp );
[473]	1098	inode_ptr = GET_PTR( inode_xp );
[23]	1099
	1100	// get inode type from remote inode
	1101	inode_type = hal_remote_lw( XPTR( inode_cxy , &inode_ptr->type ) );
	1102
	1103
[492]	1104	assert( false , "not implemented\n" );
[1]	1105	return 0;
	1106	}
	1107
[23]	1108	///////////////////////////////////
	1109	error_t vfs_mkfifo( xptr_t cwd_xp,
	1110	char * path,
	1111	uint32_t rights )
	1112	{
[492]	1113	assert( false , "not implemented cwd_xp: %x, path <%s>, rights %x\n",
	1114	cwd_xp, path, rights );
[23]	1115	return 0;
	1116	}
[1]	1117
	1118
	1119
[188]	1120	//////////////////////////////////////////////////////////////////////////////////////////
[1]	1121	// Inode Tree functions
	1122	//////////////////////////////////////////////////////////////////////////////////////////
	1123
[188]	1124	/////////////////////////////////
[484]	1125	cxy_t vfs_cluster_random_select( void )
[188]	1126	{
	1127	uint32_t x_size = LOCAL_CLUSTER->x_size;
	1128	uint32_t y_size = LOCAL_CLUSTER->y_size;
	1129	uint32_t y_width = LOCAL_CLUSTER->y_width;
	1130	uint32_t index = ( hal_get_cycles() + hal_get_gid() ) % (x_size * y_size);
	1131	uint32_t x = index / y_size;
	1132	uint32_t y = index % y_size;
	1133
	1134	return (x<<y_width) + y;
	1135	}
	1136
	1137
	1138	//////////////////////////////////////////////////////////////////////////
	1139	// This static function is called by the vfs_display() function.
[337]	1140	// that is supposed to take the TXT0 lock.
[188]	1141	//////////////////////////////////////////////////////////////////////////
	1142	static void vfs_recursive_display( xptr_t inode_xp,
	1143	xptr_t name_xp,
	1144	uint32_t indent )
	1145	{
	1146	cxy_t inode_cxy;
	1147	vfs_inode_t * inode_ptr;
	1148	vfs_inode_type_t inode_type;
[204]	1149	xptr_t children_xp; // extended pointer on children xhtab
[188]	1150
[204]	1151	xptr_t child_dentry_xp;
	1152	cxy_t child_dentry_cxy;
	1153	vfs_dentry_t * child_dentry_ptr;
	1154	xptr_t child_inode_xp;
	1155	xptr_t child_dentry_name_xp;
[188]	1156
	1157	char name[CONFIG_VFS_MAX_NAME_LENGTH];
	1158
	1159	char * indent_str[] = { "", // level 0
	1160	" ", // level 1
	1161	" ", // level 2
	1162	" ", // level 3
	1163	" ", // level 4
	1164	" ", // level 5
	1165	" ", // level 6
	1166	" ", // level 7
	1167	" ", // level 8
	1168	" ", // level 9
	1169	" ", // level 10
	1170	" ", // level 11
	1171	" ", // level 12
	1172	" ", // level 13
	1173	" ", // level 14
	1174	" " }; // level 15
	1175
[492]	1176	assert( (inode_xp != XPTR_NULL) , "inode_xp cannot be NULL\n" );
	1177	assert( (name_xp != XPTR_NULL) , "name_xp cannot be NULL\n" );
	1178	assert( (indent < 16) , "depth cannot be larger than 15\n" );
[188]	1179
	1180	// get inode cluster and local pointer
	1181	inode_cxy = GET_CXY( inode_xp );
[473]	1182	inode_ptr = GET_PTR( inode_xp );
[188]	1183
	1184	// get inode type
	1185	inode_type = hal_remote_lw( XPTR( inode_cxy , &inode_ptr->type ) );
	1186
[367]	1187	// get local pointer on associated mapper
	1188	mapper_t * mapper_ptr = hal_remote_lpt( XPTR( inode_cxy , &inode_ptr->mapper ) );
	1189
[188]	1190	// make a local copy of node name
	1191	hal_remote_strcpy( XPTR( local_cxy , name ) , name_xp );
	1192
	1193	// display inode
[407]	1194	nolock_printk("%s%s <%s> : inode = %x / mapper = %x / cluster %x\n",
[367]	1195	indent_str[indent], vfs_inode_type_str( inode_type ), name,
[407]	1196	inode_ptr , mapper_ptr , inode_cxy );
[188]	1197
	1198	// scan directory entries
	1199	if( inode_type == INODE_TYPE_DIR )
	1200	{
	1201	// get extended pointer on directory entries xhtab
[204]	1202	children_xp = XPTR( inode_cxy , &inode_ptr->children );
[188]	1203
	1204	// get xhtab lock
[204]	1205	xhtab_read_lock( children_xp );
[188]	1206
	1207	// get first dentry from xhtab
[204]	1208	child_dentry_xp = xhtab_get_first( children_xp );
[188]	1209
[204]	1210	while( child_dentry_xp != XPTR_NULL )
[188]	1211	{
	1212	// get dentry cluster and local pointer
[204]	1213	child_dentry_cxy = GET_CXY( child_dentry_xp );
[473]	1214	child_dentry_ptr = GET_PTR( child_dentry_xp );
[188]	1215
	1216	// get extended pointer on child inode
[204]	1217	child_inode_xp = hal_remote_lwd( XPTR( child_dentry_cxy,
	1218	&child_dentry_ptr->child_xp ) );
[188]	1219
	1220	// get extended pointer on dentry name
[204]	1221	child_dentry_name_xp = XPTR( child_dentry_cxy , &child_dentry_ptr->name );
[188]	1222
	1223	// recursive call on child inode
[204]	1224	vfs_recursive_display( child_inode_xp,
	1225	child_dentry_name_xp,
	1226	indent+1 );
[188]	1227
	1228	// get next dentry
[204]	1229	child_dentry_xp = xhtab_get_next( children_xp );
[188]	1230	}
	1231
	1232	// release xhtab lock
[204]	1233	xhtab_read_unlock( children_xp );
[188]	1234	}
	1235	} // end vfs_recursive_display()
	1236
	1237	///////////////////////////////////
	1238	void vfs_display( xptr_t inode_xp )
	1239	{
[204]	1240	xptr_t name_xp;
[188]	1241	xptr_t dentry_xp;
	1242	cxy_t dentry_cxy;
	1243	vfs_dentry_t * dentry_ptr;
[337]	1244	uint32_t save_sr;
[188]	1245
	1246	// get target inode cluster and local pointer
	1247	cxy_t inode_cxy = GET_CXY( inode_xp );
[473]	1248	vfs_inode_t * inode_ptr = GET_PTR( inode_xp );
[188]	1249
	1250	// get extended pointer on associated dentry
[367]	1251	dentry_xp = hal_remote_lwd( XPTR( inode_cxy , &inode_ptr->parent_xp ) );
[188]	1252
	1253	// check if target inode is the File System root
	1254	if( dentry_xp == XPTR_NULL )
	1255	{
	1256	// build extended pointer on root name
	1257	name_xp = XPTR( local_cxy , "/" );
	1258	}
	1259	else
	1260	{
	1261	// get dentry cluster and local pointer
	1262	dentry_cxy = GET_CXY( dentry_xp );
[473]	1263	dentry_ptr = GET_PTR( dentry_xp );
[188]	1264
	1265	// get extended pointer on dentry name
	1266	name_xp = XPTR( dentry_cxy , &dentry_ptr->name );
	1267	}
	1268
[337]	1269	// get pointers on TXT0 chdev
[407]	1270	xptr_t txt0_xp = chdev_dir.txt_tx[0];
[337]	1271	cxy_t txt0_cxy = GET_CXY( txt0_xp );
	1272	chdev_t * txt0_ptr = GET_PTR( txt0_xp );
	1273
	1274	// get extended pointer on remote TXT0 chdev lock
	1275	xptr_t lock_xp = XPTR( txt0_cxy , &txt0_ptr->wait_lock );
	1276
	1277	// get TXT0 lock in busy waiting mode
	1278	remote_spinlock_lock_busy( lock_xp , &save_sr );
	1279
[188]	1280	// print header
[401]	1281	nolock_printk("\n***** file system state\n\n");
[188]	1282
	1283	// call recursive function
[473]	1284	vfs_recursive_display( inode_xp , name_xp , 0 );
[188]	1285
[337]	1286	// release lock
	1287	remote_spinlock_unlock_busy( lock_xp , save_sr );
	1288
[204]	1289	} // end vfs_display()
[188]	1290
[1]	1291	//////////////////////////////////////////////////////////////////////////////////////////
[23]	1292	// This function is used by the vfs_lookup() function.
[1]	1293	// It takes an extended pointer on a remote inode (parent directory inode),
	1294	// and check access_rights violation for the calling thread.
	1295	// It can be used by any thread running in any cluster.
	1296	//////////////////////////////////////////////////////////////////////////////////////////
	1297	// @ inode_xp : extended pointer on inode.
	1298	// @ client_uid : client thread user ID
	1299	// @ client_gid : client thread group ID
	1300	// @ return true if access rights are violated.
	1301	//////////////////////////////////////////////////////////////////////////////////////////
	1302	bool_t vfs_access_denied( xptr_t inode_xp,
	1303	uint32_t client_uid,
	1304	uint32_t client_gid )
	1305	{
	1306	// get found inode cluster and local pointer
	1307	cxy_t inode_cxy = GET_CXY( inode_xp );
[473]	1308	vfs_inode_t * inode_ptr = GET_PTR( inode_xp );
[1]	1309
	1310	// get inode access mode, UID, and GID
	1311	// TODO uint32_t mode = hal_remote_lw( XPTR( inode_cxy , &inode_ptr->mode ) );
	1312	uid_t uid = hal_remote_lw( XPTR( inode_cxy , &inode_ptr->uid ) );
	1313	gid_t gid = hal_remote_lw( XPTR( inode_cxy , &inode_ptr->gid ) );
	1314
	1315	// FIXME : me must use mode
	1316	if( (uid == client_uid) \|\| (gid == client_gid) ) return false;
	1317	else return true;
	1318	}
	1319
	1320	//////////////////////////////////////////////////////////////////////////////////////////
	1321	// This static function is used by the vfs_lookup() function.
[204]	1322	// It takes an extended pointer on a remote parent directory inode, a directory
[1]	1323	// entry name, and returns an extended pointer on the child inode.
	1324	// It can be used by any thread running in any cluster.
	1325	//////////////////////////////////////////////////////////////////////////////////////////
	1326	// @ parent_xp : extended pointer on parent inode in remote cluster.
	1327	// @ name : dentry name
	1328	// @ child_xp : [out] buffer for extended pointer on child inode.
	1329	// @ return true if success / return false if not found.
	1330	//////////////////////////////////////////////////////////////////////////////////////////
	1331	static bool_t vfs_get_child( xptr_t parent_xp,
	1332	char * name,
	1333	xptr_t * child_xp )
	1334	{
	1335	xptr_t xhtab_xp; // extended pointer on hash table containing children dentries
	1336	xptr_t dentry_xp; // extended pointer on children dentry
	1337
	1338	// get parent inode cluster and local pointer
	1339	cxy_t parent_cxy = GET_CXY( parent_xp );
[473]	1340	vfs_inode_t * parent_ptr = GET_PTR( parent_xp );
[1]	1341
	1342	// get extended pointer on hash table of children directory entries
	1343	xhtab_xp = XPTR( parent_cxy , &parent_ptr->children );
	1344
	1345	// search extended pointer on matching dentry
	1346	dentry_xp = xhtab_lookup( xhtab_xp , name );
	1347
	1348	if( dentry_xp == XPTR_NULL ) return false;
	1349
	1350	// get dentry cluster and local pointer
	1351	cxy_t dentry_cxy = GET_CXY( dentry_xp );
[473]	1352	vfs_dentry_t * dentry_ptr = GET_PTR( dentry_xp );
[1]	1353
	1354	// return child inode
[101]	1355	*child_xp = (xptr_t)hal_remote_lwd( XPTR( dentry_cxy , &dentry_ptr->child_xp ) );
[1]	1356	return true;
	1357
[204]	1358	} // end vfs_get_child()
	1359
[1]	1360	//////////////////////////////////////////////////////////////////////////////////////////
	1361	// This static function is used by the vfs_lookup() function.
	1362	// It takes the <current> pointer on a buffer containing a complete pathname, and return
	1363	// in the <name> buffer, allocated by the caller, a single name in the path.
	1364	// It return also in the <next> pointer the next character to analyse in the path.
	1365	// Finally it returns a <last> boolean, that is true when the returned <name> is the
	1366	// last name in the path. The names are supposed to be separated by one or several '/'
	1367	// characters, that are not written in the <name> buffer.
	1368	//////////////////////////////////////////////////////////////////////////////////////////
	1369	// @ current : pointer on first character to analyse in buffer containing the path.
	1370	// @ name : [out] pointer on buffer allocated by the caller for the returned name.
	1371	// @ next : [out] pointer on next character to analyse in buffer containing the path.
	1372	// @ last : [out] true if the returned name is the last (NUL character found).
	1373	// @ return 0 if success / return EINVAL if string empty (first chracter is NUL).
	1374	//////////////////////////////////////////////////////////////////////////////////////////
	1375	static error_t vfs_get_name_from_path( char * current,
	1376	char * name,
	1377	char ** next,
	1378	bool_t * last )
	1379	{
	1380	char * ptr = current;
	1381
	1382	// skip leading '/' characters
	1383	while( *ptr == '/' ) ptr++;
	1384
	1385	// return EINVAL if string empty
	1386	if( *ptr == 0 ) return EINVAL;
	1387
	1388	// copy all characters in name until NUL or '/'
	1389	while( (ptr != 0) && (ptr !='/') ) (name++) = (ptr++);
	1390
[204]	1391	// set NUL terminating character in name buffer
	1392	*(name++) = 0;
	1393
[1]	1394	// return last an next
	1395	if( *ptr == 0 ) // last found character is NUL => last name in path
	1396	{
	1397	*last = true;
	1398	}
	1399	else // last found character is '/' => skip it
	1400	{
	1401	*last = false;
	1402	*next = ptr + 1;
	1403	}
	1404
	1405	return 0;
[204]	1406
	1407	} // end vfs_get name_from_path()
[188]	1408
[23]	1409	//////////////////////////////////////////////
	1410	error_t vfs_lookup( xptr_t cwd_xp,
	1411	char * pathname,
	1412	uint32_t mode,
	1413	xptr_t * inode_xp )
[1]	1414	{
[101]	1415	char name[CONFIG_VFS_MAX_NAME_LENGTH]; // one name in path
[1]	1416
[23]	1417	xptr_t parent_xp; // extended pointer on parent inode
	1418	cxy_t parent_cxy; // cluster for parent inode
	1419	vfs_inode_t * parent_ptr; // local pointer on parent inode
	1420	xptr_t child_xp; // extended pointer on child inode
	1421	cxy_t child_cxy; // cluster for child inode
	1422	vfs_inode_t * child_ptr; // local pointer on child inode
	1423	vfs_fs_type_t fs_type; // File system type
	1424	vfs_ctx_t * ctx_ptr; // local pointer on FS context
	1425	char * current; // current pointer on path
	1426	char * next; // next value for current pointer
	1427	bool_t last; // true when the name is the last in path
	1428	bool_t found; // true when a child has been found
[459]	1429	bool_t dir; // searched inode is a directory
	1430	bool_t create; // searched inode must be created if not found
	1431	bool_t excl; // searched inode must not exist
[23]	1432	thread_t * this; // pointer on calling thread descriptor
	1433	process_t * process; // pointer on calling process descriptor
	1434	error_t error;
[1]	1435
	1436	this = CURRENT_THREAD;
	1437	process = this->process;
	1438
[438]	1439	#if DEBUG_VFS_LOOKUP
[433]	1440	uint32_t cycle = (uint32_t)hal_get_cycles();
[438]	1441	if( DEBUG_VFS_LOOKUP < cycle )
[459]	1442	printk("\n[DBG] %s : thread %x in process %x enter for <%s> / cycle %d\n",
	1443	__FUNCTION__, this->trdid, process->pid, pathname, cycle );
[433]	1444	#endif
[380]	1445
[459]	1446	// compute lookup flags
	1447	dir = mode & VFS_LOOKUP_DIR;
	1448	create = mode & VFS_LOOKUP_CREATE;
	1449	excl = mode & VFS_LOOKUP_EXCL;
	1450
[1]	1451	// get extended pointer on first inode to search
	1452	if( pathname[0] == '/' ) parent_xp = process->vfs_root_xp;
	1453	else parent_xp = cwd_xp;
	1454
[101]	1455	// initialise other loop variables
[1]	1456	current = pathname;
	1457	next = NULL;
	1458	last = false;
	1459	child_xp = XPTR_NULL;
	1460
	1461	// take lock on parent inode
[101]	1462	vfs_inode_lock( parent_xp );
[1]	1463
[401]	1464	// sequencially loop on nodes in pathname
[459]	1465	// load from device if one node in path not found in inode tree
[401]	1466	// exit loop when last name found (i.e. last == true)
[1]	1467	do
	1468	{
[401]	1469	// get one name from path, and "last" flag
[1]	1470	vfs_get_name_from_path( current , name , &next , &last );
	1471
[438]	1472	#if (DEBUG_VFS_LOOKUP & 1)
	1473	if( DEBUG_VFS_LOOKUP < cycle )
[459]	1474	printk("\n[DBG] %s : look for <%s> / last = %d\n",
	1475	__FUNCTION__ , name , last );
[433]	1476	#endif
[101]	1477
[204]	1478	// search a child dentry matching name in parent inode
[1]	1479	found = vfs_get_child( parent_xp,
	1480	name,
	1481	&child_xp );
	1482
[459]	1483	if (found == false ) // child not found in inode tree
[1]	1484	{
[101]	1485
[438]	1486	#if (DEBUG_VFS_LOOKUP & 1)
	1487	if( DEBUG_VFS_LOOKUP < cycle )
[459]	1488	printk("\n[DBG] %s : miss <%s> node => try to create it\n",
	1489	__FUNCTION__ , name );
[433]	1490	#endif
[459]	1491	// if a child node is not found in the inode tree,
	1492	// we introduce a new (dentry/inode) in inode tree,
	1493	// and try to find it by scanning the parent directory mapper.
	1494	// . if it is found in parent mapper:
	1495	// - if the child is a directory, the child mapper is loaded from device
	1496	// - if the child is not a directory, the search is completed
	1497	// . if it is not found in the parent mapper:
	1498	// - if ( not last or not create ) an error is reported
	1499	// - if (last and create and dir) a new directory is created
	1500	// - if (last and create and not dir) a new file is created
[407]	1501
[1]	1502	// release lock on parent inode
[101]	1503	vfs_inode_unlock( parent_xp );
[459]	1504
[238]	1505	// get parent inode FS type
[23]	1506	parent_cxy = GET_CXY( parent_xp );
[459]	1507	parent_ptr = GET_PTR( parent_xp );
	1508	ctx_ptr = (vfs_ctx_t *)hal_remote_lpt( XPTR( parent_cxy,&parent_ptr->ctx ) );
[238]	1509	fs_type = hal_remote_lw( XPTR( parent_cxy , &ctx_ptr->type ) );
[23]	1510
[238]	1511	// select a cluster for missing inode
	1512	child_cxy = vfs_cluster_random_select();
[401]	1513
[459]	1514	// insert a new child dentry/inode in inode tree
[188]	1515	error = vfs_add_child_in_parent( child_cxy,
[459]	1516	0, // type will be updated later
[23]	1517	fs_type,
	1518	parent_xp,
[222]	1519	name,
[459]	1520	NULL, // fs_type_specific inode extend
[23]	1521	&child_xp );
[1]	1522	if( error )
	1523	{
[459]	1524	printk("\n[ERROR] in %s : cannot create node %s for path <%s>\n",
	1525	__FUNCTION__ , name, pathname );
[238]	1526	return ENOMEM;
	1527	}
	1528
[459]	1529	// get child inode cluster and local pointer
	1530	child_cxy = GET_CXY( child_xp );
	1531	child_ptr = GET_PTR( child_xp );
	1532
	1533	#if (DEBUG_VFS_LOOKUP & 1)
	1534	if( DEBUG_VFS_LOOKUP < cycle )
	1535	printk("\n[DBG] %s : missing <%s> inode speculatively created / cxy %x / ptr %x\n",
	1536	__FUNCTION__ , name , child_cxy, child_ptr );
	1537	#endif
	1538	// scan parent mapper to complete the missing inode
[238]	1539	if( parent_cxy == local_cxy )
	1540	{
	1541	error = vfs_inode_load( parent_ptr,
	1542	name,
	1543	child_xp );
	1544	}
	1545	else
	1546	{
	1547	rpc_vfs_inode_load_client( parent_cxy,
	1548	parent_ptr,
	1549	name,
	1550	child_xp,
	1551	&error );
	1552	}
	1553
[459]	1554	if ( error ) // child not found in parent mapper
[238]	1555	{
[459]	1556	if( last && create && dir ) // new directory => update inode type
	1557	{
	1558	hal_remote_sw( XPTR( child_cxy, &child_ptr->type ), INODE_TYPE_DIR );
[1]	1559
[459]	1560	#if (DEBUG_VFS_LOOKUP & 1)
	1561	if( DEBUG_VFS_LOOKUP < cycle )
	1562	printk("\n[DBG] %s : created node <%s> in path %s / type DIR\n",
	1563	__FUNCTION__ , name, pathname );
	1564	#endif
[238]	1565	}
[459]	1566	else if ( last && create ) // new file => update inode type
[238]	1567	{
[459]	1568	hal_remote_sw( XPTR( child_cxy, &child_ptr->type ), INODE_TYPE_FILE );
[238]	1569
[459]	1570	#if (DEBUG_VFS_LOOKUP & 1)
	1571	if( DEBUG_VFS_LOOKUP < cycle )
	1572	printk("\n[DBG] %s : created node <%s> in path %s / type FILE\n",
	1573	__FUNCTION__ , name, pathname );
	1574	#endif
[238]	1575	}
[459]	1576	else // not last or not create => remove created node
	1577	{
	1578	printk("\n[ERROR] in %s : <%s> node not found in parent for <%s>\n",
	1579	__FUNCTION__ , name , pathname );
	1580	vfs_remove_child_from_parent( child_xp );
	1581	return ENOENT;
	1582	}
[238]	1583	}
[459]	1584	else // child found in parent
	1585	{
	1586	// load child mapper from device if child is a directory (prefetch)
	1587	if( hal_remote_lw( XPTR( child_cxy , &child_ptr->type ) ) == INODE_TYPE_DIR )
	1588	{
	1589	if( child_cxy == local_cxy )
	1590	{
	1591	error = vfs_mapper_load_all( child_ptr );
	1592	}
	1593	else
	1594	{
	1595	rpc_vfs_mapper_load_all_client( child_cxy,
	1596	child_ptr,
	1597	&error );
	1598	}
	1599	if ( error )
	1600	{
	1601	printk("\n[ERROR] in %s : cannot load <%s> from device\n",
	1602	__FUNCTION__ , name );
	1603	vfs_remove_child_from_parent( child_xp );
	1604	return EIO;
	1605	}
[238]	1606
[438]	1607	#if (DEBUG_VFS_LOOKUP & 1)
	1608	if( DEBUG_VFS_LOOKUP < cycle )
[459]	1609	printk("\n[DBG] %s : load mapper from device for node <%s> in path %s\n",
	1610	__FUNCTION__ , name, pathname );
[433]	1611	#endif
[459]	1612	}
	1613	}
[407]	1614
[459]	1615	// take lock on parent inode
	1616	vfs_inode_lock( parent_xp );
[1]	1617	}
[459]	1618	else // child found in inode tree
	1619	{
	1620
[438]	1621	#if (DEBUG_VFS_LOOKUP & 1)
	1622	if( DEBUG_VFS_LOOKUP < cycle )
[433]	1623	printk("\n[DBG] %s : found <%s> / inode %x in cluster %x\n",
	1624	__FUNCTION__ , name , GET_PTR(child_xp) , GET_CXY(child_xp) );
	1625	#endif
[459]	1626	child_ptr = GET_PTR( child_xp );
	1627	child_cxy = GET_CXY( child_xp );
	1628	parent_cxy = GET_CXY( parent_xp );
	1629	parent_ptr = GET_PTR( parent_xp );
[101]	1630
[459]	1631	if( last && (mode & VFS_LOOKUP_CREATE) && (mode & VFS_LOOKUP_EXCL) )
	1632	{
	1633	printk("\n[ERROR] in %s : node already exist <%s>\n", __FUNCTION__, name );
	1634	return EINVAL;
	1635	}
	1636	}
	1637
[380]	1638	// TODO check access rights here [AG]
[23]	1639	// error = vfs_access_denied( child_xp,
	1640	// client_uid,
	1641	// client_gid );
	1642	// if( error )
	1643	// {
[441]	1644	// printk("\n[ERROR] in %s : thread %x / permission denied for %s\n",
	1645	// __FUNCTION__ , this , name );
[23]	1646	// return EACCES;
	1647	// }
[1]	1648
[238]	1649	// take lock on child inode and release lock on parent
	1650	vfs_inode_lock( child_xp );
[101]	1651	vfs_inode_unlock( parent_xp );
[1]	1652
	1653	// update loop variables
	1654	parent_xp = child_xp;
	1655	current = next;
	1656	}
	1657	while( last == false );
	1658
[238]	1659	// release lock
	1660	vfs_inode_unlock( parent_xp );
[1]	1661
[438]	1662	#if DEBUG_VFS_LOOKUP
[433]	1663	cycle = (uint32_t)hal_get_cycles();
[438]	1664	if( DEBUG_VFS_LOOKUP < cycle )
[459]	1665	printk("\n[DBG] %s : thread %x in process %x exit for <%s>\n"
	1666	" parent %x in cluster %x / child %x in cluster %x / cycle %d\n",
	1667	__FUNCTION__ , this->trdid, process->pid, pathname,
	1668	parent_ptr, parent_cxy, child_ptr, child_cxy, cycle );
[433]	1669	#endif
[1]	1670
[238]	1671	// return searched pointer
[459]	1672	if( mode & VFS_LOOKUP_PARENT ) *inode_xp = parent_xp;
	1673	else *inode_xp = child_xp;
[1]	1674
	1675	return 0;
	1676
	1677	} // end vfs_lookup()
	1678
	1679	////////////////////////////////////////////
	1680	error_t vfs_get_path( xptr_t searched_xp,
	1681	char * buffer,
	1682	uint32_t max_size )
	1683	{
	1684	xptr_t dentry_xp; // extended pointer on current dentry
	1685	char * name; // local pointer on current dentry name
	1686	uint32_t length; // length of current dentry name
	1687	uint32_t count; // number of characters written in buffer
	1688	uint32_t index; // slot index in buffer
[23]	1689	xptr_t inode_xp; // extended pointer on
[1]	1690
	1691	// implementation note:
	1692	// we use two variables "index" and "count" because the buffer
[401]	1693	// is written in decreasing index order (from leaf to root)
[433]	1694	// TODO : handle conflict with a concurrent rename [AG]
	1695	// FIXME : handle synchro in the loop [AG]
[1]	1696
	1697	// set the NUL character in buffer / initialise buffer index and count
	1698	buffer[max_size - 1] = 0;
	1699	count = 1;
	1700	index = max_size - 2;
	1701
	1702	// initialize current inode
	1703	inode_xp = searched_xp;
	1704
	1705	// exit when root inode found (i.e. dentry_xp == XPTR_NULL)
	1706	do
	1707	{
	1708	// get inode cluster and local pointer
	1709	cxy_t inode_cxy = GET_CXY( inode_xp );
[473]	1710	vfs_inode_t * inode_ptr = GET_PTR( inode_xp );
[1]	1711
	1712	// get extended pointer on parent dentry
	1713	dentry_xp = (xptr_t)hal_remote_lwd( XPTR( inode_cxy , inode_ptr->parent_xp ) );
	1714
	1715	// get dentry cluster and local pointer
	1716	cxy_t dentry_cxy = GET_CXY( dentry_xp );
[473]	1717	vfs_dentry_t * dentry_ptr = GET_PTR( dentry_xp );
[1]	1718
	1719	// get dentry name length and pointer
	1720	length = hal_remote_lw( XPTR( dentry_cxy , &dentry_ptr->length ) );
	1721	name = (char *)hal_remote_lpt( XPTR( dentry_cxy , &dentry_ptr->name ) );
	1722
	1723	// update index and count
	1724	index -= (length + 1);
	1725	count += (length + 1);
	1726
	1727	// check buffer overflow
	1728	if( count >= max_size )
	1729	{
	1730	printk("\n[ERROR] in %s : kernel buffer too small\n", __FUNCTION__ );
	1731	return EINVAL;
	1732	}
	1733
	1734	// update pathname
	1735	hal_remote_memcpy( XPTR( local_cxy , &buffer[index + 1] ) ,
	1736	XPTR( dentry_cxy , name ) , length );
	1737	buffer[index] = '/';
	1738
	1739	// get extended pointer on next inode
	1740	inode_xp = (xptr_t)hal_remote_lwd( XPTR( dentry_cxy , dentry_ptr->parent ) );
	1741	}
	1742	while( (dentry_xp != XPTR_NULL) );
	1743
	1744	return 0;
	1745
	1746	} // end vfs_get_path()
	1747
[188]	1748
	1749	//////////////////////////////////////////////////////////////
	1750	error_t vfs_add_child_in_parent( cxy_t child_cxy,
	1751	vfs_inode_type_t inode_type,
[23]	1752	vfs_fs_type_t fs_type,
	1753	xptr_t parent_xp,
	1754	char * name,
[188]	1755	void * extend,
[23]	1756	xptr_t * child_xp )
[1]	1757	{
[23]	1758	error_t error;
	1759	xptr_t dentry_xp; // extended pointer on created dentry
	1760	xptr_t inode_xp; // extended pointer on created inode
	1761	cxy_t parent_cxy; // parent inode cluster identifier
	1762	vfs_inode_t * parent_ptr; // parent inode local pointer
[1]	1763
	1764	// get parent inode cluster and local pointer
[23]	1765	parent_cxy = GET_CXY( parent_xp );
[459]	1766	parent_ptr = GET_PTR( parent_xp );
[1]	1767
[438]	1768	#if DEBUG_VFS_ADD_CHILD
[433]	1769	uint32_t cycle = (uint32_t)hal_get_cycles();
[438]	1770	if( DEBUG_VFS_ADD_CHILD < cycle )
[459]	1771	printk("\n[DBG] %s : thread %x enter for <%s> / child_cxy = %x / parent_cxy = %x / cycle %d\n",
	1772	__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, name,
	1773	child_cxy, parent_cxy, (uint32_t)hal_get_cycles() );
[433]	1774	#endif
[279]	1775
[204]	1776	// 1. create dentry
[1]	1777	if( parent_cxy == local_cxy ) // parent cluster is the local cluster
	1778	{
[23]	1779	error = vfs_dentry_create( fs_type,
[1]	1780	name,
	1781	parent_ptr,
	1782	&dentry_xp );
[279]	1783
[438]	1784	#if (DEBUG_VFS_ADD_CHILD & 1)
	1785	if( (DEBUG_VFS_ADD_CHILD < cycle) && (error == 0) )
[433]	1786	printk("\n[DBG] %s : dentry <%s> created in cluster %x\n", __FUNCTION__, name, local_cxy );
	1787	#endif
[407]	1788
[1]	1789	}
	1790	else // parent cluster is remote
	1791	{
	1792	rpc_vfs_dentry_create_client( parent_cxy,
[23]	1793	fs_type,
[1]	1794	name,
	1795	parent_ptr,
	1796	&dentry_xp,
	1797	&error );
[279]	1798
[438]	1799	#if (DEBUG_VFS_ADD_CHILD & 1)
	1800	if( (DEBUG_VFS_ADD_CHILD < cycle) && (error == 0) )
[433]	1801	printk("\n[DBG] %s : dentry <%s> created in cluster %x\n", __FUNCTION__, name, parent_cxy );
	1802	#endif
[407]	1803
[1]	1804	}
	1805
	1806	if( error )
	1807	{
[437]	1808	printk("\n[ERROR] in %s : cannot create dentry <%s> in cluster %x\n",
	1809	__FUNCTION__ , name , parent_cxy );
[204]	1810	return ENOMEM;
[1]	1811	}
	1812
[204]	1813	// 2. create child inode TODO : define attr / mode / uid / gid
[1]	1814	uint32_t attr = 0;
	1815	uint32_t mode = 0;
	1816	uint32_t uid = 0;
	1817	uint32_t gid = 0;
	1818
	1819	if( child_cxy == local_cxy ) // child cluster is the local cluster
	1820	{
	1821	error = vfs_inode_create( dentry_xp,
[23]	1822	fs_type,
	1823	inode_type,
[188]	1824	extend,
[1]	1825	attr,
	1826	mode,
	1827	uid,
	1828	gid,
	1829	&inode_xp );
[279]	1830
[438]	1831	#if (DEBUG_VFS_ADD_CHILD & 1)
	1832	if( DEBUG_VFS_ADD_CHILD < cycle )
[433]	1833	printk("\n[DBG] %s : inode <%x> created in cluster %x\n",
	1834	__FUNCTION__ , GET_PTR(inode_xp) , local_cxy );
	1835	#endif
	1836
[1]	1837	}
	1838	else // child cluster is remote
	1839	{
	1840	rpc_vfs_inode_create_client( child_cxy,
	1841	dentry_xp,
[23]	1842	fs_type,
	1843	inode_type,
[188]	1844	extend,
[1]	1845	attr,
	1846	mode,
	1847	uid,
	1848	gid,
	1849	&inode_xp,
	1850	&error );
[279]	1851
[438]	1852	#if (DEBUG_VFS_ADD_CHILD & 1)
	1853	if( DEBUG_VFS_ADD_CHILD < cycle )
[433]	1854	printk("\n[DBG] %s : inode <%s> created in cluster %x\n",
[407]	1855	__FUNCTION__ , GET_PTR(inode_xp) , child_cxy );
[433]	1856	#endif
[407]	1857
[1]	1858	}
	1859
	1860	if( error )
	1861	{
	1862	printk("\n[ERROR] in %s : cannot create inode in cluster %x\n",
	1863	__FUNCTION__ , child_cxy );
	1864
[459]	1865	vfs_dentry_t * dentry = GET_PTR( dentry_xp );
[1]	1866	if( parent_cxy == local_cxy ) vfs_dentry_destroy( dentry );
[459]	1867	else rpc_vfs_dentry_destroy_client( parent_cxy , dentry , &error );
[204]	1868	return ENOMEM;
[1]	1869	}
	1870
[204]	1871	// 3. update extended pointer on inode in dentry
	1872	cxy_t dentry_cxy = GET_CXY( dentry_xp );
[473]	1873	vfs_dentry_t * dentry_ptr = GET_PTR( dentry_xp );
[204]	1874	hal_remote_swd( XPTR( dentry_cxy , &dentry_ptr->child_xp ) , inode_xp );
	1875
[438]	1876	#if DEBUG_VFS_ADD_CHILD
[433]	1877	cycle = (uint32_t)hal_get_cycles();
[438]	1878	if( DEBUG_VFS_ADD_CHILD < cycle )
[459]	1879	printk("\n[DBG] %s : thread %x in process %x exit for <%s>\n",
	1880	__FUNCTION__, CURRENT_THREAD, CURRENT_THREAD->process->pid, name );
[433]	1881	#endif
[296]	1882
[1]	1883	// success : return extended pointer on child inode
	1884	*child_xp = inode_xp;
	1885	return 0;
	1886
[459]	1887	// FIXME update the refcount fields in both inode and dentry
	1888
[1]	1889	} // end vfs_add_child_in_parent()
	1890
[459]	1891	///////////////////////////////////////////////////////
	1892	error_t vfs_remove_child_from_parent( xptr_t inode_xp )
	1893	{
	1894	cxy_t inode_cxy;
	1895	vfs_inode_t * inode_ptr;
	1896	xptr_t dentry_xp;
	1897	cxy_t dentry_cxy;
	1898	vfs_dentry_t * dentry_ptr;
	1899	error_t error;
	1900
	1901	// get inode cluster and local pointer
	1902	inode_cxy = GET_CXY( inode_xp );
	1903	inode_ptr = GET_PTR( inode_xp );
	1904
	1905	// get cluster and pointers of associated dentry
	1906	dentry_xp = hal_remote_lwd( XPTR( inode_cxy , &inode_ptr->parent_xp ) );
	1907	dentry_cxy = GET_CXY( dentry_xp );
	1908	dentry_ptr = GET_PTR( dentry_xp );
	1909
	1910	// FIXME update the refcount fields in both inode and dentry
	1911
	1912	// delete dentry
	1913	if( dentry_cxy == local_cxy )
	1914	{
	1915	error = vfs_dentry_destroy( dentry_ptr );
	1916	}
	1917	else
	1918	{
	1919	rpc_vfs_dentry_destroy_client( dentry_cxy,
	1920	dentry_ptr,
	1921	&error );
	1922	}
	1923	if( error ) return EINVAL;
	1924
	1925	// delete inode
	1926	if( inode_cxy == local_cxy )
	1927	{
	1928	vfs_inode_destroy( inode_ptr );
	1929	}
	1930	else
	1931	{
	1932	rpc_vfs_inode_destroy_client( inode_cxy,
	1933	inode_ptr,
	1934	&error );
	1935	}
	1936	if( error ) return EINVAL;
	1937
	1938	return 0;
	1939
	1940	} // end vfs_remove_child_from_parent()
	1941
[23]	1942	//////////////////////////////////////////////////////////////////////////////////////////
	1943	// Mapper related functions
	1944	//////////////////////////////////////////////////////////////////////////////////////////
	1945
[238]	1946	////////////////////////////////////////////
	1947	error_t vfs_mapper_move_page( page_t * page,
	1948	bool_t to_mapper )
[23]	1949	{
[204]	1950	error_t error = 0;
[23]	1951
[492]	1952	assert( (page != NULL) , "page pointer is NULL\n" );
[23]	1953
[246]	1954	mapper_t * mapper = page->mapper;
[23]	1955
[492]	1956	assert( (mapper != NULL) , "no mapper for page\n" );
[23]	1957
[438]	1958	#if DEBUG_VFS_MAPPER_MOVE
[433]	1959	uint32_t cycle = (uint32_t)hal_get_cycles();
[438]	1960	if( DEBUG_VFS_MAPPER_MOVE < cycle )
[433]	1961	printk("\n[DBG] %s : thread %x enter for page %d / mapper %x / inode %x / cycle %d\n",
	1962	__FUNCTION__, CURRENT_THREAD, page->index, mapper, mapper->inode, cycle );
	1963	#endif
[246]	1964
[23]	1965	// get FS type
[246]	1966	vfs_fs_type_t fs_type = mapper->type;
[23]	1967
[238]	1968	// call relevant FS function
[23]	1969	if( fs_type == FS_TYPE_FATFS )
	1970	{
	1971	rwlock_wr_lock( &mapper->lock );
[246]	1972	error = fatfs_mapper_move_page( page , to_mapper );
[23]	1973	rwlock_wr_unlock( &mapper->lock );
	1974	}
	1975	else if( fs_type == FS_TYPE_RAMFS )
	1976	{
[492]	1977	assert( false , "should not be called for RAMFS\n" );
[23]	1978	}
	1979	else if( fs_type == FS_TYPE_DEVFS )
	1980	{
[492]	1981	assert( false , "should not be called for DEVFS\n" );
[23]	1982	}
	1983	else
	1984	{
[492]	1985	assert( false , "undefined file system type\n" );
[23]	1986	}
	1987
[438]	1988	#if DEBUG_VFS_MAPPER_MOVE
[433]	1989	cycle = (uint32_t)hal_get_cycles();
[438]	1990	if( DEBUG_VFS_MAPPER_MOVE < cycle )
[433]	1991	printk("\n[DBG] %s : thread %x exit for page %d / mapper %x / inode %x / cycle %d\n",
	1992	__FUNCTION__, CURRENT_THREAD, page->index, mapper, mapper->inode, cycle );
	1993	#endif
[246]	1994
[23]	1995	return error;
	1996
[238]	1997	} // end vfs_move_page()
[23]	1998
	1999	//////////////////////////////////////////////////
[238]	2000	error_t vfs_mapper_load_all( vfs_inode_t * inode )
[23]	2001	{
[492]	2002	assert( (inode != NULL) , "inode pointer is NULL\n" );
[23]	2003
[238]	2004	uint32_t index;
	2005	page_t * page;
[23]	2006
[238]	2007	mapper_t * mapper = inode->mapper;
	2008	uint32_t size = inode->size;
[23]	2009
[492]	2010	assert( (mapper != NULL) , "mapper pointer is NULL\n" );
[23]	2011
[438]	2012	#if DEBUG_VFS_MAPPER_LOAD
[433]	2013	uint32_t cycle = (uint32_t)hal_get_cycles();
[438]	2014	if( DEBUG_VFS_MAPPER_MOVE < cycle )
[433]	2015	printk("\n[DBG] %s : thread %x enter for inode %x in cluster %x / cycle %d\n",
	2016	__FUNCTION__, CURRENT_THREAD, inode, local_cxy, cycle );
	2017	#endif
[401]	2018
	2019	// compute number of pages
[238]	2020	uint32_t npages = size >> CONFIG_PPM_PAGE_SHIFT;
[265]	2021	if( (size & CONFIG_PPM_PAGE_MASK) \|\| (size == 0) ) npages++;
[238]	2022
[265]	2023	// loop on pages
[238]	2024	for( index = 0 ; index < npages ; index ++ )
[23]	2025	{
[238]	2026	// this function allocates the missing page in mapper,
	2027	// and call the vfs_mapper_move_page() to load the page from device
	2028	page = mapper_get_page( mapper , index );
[23]	2029
[238]	2030	if( page == NULL ) return EIO;
[23]	2031	}
	2032
[438]	2033	#if DEBUG_VFS_MAPPER_LOAD
[433]	2034	cycle = (uint32_t)hal_get_cycles();
[438]	2035	if( DEBUG_VFS_MAPPER_MOVE < cycle )
[433]	2036	printk("\n[DBG] %s : thread %x exit for inode %x in cluster %x / cycle %d\n",
	2037	__FUNCTION__, CURRENT_THREAD, inode, local_cxy, cycle );
	2038	#endif
[401]	2039
[238]	2040	return 0;
[23]	2041
[238]	2042	} // end vfs_mapper_load_all()
[23]	2043

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

Context Navigation

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

Download in other formats: