Context Navigation

source: trunk/kernel/fs/vfs.h @ 615

Last change on this file since 615 was 614, checked in by alain, 6 years ago

1) introduce a dev_ioc_sync_write() function in IOC API,

to improve the DEVFS synchronous update.

2) fix a big bug in both the user_dir_create() and user_dir_destroy()

functions: add an extended pointer on the reference client process
in the function's arguments.

File size: 59.4 KB

Rev	Line
[1]	1	/*
	2	* vfs.h - Virtual File System definition.
	3	*
[23]	4	* Author Mohamed Lamine Karaoui (2014,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	#ifndef _VFS_H_
	26	#define _VFS_H_
	27
[14]	28	#include <kernel_config.h>
[457]	29	#include <hal_kernel_types.h>
[1]	30	#include <hal_atomic.h>
	31	#include <remote_rwlock.h>
[568]	32	#include <remote_busylock.h>
	33	#include <busylock.h>
[1]	34	#include <list.h>
	35	#include <xlist.h>
	36	#include <bits.h>
	37	#include <xhtab.h>
	38	#include <errno.h>
[407]	39	#include <shared_syscalls.h>
[1]	40	#include <fatfs.h>
	41	#include <ramfs.h>
[23]	42	#include <devfs.h>
[614]	43	#include <dev_ioc.h>
[1]	44
	45	/** Forward declarations */
	46
	47	struct vfs_inode_s;
[611]	48	struct vfs_dentry_s;
	49	struct vfs_ctx_s;
[1]	50	struct vfs_file_s;
	51
	52	struct mapper_s;
	53	struct process_s;
	54	struct device_s;
	55	struct vseg_s;
[23]	56	struct page_s;
[1]	57
[23]	58	/******************************************************************************************
	59	* These flags are used to define the working mode of the vfs_lookup() function.
	60	*****************************************************************************************/
[1]	61
[610]	62	#define VFS_LOOKUP_DIR 0x01 /* the searched inode must be a directory */
[23]	63	#define VFS_LOOKUP_OPEN 0x02 /* the search is for an open/opendir */
	64	#define VFS_LOOKUP_PARENT 0x04 /* return the parent inode (not the inode itself) */
	65	#define VFS_LOOKUP_CREATE 0x10 /* file must be created if missing */
[610]	66	#define VFS_LOOKUP_EXCL 0x20 /* file cannot previously exist */
[1]	67
[23]	68	/******************************************************************************************
[568]	69	* This structure defines a VFS context, that contains informations common to all inodes
	70	* and dentries for a given file system. As it is declared as a global variable in the
[602]	71	* kdata segment (fs_context[] array), it is replicated in all clusters.
	72	* The <extend> field is a pointer on the FS specific context extension.
	73	* This extension is dynamically allocated by kernel_init in all clusters.
	74	* In each cluster, both this VFS context and the FS specific context are handled as
	75	* private by the local OS intance.
[23]	76	*****************************************************************************************/
[1]	77
[23]	78	typedef enum
	79	{
	80	FS_TYPE_DEVFS = 0,
	81	FS_TYPE_FATFS = 1,
	82	FS_TYPE_RAMFS = 2,
	83
	84	FS_TYPES_NR = 3,
	85	}
	86	vfs_fs_type_t;
[1]	87
[23]	88	typedef enum
	89	{
	90	CTX_ATTR_READ_ONLY = 0x01, /! write access prohibited /
	91	CTX_ATTR_SYNC = 0x10, /! synchronise FS on each write /
	92	}
	93	vfs_ctx_attr_t;
[1]	94
[23]	95	typedef struct vfs_ctx_s
	96	{
	97	vfs_fs_type_t type; /! File System type /
	98	uint32_t attr; /! global attributes for all files in FS /
[188]	99	uint32_t total_clusters; /! total number of clusters on device /
	100	uint32_t cluster_size; /! cluster size on device (bytes) /
	101	xptr_t vfs_root_xp; /! extended pointer on VFS root inode /
[568]	102	busylock_t lock; /! lock protecting inum allocator /
[23]	103	uint32_t bitmap[BITMAP_SIZE(CONFIG_VFS_MAX_INODES)]; /* inum allocator */
	104	void * extend; /! FS specific context extension /
	105	}
	106	vfs_ctx_t;
[1]	107
	108	/******************************************************************************************
	109	* This structure define a VFS inode.
[610]	110	* An inode has several children dentries (if it is a directory), an can have several
	111	* parents dentries (if it hass several aliases links):
	112	* - The "parents" field is the root of the xlist of parents dentries, and the "links"
	113	* fiels define the number of aliases parent dentries. only a FILE inode can have
	114	* several parents (no hard links for directories).
	115	* - The "children" field is an embedded xhtab containing pointers on all local children
	116	* dentries. This set of children is empty for a FILE inode.
[568]	117	* Synchronisation:
[610]	118	* - the main_lock (remote_rwlock) is used during the inode tree traversal,
	119	* or for inode modification (add/remove children in xhtab).
	120	* - the size_lock (remote_rwlock) is used during read/write accesses to the size
	121	* field in the mapper.
	122	* - access to the data stored in the associated mapper use the mapper remote_rwlock
	123	* protecting radix tree traversal and modifications.
[1]	124	*****************************************************************************************/
	125
[611]	126	/* this enum define the VFS inode types values */
	127	/* WARNING : this enum must be kept consistent with macros in <shared_stat.h> file */
	128	/* and with types in <shared_dirent.h> file. */
[23]	129
[10]	130	typedef enum
	131	{
[598]	132	INODE_TYPE_FILE = 0, /! regular file /
[430]	133	INODE_TYPE_DIR = 1, /! directory /
	134	INODE_TYPE_FIFO = 2, /! POSIX named pipe /
	135	INODE_TYPE_PIPE = 3, /! POSIX anonymous pipe /
	136	INODE_TYPE_SOCK = 4, /! POSIX socket /
[598]	137	INODE_TYPE_DEV = 5, /! character device /
[611]	138	INODE_TYPE_BLK = 6, /! block device /
	139	INODE_TYPE_SYML = 7, /! symbolic link /
[10]	140	}
	141	vfs_inode_type_t;
	142
[23]	143	/* this enum define the VFS inode attributes values */
	144
[1]	145	typedef enum
	146	{
[23]	147	INODE_ATTR_DIRTY = 0x01, /* modified versus the value on device */
	148	INODE_ATTR_INLOAD = 0x04, /* loading from device in progress */
	149	INODE_ATTR_NEW = 0x08, /* not saved on device yet */
[1]	150	}
[10]	151	vfs_inode_attr_t;
[1]	152
	153	typedef struct vfs_inode_s
	154	{
[188]	155	struct vfs_ctx_s * ctx; /! local pointer on FS context /
	156	uint32_t inum; /! inode identifier (unique in file system) /
	157	uint32_t attr; /! inode attributes (see above) /
	158	vfs_inode_type_t type; /! inode type (see above) /
	159	uint32_t size; /! number of bytes /
[598]	160	uint32_t uid; /! user owner identifier /
	161	uint32_t gid; /! group owner identifier /
[188]	162	uint32_t rights; /! access rights /
[610]	163	xlist_entry_t parents; /! root of list of parents dentries /
	164	uint32_t links; /! number of parent dentries (hard links) /
[188]	165	xhtab_t children; /! embedded xhtab of children dentries /
[610]	166	remote_rwlock_t size_lock; /! protect read/write to size /
	167	remote_rwlock_t main_lock; /! protect inode tree traversal and modifs /
	168	// list_entry_t list; /! member of set of inodes in same cluster /
	169	// list_entry_t wait_root; /! root of threads waiting on this inode /
[188]	170	struct mapper_s * mapper; /! associated file cache /
	171	void * extend; /! fs_type_specific inode extension /
[1]	172	}
	173	vfs_inode_t;
	174
[598]	175	/* This define the masks for the inode <rights> field */
	176
	177	#define VFS_ISUID 0x0004000
	178	#define VFS_ISGID 0x0002000
[611]	179	#define VFS_ISVTX 0x0001000
[598]	180
	181	#define VFS_IRWXU 0x0000700
	182	#define VFS_IRUSR 0x0000400
	183	#define VFS_IWUSR 0x0000200
	184	#define VFS_IXUSR 0x0000100
	185
	186	#define VFS_IRWXG 0x0000070
	187	#define VFS_IRGRP 0x0000040
	188	#define VFS_IWGRP 0x0000020
	189	#define VFS_IXGRP 0x0000010
	190
	191	#define VFS_IRWXO 0x0000007
	192	#define VFS_IROTH 0x0000004
	193	#define VFS_IWOTH 0x0000002
	194	#define VFS_IXOTH 0x0000001
	195
[1]	196	/******************************************************************************************
	197	* This structure defines a directory entry.
	198	* A dentry contains the name of a remote file/dir, an extended pointer on the
[610]	199	* inode representing this file/dir, a local pointer on the inode representing
[1]	200	* the parent directory.
[610]	201	* A dentry can be member of the set of children of a given directory inode (xhtab).
	202	* A dentry can be member of the set of parents of a given inode (xlist).
[1]	203	*****************************************************************************************/
	204
	205	typedef struct vfs_dentry_s
	206	{
[188]	207	struct vfs_ctx_s * ctx; /! local pointer on FS context /
	208	char name[CONFIG_VFS_MAX_NAME_LENGTH];
	209	uint32_t length; /! name length (bytes) /
	210	struct vfs_inode_s * parent; /! local pointer on parent inode /
	211	xptr_t child_xp; /! extended pointer on child inode /
[610]	212	xlist_entry_t children; /! member of set of children dentries /
	213	xlist_entry_t parents; /! member of set of parent dentries /
[188]	214	void * extend; /! FS specific extension /
[1]	215	}
	216	vfs_dentry_t;
	217
	218	/******************************************************************************************
[23]	219	* This file structure describes an open file/directory for a given process.
[1]	220	* It is not replicated, and is dynamically allocated in the cluster that contains
	221	* the inode, when a thread makes an open() or opendir() system call.
[459]	222	* It cannot exist a file structure without an inode structure in same cluster.
[266]	223	* As the fd_array (containing extended pointers on the open file descriptors)
[23]	224	* is replicated in all process descriptors, we need a references counter.
[1]	225	*****************************************************************************************/
	226
	227	typedef enum
	228	{
[23]	229	FD_ATTR_READ_ENABLE = 0x01, /! read access possible /
	230	FD_ATTR_WRITE_ENABLE = 0x02, /! write access possible /
	231	FD_ATTR_APPEND = 0x04, /! append on each write /
	232	FD_ATTR_CLOSE_EXEC = 0x08, /! close file on exec /
	233	FD_ATTR_SYNC = 0x10, /! synchronise FS on each write /
	234	FD_ATTR_IS_DIR = 0x20, /! this is a directory /
[1]	235	}
[23]	236	vfs_file_attr_t;
[1]	237
	238	typedef struct vfs_file_s
	239	{
[23]	240	struct vfs_ctx_s * ctx; /! local pointer on FS context. /
[1]	241	uint32_t gc; /! generation counter /
[23]	242	vfs_file_attr_t attr; /! file attributes bit vector (see above) /
	243	vfs_inode_type_t type; /! same type as inode /
[1]	244	uint32_t offset; /! seek position in file /
[23]	245	uint32_t refcount; /! all pointers on this file descriptor /
	246	remote_rwlock_t lock; /! protect offset modifications /
[1]	247	struct mapper_s * mapper; /! associated file cache /
	248	struct vfs_inode_s * inode; /! local pointer on associated inode /
[23]	249	void * extend; /! FS specific extension /
[1]	250	}
	251	vfs_file_t;
	252
	253
[602]	254	/******************************************************************************************
	255	* These functions access / modify a VFS context.
[1]	256	*****************************************************************************************/
	257
	258	/******************************************************************************************
[188]	259	* This function initialise a (statically allocated) VFS context in local cluster.
	260	******************************************************************************************
	261	* @ fs_type : file system type.
	262	* @ attr : global attributes (for all files in FS.
	263	* @ total_clusters : total number of clusters on device.
	264	* @ cluster_size : cluster size on device (bytes).
	265	* @ vfs_root_xp : extended pointer on VFS root inode.
	266	* @ extend : fs_type_specific extension.
	267	*****************************************************************************************/
	268	void vfs_ctx_init( vfs_fs_type_t type,
	269	uint32_t attr,
	270	uint32_t total_clusters,
	271	uint32_t cluster_size,
	272	xptr_t vfs_root_xp,
	273	void * extend );
	274
	275	/******************************************************************************************
[1]	276	* This function allocates an inode identifier from the local cluster inum allocator.
	277	* The inum respects a fixed format:
	278	* - the 16 MSB bits contain the cluster identifier : cxy
	279	* - the 16 LSB bits contains the local inode identifier : lid
	280	******************************************************************************************
	281	* @ ctx : local pointer on file system context.
	282	* @ inum : [ou] buffer for allocated inode identifier.
	283	* @ return 0 if success / return non-zero if error.
	284	*****************************************************************************************/
	285	error_t vfs_ctx_inum_alloc( vfs_ctx_t * ctx,
	286	uint32_t * inum );
	287
	288	/******************************************************************************************
	289	* This function release an inode identifier.
	290	******************************************************************************************
	291	* @ ctx : local pointer on file system context.
	292	* @ inum : released inode identifier.
	293	*****************************************************************************************/
	294	void vfs_ctx_inum_release( vfs_ctx_t * ctx,
	295	uint32_t inum );
	296
	297
	298
[602]	299	/******************************************************************************************
	300	* These low-level functions access / modify a VFS inode descriptor
	301	*****************************************************************************************/
[1]	302
	303	/******************************************************************************************
[602]	304	* This function returns a printable string for the inode type.
	305	*****************************************************************************************/
	306	const char * vfs_inode_type_str( vfs_inode_type_t type );
	307
	308	/******************************************************************************************
[1]	309	* This function allocates memory from local cluster for an inode descriptor and the
	310	* associated mapper. It initialise these descriptors from arguments values.
[611]	311	* It must called by a local thread. Use the RPC_INODE_CREATE if client thread is remote.
[1]	312	******************************************************************************************
[23]	313	* @ fs_type : file system type.
	314	* @ inode_type : inode type.
[1]	315	* @ attr : inode attributes.
[23]	316	* @ rights : inode access rights.
[1]	317	* @ uid : user owner ID.
	318	* @ gid : group owner ID.
	319	* @ inode_xp : [out] buffer for extended pointer on created inode.
[459]	320	* @ return 0 if success / return ENOMEM or EINVAL if error.
[1]	321	*****************************************************************************************/
[610]	322	error_t vfs_inode_create( vfs_fs_type_t fs_type,
[23]	323	vfs_inode_type_t inode_type,
	324	uint32_t attr,
	325	uint32_t rights,
	326	uid_t uid,
	327	gid_t gid,
	328	xptr_t * inode_xp );
[1]	329
	330	/******************************************************************************************
[602]	331	* This function releases memory allocated to an inode descriptor, including
	332	* all memory allocated to the mapper (both mapper descriptor and radix tree).
[610]	333	* The mapper should not contain any dirty page (should be synchronized before deletion).
[602]	334	* It must be executed by a thread running in the cluster containing the inode.
	335	* Use the rpc_vfs_inode_destroy_client() function if required.
[1]	336	******************************************************************************************
	337	* @ inode : local pointer on inode descriptor.
	338	*****************************************************************************************/
[602]	339	void vfs_inode_destroy( vfs_inode_t * inode );
[1]	340
	341	/******************************************************************************************
	342	* This function returns the <size> of a file/dir from a remote inode,
	343	* taking the remote_rwlock protecting <size> in READ_MODE.
	344	*****************************************************************************************
	345	* @ inode_xp : extended pointer on the remote inode.
	346	* @ return the current size.
	347	*****************************************************************************************/
	348	uint32_t vfs_inode_get_size( xptr_t inode_xp );
	349
	350	/******************************************************************************************
	351	* This function set the <size> of a file/dir to a remote inode,
	352	* taking the remote_rwlock protecting <size> in WRITE_MODE.
	353	*****************************************************************************************
	354	* @ inode_xp : extended pointer on the remote inode.
	355	* @ size : value to be written.
	356	*****************************************************************************************/
	357	void vfs_inode_set_size( xptr_t inode_xp,
	358	uint32_t size );
	359
	360	/******************************************************************************************
	361	* This function takes the main lock of a remote inode.
[602]	362	* This lock protect all inode fields, including the children dentries.
[1]	363	*****************************************************************************************
	364	* @ inode_xp : extended pointer on the remote inode.
	365	*****************************************************************************************/
[101]	366	void vfs_inode_lock( xptr_t inode_xp );
[1]	367
	368	/******************************************************************************************
	369	* This function releases the main lock of a remote inode.
	370	* This lock protect all inode fiels, including the children dentries.
	371	*****************************************************************************************
	372	* @ inode_xp : extended pointer on the remote inode.
	373	*****************************************************************************************/
[101]	374	void vfs_inode_unlock( xptr_t inode_xp );
[1]	375
	376	/******************************************************************************************
[409]	377	* This debug function copies the name of a remote inode identified by the <inode_xp>
	378	* argument to a local buffer identified by the <name> argument.
	379	* The local buffer size must be at least CONFIG_VFS_MAX_NAME_LENGTH.
[101]	380	*****************************************************************************************
	381	* @ inode_xp : extended pointer on the remote inode.
[409]	382	* @ name : local buffer pointer.
[1]	383	*****************************************************************************************/
[409]	384	void vfs_inode_get_name( xptr_t inode_xp,
	385	char * name );
[1]	386
[602]	387	/******************************************************************************************
	388	* This function accesses successively all pages of a file identified by the <inode>,
	389	* argument, to force misses, and load all pages into mapper.
	390	* The target inode can be a directory or a file, but this function is mainly used
	391	* to prefetch a complete directory to the mapper.
	392	* It must be executed by a thread running in the cluster containing the inode.
	393	* This function does NOT take any lock.
	394	******************************************************************************************
	395	* @ inode : local pointer on inode.
	396	* @ return 0 if success / return -1 if device access failure.
	397	*****************************************************************************************/
	398	error_t vfs_inode_load_all_pages( vfs_inode_t * inode );
[204]	399
[1]	400
[611]	401
[602]	402	/******************************************************************************************
	403	* These low-level functions access / modify a VFS dentry descriptor
	404	*****************************************************************************************/
	405
[1]	406	/******************************************************************************************
	407	* This function allocates memory from local cluster for a dentry descriptor,
	408	* initialises it from arguments values, and returns the extended pointer on dentry.
[611]	409	* It must called by a local thread. Use the RPC_DENTRY_CREATE if client thread is remote.
[1]	410	******************************************************************************************
[614]	411	* @ fs_type : [in] file system type.
	412	* @ name : [in] directory entry file/dir name.
[23]	413	* @ dentry_xp : [out] buffer for extended pointer on created dentry.
[1]	414	* @ return 0 if success / return ENOMEM or EINVAL if error.
	415	*****************************************************************************************/
[23]	416	error_t vfs_dentry_create( vfs_fs_type_t fs_type,
	417	char * name,
	418	xptr_t * dentry_xp );
[1]	419
	420	/******************************************************************************************
[610]	421	* This function removes the dentry from the parent inode xhtab, and releases the memory
	422	* allocated to the dentry descriptor.
[602]	423	* It must be executed by a thread running in the cluster containing the dentry.
[614]	424	* Use the RPC_DENTRY_DESTROY if required.
[1]	425	******************************************************************************************
[614]	426	* @ dentry : [in] local pointer on dentry descriptor.
[1]	427	*****************************************************************************************/
[602]	428	void vfs_dentry_destroy( vfs_dentry_t * dentry );
[1]	429
	430
[602]	431	/******************************************************************************************
	432	* These low-level functions access / modify a VFS file descriptor
	433	*****************************************************************************************/
[23]	434
[1]	435	/******************************************************************************************
[23]	436	* This function allocates memory and initializes a new local file descriptor.
	437	* It must be executed in the cluster containing the inode.
	438	* If the client thread is not running in the owner cluster, it must use the
	439	* rpc_vfs_file_create_client() function.
	440	******************************************************************************************
	441	* @ inode : local pointer on associated inode.
	442	* @ attr : file descriptor attributes.
	443	* @ file_xp : [out] buffer for extended pointer on created file descriptor.
	444	* @ return 0 if success / return ENOMEM if error.
[1]	445	*****************************************************************************************/
[23]	446	error_t vfs_file_create( vfs_inode_t * inode,
	447	uint32_t attr,
	448	xptr_t * file_xp );
[1]	449
[23]	450	/******************************************************************************************
	451	* This function releases memory allocated to a local file descriptor.
	452	* It must be executed by a thread running in the cluster containing the inode,
	453	* and the file refcount must be zero.
	454	* If the client thread is not running in the owner cluster, it must use the
	455	* rpc_vfs_file_destroy_client() function.
	456	******************************************************************************************
	457	* @ file : local pointer on file descriptor.
	458	*****************************************************************************************/
	459	void vfs_file_destroy( vfs_file_t * file );
[1]	460
[23]	461	/******************************************************************************************
	462	* These functions increment (resp. decrement) the count field in a remote file
	463	* descriptor, using a remote_atomic access.
	464	*****************************************************************************************/
	465	void vfs_file_count_up ( xptr_t file_xp );
	466	void vfs_file_count_down( xptr_t file_xp );
	467
	468
	469
[612]	470
[602]	471	/******************************************************************************************
[610]	472	* These functions access / modify the distributed VFS Inode Tree
[598]	473	*****************************************************************************************/
	474
	475	/******************************************************************************************
[610]	476	* This function returns in a kernel <buffer> allocated by the caller function,
	477	* the pathname of a file/dir identified by the <inode_xp> argument.
[1]	478	* It traverse the Inode Tree from the target node to the root.
	479	* It can be called by any thread running in any cluster.
[610]	480	* As this buffer if filled in "reverse order" (i.e. from the target inode to the root),
	481	* the pathname is stored in the higher part of the buffer.
	482	* A pointer on the first character of the pathname is returned in <first> buffer.
	483	*
	484	* WARNING : This function takes & releases the remote_rwlock protecting the Inode Tree.
[1]	485	******************************************************************************************
[610]	486	* @ inode_xp : [in] extended pointer on target inode descriptor.
	487	* @ buffer : [in] kernel buffer for pathname (allocated by caller).
	488	* @ first : [out] pointer on first character in buffer.
	489	* @ max_size : [in] max number of characters in buffer.
[1]	490	* @ return 0 if success / return EINVAL if buffer too small.
	491	*****************************************************************************************/
	492	error_t vfs_get_path( xptr_t inode_xp,
	493	char * buffer,
[610]	494	char ** first,
[1]	495	uint32_t max_size );
	496
	497	/******************************************************************************************
[610]	498	* This function traverses the the Inode Tree, from inode identified by the <root_xp>
	499	* argument, and returns in <inode_xp> the inode identified by the < pathname> argument.
	500	* It can be called by a thread running in any cluster.
	501	* It supports the following flags that define the lookup modes :
	502	* - VFS_LOOKUP_DIR : the searched inode must be a directory
	503	* - VFS_LOOKUP_OPEN : the search is for an open/opendir
	504	* - VFS_LOOKUP_PARENT : return the parent inode (not the inode itself)
	505	* - VFS_LOOKUP_CREATE : file/directory must be created if missing on IOC
	506	* - VFS_LOOKUP_EXCL : file cannot previously exist
	507	* As the inode Tree is a cache, the search policy is the following :
[459]	508	* - If a given directory name in the path is not found in the inode tree, it try to load
	509	* the missing dentry/inode couple, from informations found in the parent directory.
[610]	510	* - If this directory entry does not exist on IOC, it returns an error.
	511	* - If the the file identified by the pathname does not exist on IOC but the
	512	* flag CREATE is set, the inode is created. It returns an error otherwise.
	513	* - If the the file identified by the pathname exist on device, but both flags EXCL
[23]	514	* and CREATE are set, an error is returned.
[610]	515	* - If the PARENT flag is set, it returns in <inode_xp> an extended pointer on the parent
	516	* inode, and copies in <last_name> buffer a string containing the last name in path.
	517	*
	518	* WARNING : The remote_rwlock protecting the Inode Tree must be taken by the caller.
	519	*
	520	* TODO the access rights are not checked yet.
[1]	521	******************************************************************************************
[610]	522	* @ root_xp : [in] extended pointer on root inode (can be root of a subtree).
	523	* @ pathname : [in] path (can be relative or absolute).
	524	* @ lookup_mode : [in] flags defining the searching mode.
[238]	525	* @ inode_xp : [out] buffer for extended pointer on searched inode.
[610]	526	* @ last_name : [out] pointer on buffer for last name in path.
[407]	527	* @ return 0 if success / ENOENT if inode not found , EACCES if permisson denied,
[1]	528	*****************************************************************************************/
[610]	529	error_t vfs_lookup( xptr_t root_xp,
[23]	530	char * pathname,
	531	uint32_t lookup_mode,
[610]	532	xptr_t * inode_xp,
	533	char * last_name );
[1]	534
	535	/******************************************************************************************
	536	* This function creates a new couple dentry/inode, and insert it in the Inode-Tree.
[610]	537	* Only the distributed Inode Tree is modified: it does NOT modify the parent mapper,
	538	* and does NOT update the FS on IOC device.
[407]	539	* It can be executed by any thread running in any cluster (can be different from both
[610]	540	* the child cluster and the parent cluster).
[602]	541	*
	542	* [Implementation]
[611]	543	* As there are cross-references between inode and dentry, this function implements
	544	* a three steps scenario :
[602]	545	* 1) The dentry descriptor is created in the cluster containing the existing <parent_xp>
[611]	546	* inode, and partially initialized, using the RPC_VFS_CREATE DENTRY if required.
[602]	547	* 2) The inode and its associated mapper are created in cluster identified by <child_cxy>,
[611]	548	* and partially initialised, using the RPC_VFS_CREATE_INODE if required.
	549	* The new inode and the parent inode can have different FS types.
	550	* 3) The pointers between the parent inode, the new dentry, and the child inode
	551	* are updated, using remote accesses.
[1]	552	******************************************************************************************
[602]	553	* @ child_inode_cxy : [in] target cluster for child inode.
	554	* @ child_inode_type : [in] child inode type
	555	* @ fs_type : [in] child inode FS type.
	556	* @ parent_inode_xp : [in] extended pointer on parent inode.
	557	* @ name : [in] new directory entry name.
	558	* @ dentry_xp : [out] buffer for extended pointer on dentry
	559	* @ child_inode_xp : [out] buffer for extended pointer on child inode.
	560	* @ return 0 if success / -1 if dentry or inode cannot be created.
[1]	561	*****************************************************************************************/
[610]	562	error_t vfs_add_child_in_parent( cxy_t child_inode_cxy,
	563	vfs_inode_type_t child_inode_type,
[23]	564	vfs_fs_type_t fs_type,
[602]	565	xptr_t parent_inode_xp,
	566	char * name,
	567	xptr_t * dentry_xp,
	568	xptr_t * child_inode_xp );
[1]	569
	570	/******************************************************************************************
[610]	571	* This function removes a remote dentry from the Inode-Tree.
	572	* - It removes the dentry from the parent inode xhtab ("children" field), and from the
	573	* child inode xlist ("parents" field).
	574	* - It releases the memory allocated to the dentry descriptor.
	575	* - If the number of parents of the child inode is one, it also releases the memory
	576	* allocated to the child inode.
	577	* Only the Inode Tree is modified: it does NOT modify the parent mapper,
	578	* and does NOT update the FS on IOC device.
[602]	579	* It can be executed by any thread running in any cluster (can be different from both
[610]	580	* the inode cluster and the dentry cluster).
[1]	581	******************************************************************************************
[610]	582	* @ dentry_xp : extended pointer on removed dentry.
[1]	583	*****************************************************************************************/
[610]	584	void vfs_remove_child_from_parent( xptr_t dentry_xp );
[1]	585
[188]	586	/******************************************************************************************
[602]	587	* This function is called by the vfs_lookup() function when a new dentry/inode must
	588	* be created from scratch and introduced in both the Inode Tree and the IOC device.
	589	* The dentry and inode descriptors have been created by the caller:
	590	* - It allocates one cluster from the relevant FS, and updates the File Allocation
	591	* Table (both the FAT mapper, and the IOC device).
	592	* - It set the "size", and "extend" fields in child inode descriptor.
	593	* - It updates the parent directory to introduce the new child in the parent directory
	594	* inode descriptor (radix tree), in theparent inode mapper, and on IOC device.
	595	* - It set the "extend" field in dentry descriptor.
	596	* It can be called by a thread running in any cluster.
	597	******************************************************************************************
	598	* @ parent_xp : extended pointer on parent inode descriptor.
	599	* @ dentry_xp : extended pointer on new dentry descriptor.
	600	* @ child_xp : extended pointer on child inode descriptor.
	601	* @ return 0 if success / -1 if failure.
	602	*****************************************************************************************/
[612]	603	error_t vfs_new_dentry_init( xptr_t parent_xp,
	604	xptr_t dentry_xp,
	605	xptr_t child_xp );
[602]	606
	607	/******************************************************************************************
[612]	608	* This function creates in the directory identified by the <child_xp> argument,
	609	* the two special dentries <.> and <..>. The parent directory inode is defined
	610	* by the <parent_xp> argument. The two dentries are introduced in the Inode Tree.
	611	* They are also introduced in the child directory mapper, and the IOC device is updated.
	612	* This function is called by all functions creating a brand new directory : vfs_mkdir(),
	613	* devfs_global_init(), and devfs_local_init().
[611]	614	******************************************************************************************
	615	* @ child_xp : extended pointer on new directory inode.
	616	* @ parent_xp : extended pointer on parent directory inode.
	617	* @ return 0 if success / -1 if failure.
	618	*****************************************************************************************/
	619	error_t vfs_add_special_dentries( xptr_t child_xp,
	620	xptr_t parent_xp );
	621
	622	/******************************************************************************************
[188]	623	* This recursive function diplays a complete inode/dentry sub-tree.
	624	* Any inode can be selected as the sub-tree root.
[611]	625	* WARNING : this function is not protected against a concurrent inode/dentry removal...
[188]	626	******************************************************************************************
	627	* @ inode_xp : extended pointer on sub-tree root inode.
	628	*****************************************************************************************/
	629	void vfs_display( xptr_t inode_xp );
[23]	630
[602]	631	/******************************************************************************************
	632	* This function mount a given file system type for a given process
	633	* TODO non implemented yet [AG].
	634	*****************************************************************************************/
	635	error_t vfs_mount_fs_root( struct device_s * device,
	636	uint32_t fs_type,
	637	struct process_s * process );
[23]	638
	639
	640
[612]	641
[602]	642	/******************************************************************************************
	643	* These functions define the VFS "syscalls" API (user commands)
[1]	644	*****************************************************************************************/
	645
	646	/******************************************************************************************
[313]	647	* This function moves <size> bytes between a remote file mapper, identified by the
	648	* <file_xp> argument, and a - possibly distributed - user space <buffer>, taken into
	649	* account the offset in <file_xp>. The transfer direction is defined by <to_buffer>.
[407]	650	* It is called by the sys_read() and sys_write() functions.
[23]	651	******************************************************************************************
[265]	652	* @ to_buffer : mapper -> buffer if true / buffer -> mapper if false.
[23]	653	* @ file_xp : extended pointer on the remote file descriptor.
[313]	654	* @ buffer : user space pointer on buffer (can be physically distributed).
[1]	655	* @ size : requested number of bytes from offset.
[407]	656	* @ returns number of bytes actually moved if success / -1 if error.
[1]	657	*****************************************************************************************/
[407]	658	int vfs_user_move( bool_t to_buffer,
	659	xptr_t file_xp,
	660	void * buffer,
	661	uint32_t size );
[1]	662
	663	/******************************************************************************************
[317]	664	* This function moves <size> bytes between a remote file mapper, identified by the
	665	* <file_xp> argument, and a - possibly remote - kernel <buffer_xp>, taken into
	666	* account the offset in <file_xp>. The transfer direction is defined by <to_buffer>.
[407]	667	* It is called by the elf_load_process() function.
[317]	668	******************************************************************************************
	669	* @ to_buffer : mapper -> buffer if true / buffer -> mapper if false.
	670	* @ file_xp : extended pointer on the remote file descriptor.
	671	* @ buffer_xp : user space pointer on buffer (can be physically distributed).
	672	* @ size : requested number of bytes from offset.
[407]	673	* @ returns 0 if success / -1 if error.
[317]	674	*****************************************************************************************/
	675	error_t vfs_kernel_move( bool_t to_buffer,
	676	xptr_t file_xp,
	677	xptr_t buffer_xp,
	678	uint32_t size );
	679
	680	/******************************************************************************************
[602]	681	* This function allocates a vfs_file_t structure in the cluster containing the inode
[610]	682	* identified by the <root_xp> & <path> arguments.
[602]	683	* It initializes it, register it in the reference process fd_array identified by the
[610]	684	* <process_xp> argument, and returns both the extended pointer on the file descriptor,
	685	* and the allocated index in the <file_xp> and <file_id> buffers.
[602]	686	* The pathname can be relative to current directory or absolute.
[610]	687	* If the inode does not exist in the inode cache, it try to find the file on the IOC
[602]	688	* device, and creates an inode on a pseudo randomly selected cluster if found.
	689	* It the requested file does not exist on device, it creates a new inode if the
	690	* O_CREAT flag is set, and return an error otherwise.
[610]	691	*
	692	* WARNING : this function takes & releases the remote_rwlock protecting the Inode Tree.
[602]	693	******************************************************************************************
[610]	694	* @ root_xp : extended pointer on path root inode.
[602]	695	* @ path : file pathname (absolute or relative to current directory).
[610]	696	* @ process_xp : extended pointer on client reference process.
[602]	697	* @ flags : defined in vfs_file_t structure.
	698	* @ mode : access rights (as defined by chmod).
	699	* @ file_xp : [out] buffer for extended pointer on created remote file descriptor.
	700	* @ file_id : [out] buffer for created file descriptor index in reference fd_array.
	701	* @ return 0 if success / return non-zero if error.
	702	*****************************************************************************************/
[610]	703	error_t vfs_open( xptr_t root_xp,
[602]	704	char * path,
[610]	705	xptr_t process_xp,
[602]	706	uint32_t flags,
	707	uint32_t mode,
	708	xptr_t * file_xp,
	709	uint32_t * file_id );
	710
	711	/******************************************************************************************
[1]	712	* This function set a new value in the offset of the open file descriptor <file_xp>.
	713	* This value depends on the <whence> argument:
	714	* - if VFS_SEEK_SET, new value is <offset>
	715	* - if VFS_SEEK_CUR, new value is current_offset + <offset>
	716	* - if VFS_SEEK_END, new value is file_size + <offset>
	717	******************************************************************************************
	718	* @ file_xp : extended pointer on the remote open file descriptor.
	719	* @ offset : local pointer on source kernel buffer.
	720	* @ whence : VFS_SEEK_SET / VFS_SEEK_CUR / VFS_SEEK_END.
	721	* @ new_offset : [out] buffer for new offset value.
	722	* @ returns 0 if success / -1 if error.
	723	*****************************************************************************************/
	724	error_t vfs_lseek( xptr_t file_xp,
	725	uint32_t offset,
	726	uint32_t whence,
	727	uint32_t * new_offset );
	728
	729	/******************************************************************************************
[602]	730	* This function close the - non-replicated - file descriptor identified by the <file_xp>
[459]	731	* and <file_id> arguments.
	732	* 1) All entries in the fd_array copies are directly reset by the calling thread,
[23]	733	* using remote accesses.
	734	* 2) The memory allocated to file descriptor in cluster containing the inode is released.
	735	* It requires a RPC if cluster containing the file descriptor is remote.
[1]	736	******************************************************************************************
[459]	737	* @ file_xp : extended pointer on the file descriptor in owner cluster.
[23]	738	* @ file_id : file descriptor index in fd_array.
	739	* @ returns 0 if success / -1 if error.
[1]	740	*****************************************************************************************/
[23]	741	error_t vfs_close( xptr_t file_xp,
	742	uint32_t file_id );
[1]	743
	744	/******************************************************************************************
[602]	745	* This function is called by the kernel to create in the file system a new directory
[610]	746	* identified by the <root_xp> & <path> arguments, with the access permission defined
	747	* by the <rights> argument. All nodes in the path - but the last - must exist.
	748	*
	749	* WARNING : this function takes & releases the remote_rwlock protecting the Inode Tree.
	750	******************************************************************************************
	751	* @ root_xp : extended pointer on path root inode (any inode in Inode Tree).
	752	* @ path : pathname (absolute or relative to current directory).
	753	* @ rights : access rights.
	754	* @ returns 0 if success / -1 if error.
	755	*****************************************************************************************/
	756	error_t vfs_mkdir( xptr_t root_xp,
	757	char * path,
	758	uint32_t rights );
	759
	760	/******************************************************************************************
	761	* This function is called by the kernel to create in the file system a new directory
	762	* entry identified by the <new_root_xp> & <new_path> arguments, to be linked to an
	763	* existing inode, identified by the <old_root_xp> & <old_path> arguments.
	764	* If the link is successful, the link count of the target inode is incremented.
	765	* The <new_path> and <old_path> share equal access rights to the underlying inode.
[602]	766	* Both the IOC device and the Inode Tree are modified.
[610]	767	$
	768	* TODO This function should handle any type of node, but the current implementation
	769	* handles only the FILE and DIR types.
	770	*
	771	* WARNING : this function takes & releases the remote_rwlock protecting the Inode Tree.
[1]	772	******************************************************************************************
[610]	773	* @ old_root_xp : extended pointer on old path root inode (any inode in Inode Tree).
	774	* @ old_path : old pathname (absolute or relative to current directory).
	775	* @ nld_root_xp : extended pointer on new path root inode (any inode in Inode Tree).
	776	* @ new_path : new pathname (absolute or relative to current directory).
[602]	777	* @ returns 0 if success / -1 if error.
	778	*****************************************************************************************/
[610]	779	error_t vfs_link( xptr_t old_root_xp,
	780	char * old_path,
	781	xptr_t new_root_xp,
	782	char * new_path );
[602]	783
	784	/******************************************************************************************
	785	* This function is called by the kernel to remove from the file system a directory entry
[610]	786	* identified by the <root_xp> & <path> arguments.
	787	* The link count of the target node is decremented.
	788	* If the removed link is the last, the target inode is deleted.
[602]	789	* Both the IOC device and the Inode Tree are modified.
[610]	790	*
	791	* TODO This function should handle any type of node, but the current implementation
	792	* handles only only the FILE and DIR types.
	793	*
	794	* WARNING : this function takes & releases the remote_rwlock protecting the Inode Tree.
[602]	795	******************************************************************************************
[610]	796	* @ root_xp : extended pointer on root inode (can be any inode in Inode Tree).
[1]	797	* @ path : pathname (absolute or relative to current directory).
[23]	798	* @ returns 0 if success / -1 if error.
[1]	799	*****************************************************************************************/
[610]	800	error_t vfs_unlink( xptr_t root_xp,
[1]	801	char * path );
	802
	803	/******************************************************************************************
[610]	804	* This function returns, in the structure pointed by the <st> pointer, various
	805	* informations on the inode identified by the <root_inode_xp> and <patname> arguments.
	806	*
	807	* TODO : only partially implemented yet (only size and inum fields).
	808	*
	809	* WARNING : this function takes & releases the remote_rwlock protecting the Inode Tree.
[23]	810	******************************************************************************************
[610]	811	* @ root_xp : extended pointer on path root inode (any inode in Inode Tree)
	812	* @ pathname : pathname to target inode.
[598]	813	* @ st : local pointer on the stat structure in kernel space.
[23]	814	* @ returns 0 if success / -1 if error.
[1]	815	*****************************************************************************************/
[610]	816	error_t vfs_stat( xptr_t root_xp,
	817	char * pathname,
[598]	818	struct stat * st );
[1]	819
	820	/******************************************************************************************
[610]	821	* This function creates a new directory as defined by the <root_xp> & <path> arguments.
[23]	822	* TODO not implemented yet...
	823	******************************************************************************************
[610]	824	* @ root_xp : extended pointer on the path root directory.
	825	* @ path : pathname (absolute or relative to CWD).
[23]	826	* @ mode : access rights (as defined by chmod)
	827	* @ returns 0 if success / -1 if error.
[1]	828	*****************************************************************************************/
[610]	829	error_t vfs_mkdir( xptr_t root_xp,
[23]	830	char * path,
	831	uint32_t mode );
[1]	832
	833	/******************************************************************************************
[610]	834	* This function makes the directory identified by the <root_xp and <path> arguments
	835	* to become the working directory for the calling process.
[23]	836	******************************************************************************************
[610]	837	* @ root_xp : extended pointer on the path root directory.
	838	* @ path : pathname (absolute or relative to CWD).
[23]	839	* return 0 if success / -1 if error.
[1]	840	*****************************************************************************************/
[610]	841	error_t vfs_chdir( xptr_t root_xp,
[23]	842	char * path );
[1]	843
	844	/******************************************************************************************
[610]	845	* This function change the access rigths for the file/directory identified by the
	846	* <root_xp> and <path> arguments as defined by the <mode> argument value.
[23]	847	******************************************************************************************
[610]	848	* @ root_xp : extended pointer on the path root directory.
	849	* @ path : pathname (absolute or relative to CWD).
	850	* @ mode : access rights
[23]	851	* return 0 if success / -1 if error.
[1]	852	*****************************************************************************************/
[610]	853	error_t vfs_chmod( xptr_t root_xp,
[23]	854	char * path,
	855	uint32_t mode );
[1]	856
	857	/******************************************************************************************
[23]	858	* This function creates a named FIFO file.
	859	* TODO not implemented yet
	860	******************************************************************************************
[610]	861	* @ root_xp : extended pointer on the path root directory.
	862	* @ path : pathname (absolute or relative to CWD).
	863	* @ mode : access rights new value.
[1]	864	*****************************************************************************************/
[610]	865	error_t vfs_mkfifo( xptr_t root_xp,
[23]	866	char * path,
	867	uint32_t mode );
[1]	868
	869
	870
[612]	871
	872
[23]	873	/******************************************************************************************
[612]	874	* These functions define the VFS "FS" API to a specific File System
[602]	875	*****************************************************************************************/
	876
	877	/******************************************************************************************
[614]	878	* This function makes the I/O operation to move one page identified by the <page_xp>
	879	* argument to/from the IOC device from/to the mapper, as defined by <cmd_type>.
	880	* Depending on the file system type, it calls the proper, FS specific function.
	881	* It is used in case of MISS on the mapper, or when a dirty page in the mapper must
	882	* be updated in the File System.
	883	* The mapper pointer is obtained from the page descriptor.
	884	* It can be executed by any thread running in any cluster.
	885	* This function does NOT take any lock.
	886	******************************************************************************************
	887	* @ page_xp : extended pointer on page descriptor (for mapper and page_id).
	888	* @ cmd_type : IOC_READ / IOC_WRITE / IOC_SYNC_READ / IOC_SYNC_WRITE
	889	* @ returns 0 if success / return -1 if device access failure.
	890	*****************************************************************************************/
	891	error_t vfs_fs_move_page( xptr_t page_xp,
	892	cmd_type_t cmd_type );
	893
	894	/******************************************************************************************
[602]	895	* This function updates the mapper associated to a directory inode identified by the
	896	* <parent> argument, to add a new entry identified by the <dentry> argument.
	897	* The directory inode descriptor and the dentry descriptor are in the same cluster.
[23]	898	* Depending on the file system type, it calls the proper, FS specific function.
[611]	899	* It also updates the dentry descriptor and/or the inode descriptor extensions
[602]	900	* as required by the specific file system type.
	901	* Finally, it synchronously updates the parent directory on IOC device.
	902	*
	903	* It must be executed by a thread running in the cluster containing the parent directory.
[611]	904	* It can be the RPC_VFS_FS_ADD_DENTRY. This function does NOT take any lock.
[23]	905	******************************************************************************************
[602]	906	* @ parent : local pointer on parent (directory) inode.
	907	* @ dentry : local pointer on dentry containing name.
	908	* @ return 0 if success / return -1 if device access failure.
[1]	909	*****************************************************************************************/
[602]	910	error_t vfs_fs_add_dentry( vfs_inode_t * parent,
	911	vfs_dentry_t * dentry );
[1]	912
[23]	913	/******************************************************************************************
[602]	914	* This function updates the mapper associated to a directory inode identified by the
	915	* <parent> argument, to remove an entry identified by the <dentry> argument.
	916	* The directory inode descriptor and the dentry descriptor are in the same cluster.
[23]	917	* Depending on the file system type, it calls the proper, FS specific function.
[602]	918	* Finally, it synchronously updates the parent directory on IOC device.
	919	*
	920	* It must be executed by a thread running in the cluster containing the parent directory.
	921	* It can be the RPC_VFS_VS_REMOVE_DENTRY. This function does NOT take any lock.
[23]	922	******************************************************************************************
[602]	923	* @ parent : local pointer on parent (directory) inode.
	924	* @ dentry : local pointer on dentry containing name.
	925	* @ return 0 if success / return -1 if device access failure.
[1]	926	*****************************************************************************************/
[602]	927	error_t vfs_fs_remove_dentry( vfs_inode_t * parent,
	928	vfs_dentry_t * dentry );
[1]	929
[602]	930	/******************************************************************************************
	931	* This function scan the mapper of an an existing parent inode directory, identified by
	932	* the <parent> argument to find a directory entry identified by the <name> argument,
	933	* and updates both the child inode descriptor, identified by the <child_xp> argument,
	934	* and the associated dentry descriptor :
	935	* - It set the "size", and "extend" fields in inode descriptor.
	936	* - It set the "extend" field in dentry descriptor.
	937	* It is called by the vfs_lookup() function in case of miss.
	938	*
	939	* Depending on the file system type, it calls the relevant, FS specific function.
	940	* It must be called by a thread running in the cluster containing the parent inode.
	941	* This function does NOT take any lock.
	942	******************************************************************************************
	943	* @ parent : local pointer on parent inode (directory).
	944	* @ name : child name.
	945	* @ child_xp : extended pointer on remote child inode (file or directory)
	946	* @ return 0 if success / return ENOENT if not found.
	947	*****************************************************************************************/
[612]	948	error_t vfs_fs_get_dentry( vfs_inode_t * parent,
[602]	949	char * name,
	950	xptr_t child_xp );
[1]	951
[612]	952	/******************************************************************************************
	953	* This function scan the mapper of an an existing parent inode directory, identified by
	954	* the <inode> argument and copy up to <max_dirent> valid dentries to a
	955	* local dirent array, defined by the <array> argument. The <min_dentry> argument defines
	956	* the index of the first dentry to copied to the target dirent array.
	957	* This function returns in the <entries> buffer the number of dentries actually written,
	958	* and signals in the <done> buffer when the last valid entry has been found.
	959	* If the <detailed> argument is true, a dentry/inode couple that does not exist in
	960	* the Inode Tree is dynamically created, and all dirent fiels are documented in the
	961	* dirent array. Otherwise, only the dentry name is documented.
	962	*
	963	* Depending on the file system type, it calls the relevant, FS specific function.
	964	* It must be called by a thread running in the cluster containing the parent inode.
	965	* This function does NOT take any lock.
	966	******************************************************************************************
	967	* @ inode : [in] local pointer on directory inode.
	968	* @ array : [in] local pointer on array of dirents.
	969	* @ max_dirent : [in] max number of slots in dirent array.
	970	* @ min_dentry : [in] index of first dentry to be copied into array.
	971	* @ detailed : [in] dynamic inode creation if true.
	972	* @ entries : [out] number of dentries actually copied into array.
	973	* @ done : [out] Boolean true when last entry found.
	974	* @ return 0 if success / return -1 if failure.
	975	*****************************************************************************************/
	976	error_t vfs_fs_get_user_dir( vfs_inode_t * inode,
	977	struct dirent * array,
	978	uint32_t max_dirent,
	979	uint32_t min_dentry,
	980	bool_t detailed,
	981	uint32_t * entries,
	982	bool_t * done );
	983
[602]	984	/*****************************************************************************************
	985	* This function updates the FS on the IOC device for a given inode identified by
	986	* the <inode> argument. It scan all pages registered in the associated mapper,
	987	* and copies from mapper to device each page marked as dirty.
	988	* WARNING : The target <inode> cannot be a directory, because all modifications in a
	989	* directory are synchronously done on the IOC device by the two vfs_fs_add_dentry()
	990	* and vfs_fs_remove_dentry() functions.
	991	*
	992	* Depending on the file system type, it calls the relevant, FS specific function.
	993	* It must be called by a thread running in the inode cluster.
	994	*****************************************************************************************
	995	* @ inode : local pointer on inode.
	996	* @ return 0 if success / return EIO if failure during device access.
	997	****************************************************************************************/
	998	error_t vfs_fs_sync_inode( struct vfs_inode_s * inode );
	999
	1000	/*****************************************************************************************
[610]	1001	* This function updates the FS defined by the <fs_type> argument on the IOC device
	1002	* for the FAT itself. It scan all clusters registered in the FAT mapper, and copies
	1003	* to device each page marked as dirty.
[602]	1004	*
	1005	* Depending on the file system type, it calls the relevant, FS specific function.
	1006	* It can be called by a thread running in any cluster.
	1007	*****************************************************************************************
[610]	1008	* @ fs_type : specific file system type.
[602]	1009	* @ return 0 if success / return EIO if failure during device access.
	1010	****************************************************************************************/
[610]	1011	error_t vfs_fs_sync_fat( vfs_fs_type_t fs_type );
[602]	1012
	1013	/*****************************************************************************************
[610]	1014	* This function updates the free clusters info on the IOC device for the FS defined
	1015	* by the <fs_type> argument.
[602]	1016	*
	1017	* Depending on the file system type, it calls the relevant, FS specific function.
	1018	* It can be called by a thread running in any cluster.
	1019	*****************************************************************************************
[610]	1020	* @ fs_type : specific file system type.
[602]	1021	* @ return 0 if success / return EIO if failure during device access.
	1022	****************************************************************************************/
[610]	1023	error_t vfs_fs_sync_free_info( vfs_fs_type_t fs_type );
[602]	1024
	1025	/******************************************************************************************
	1026	* This function allocates a free cluster from the FS identified by the <fs_type>
	1027	* argument. It updates the selected FS File Allocation Table.
	1028	*
	1029	* Depending on the file system type, it calls the relevant, FS specific function.
	1030	* It can be called by a thread running in any cluster.
	1031	******************************************************************************************
	1032	* @ fs_type : [in] File System type.
	1033	* @ cluster : [out] cluster index in File system.
	1034	* @ return 0 if success / return -1 if no free cluster
	1035	*****************************************************************************************/
	1036	error_t vfs_fs_cluster_alloc( uint32_t fs_type,
	1037	uint32_t * cluster );
	1038
	1039	/******************************************************************************************
	1040	* This function makes all I/O operations required to release all clusters allocated
	1041	* on IOC device to a given inode, identified by the <inode_xp> argument.
	1042	* Depending on the file system type, it calls the proper, FS specific function.
	1043	* It is called by the vfs_unlink() function.
	1044	* It can be executed by a thread running in any cluster.
	1045	* This function does NOT take any lock.
	1046	******************************************************************************************
	1047	* @ inode_xp : extended pointer on inode.
	1048	* @ return 0 if success / return -1 if device access failure.
	1049	*****************************************************************************************/
	1050	error_t vfs_fs_release_inode( xptr_t inode_xp );
	1051
	1052
[1]	1053	#endif /* _VFS_H_ */

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

Download in other formats: