Context Navigation

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

Last change on this file since 549 was 484, checked in by viala@…, 6 years ago
[fs] Add void type to function prototypes with no parameter
File size: 46.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>
	32	#include <remote_spinlock.h>
	33	#include <spinlock.h>
	34	#include <list.h>
	35	#include <xlist.h>
	36	#include <slist.h>
	37	#include <bits.h>
	38	#include <xhtab.h>
	39	#include <errno.h>
[407]	40	#include <shared_syscalls.h>
[1]	41	#include <fatfs.h>
	42	#include <ramfs.h>
[23]	43	#include <devfs.h>
[1]	44
	45	/** Forward declarations */
	46
	47	struct vfs_inode_s;
	48	struct vfs_dentry_t;
	49	struct vfs_ctx_t;
	50	struct vfs_file_ref_s;
	51	struct vfs_file_s;
	52
	53	struct vfs_inode_op_s;
	54	struct vfs_dentry_op_s;
	55	struct vfs_file_op_s;
	56	struct vfs_ctx_op_s;
	57
	58	struct vfs_lookup_cmd_s;
	59	struct vfs_lookup_rsp_s;
	60
	61	struct mapper_s;
	62	struct process_s;
	63	struct device_s;
	64	struct vseg_s;
[23]	65	struct page_s;
[1]	66
	67
[23]	68	/******************************************************************************************
	69	* These flags are used to define the working mode of the vfs_lookup() function.
	70	*****************************************************************************************/
[1]	71
[23]	72	#define VFS_LOOKUP_DIR 0x01 /* the searched inode is a directory */
	73	#define VFS_LOOKUP_OPEN 0x02 /* the search is for an open/opendir */
	74	#define VFS_LOOKUP_PARENT 0x04 /* return the parent inode (not the inode itself) */
	75	#define VFS_LOOKUP_CREATE 0x10 /* file must be created if missing */
	76	#define VFS_LOOKUP_EXCL 0x20 /* file cannot previously exist */
[1]	77
[23]	78	/******************************************************************************************
	79	* This define the masks for the POSIX access rights to inodes
	80	*****************************************************************************************/
[1]	81
[23]	82	#define VFS_ISUID 0x0004000
	83	#define VFS_ISGID 0x0002000
	84	#define VFS_ISVTX 0x0001000
[1]	85
	86	#define VFS_IRWXU 0x0000700
	87	#define VFS_IRUSR 0x0000400
	88	#define VFS_IWUSR 0x0000200
	89	#define VFS_IXUSR 0x0000100
[23]	90
[1]	91	#define VFS_IRWXG 0x0000070
	92	#define VFS_IRGRP 0x0000040
	93	#define VFS_IWGRP 0x0000020
	94	#define VFS_IXGRP 0x0000010
[23]	95
[1]	96	#define VFS_IRWXO 0x0000007
	97	#define VFS_IROTH 0x0000004
	98	#define VFS_IWOTH 0x0000002
	99	#define VFS_IXOTH 0x0000001
	100
	101	#define VFS_IREAD VFS_IRUSR
	102	#define VFS_IWRITE VFS_IWUSR
	103	#define VFS_IEXEC VFS_IXUSR
	104
	105
[23]	106	/******************************************************************************************
	107	* This structure defines informations common to all inodes and dentries
	108	* of a given file system. As it is declared a global variable in the kdata segment,
	109	* it is replicated in all clusters and handled as private by each OS intance.
	110	*****************************************************************************************/
[1]	111
[23]	112	typedef enum
	113	{
	114	FS_TYPE_DEVFS = 0,
	115	FS_TYPE_FATFS = 1,
	116	FS_TYPE_RAMFS = 2,
	117
	118	FS_TYPES_NR = 3,
	119	}
	120	vfs_fs_type_t;
[1]	121
[23]	122	typedef enum
	123	{
	124	CTX_ATTR_READ_ONLY = 0x01, /! write access prohibited /
	125	CTX_ATTR_SYNC = 0x10, /! synchronise FS on each write /
	126	}
	127	vfs_ctx_attr_t;
[1]	128
[23]	129	typedef struct vfs_ctx_s
	130	{
	131	vfs_fs_type_t type; /! File System type /
	132	uint32_t attr; /! global attributes for all files in FS /
[188]	133	uint32_t total_clusters; /! total number of clusters on device /
	134	uint32_t cluster_size; /! cluster size on device (bytes) /
	135	xptr_t vfs_root_xp; /! extended pointer on VFS root inode /
[23]	136	spinlock_t lock; /! lock protecting inum allocator /
	137	uint32_t bitmap[BITMAP_SIZE(CONFIG_VFS_MAX_INODES)]; /* inum allocator */
	138	void * extend; /! FS specific context extension /
	139	}
	140	vfs_ctx_t;
[1]	141
	142	/******************************************************************************************
	143	* This structure define a VFS inode.
	144	* It contains an extended pointer on the parent dentry, and (for directory only)
	145	* an hash table xhtab refering all children dentries.
	146	* The <parent> inode is unique for a directory (not hard links for directories).
	147	* For a file, the parent field points to the first dentry who created this inode.
[23]	148	* Syncrhonisation:
[10]	149	* - the main_lock (spinlock) is used during the inode tree traversal or for inode
	150	* modification (add/remove children).
	151	* - the data_lock (rwlock) is used during read/write accesses to the data stored
	152	* in the mapper.
	153	* - the mapper lock (rwlock) is only used during the radix tree traversal to return
[23]	154	* the relevant page for read/write.
[1]	155	*****************************************************************************************/
	156
[23]	157	/* this enum define the VFS inode types values */
	158
[10]	159	typedef enum
	160	{
[430]	161	INODE_TYPE_FILE = 0, /! file /
	162	INODE_TYPE_DIR = 1, /! directory /
	163	INODE_TYPE_FIFO = 2, /! POSIX named pipe /
	164	INODE_TYPE_PIPE = 3, /! POSIX anonymous pipe /
	165	INODE_TYPE_SOCK = 4, /! POSIX socket /
	166	INODE_TYPE_DEV = 5, /! device channel /
	167	INODE_TYPE_SYML = 6, /! symbolic link /
[10]	168	}
	169	vfs_inode_type_t;
	170
[23]	171	/* this enum define the VFS inode attributes values */
	172
[1]	173	typedef enum
	174	{
[23]	175	INODE_ATTR_DIRTY = 0x01, /* modified versus the value on device */
	176	INODE_ATTR_INLOAD = 0x04, /* loading from device in progress */
	177	INODE_ATTR_NEW = 0x08, /* not saved on device yet */
[1]	178	}
[10]	179	vfs_inode_attr_t;
[1]	180
	181	typedef struct vfs_inode_s
	182	{
[188]	183	struct vfs_ctx_s * ctx; /! local pointer on FS context /
	184	uint32_t gc; /! generation counter /
	185	uint32_t inum; /! inode identifier (unique in file system) /
	186	uint32_t attr; /! inode attributes (see above) /
	187	vfs_inode_type_t type; /! inode type (see above) /
	188	uint32_t size; /! number of bytes /
	189	uint32_t links; /! number of alias dentry /
	190	uid_t uid; /! user owner identifier /
	191	gid_t gid; /! group owner identifier /
	192	uint32_t rights; /! access rights /
	193	uint32_t refcount; /! reference counter (all pointers) /
	194	xptr_t parent_xp; /! extended pointer on parent dentry /
	195	xhtab_t children; /! embedded xhtab of children dentries /
	196	remote_rwlock_t data_lock; /! protect read/write to data and to size /
	197	remote_spinlock_t main_lock; /! protect inode tree traversal and modifs /
	198	list_entry_t list; /! member of set of inodes in same cluster /
	199	xlist_entry_t wait_root; /! root of threads waiting on this inode /
	200	struct mapper_s * mapper; /! associated file cache /
	201	void * extend; /! fs_type_specific inode extension /
[1]	202	}
	203	vfs_inode_t;
	204
	205	/******************************************************************************************
	206	* This structure defines a directory entry.
	207	* A dentry contains the name of a remote file/dir, an extended pointer on the
	208	* inode representing this file/dir, and a local pointer on the inode representing
	209	* the parent directory.
	210	*****************************************************************************************/
	211
	212	typedef struct vfs_dentry_s
	213	{
[188]	214	struct vfs_ctx_s * ctx; /! local pointer on FS context /
	215	char name[CONFIG_VFS_MAX_NAME_LENGTH];
	216	uint32_t length; /! name length (bytes) /
	217	uint32_t refcount; /! reference counter (all pointers) /
	218	struct vfs_inode_s * parent; /! local pointer on parent inode /
	219	xptr_t child_xp; /! extended pointer on child inode /
	220	xlist_entry_t list; /! member of list of dentries with same key /
	221	void * extend; /! FS specific extension /
[1]	222	}
	223	vfs_dentry_t;
	224
	225	/******************************************************************************************
[23]	226	* This file structure describes an open file/directory for a given process.
[1]	227	* It is not replicated, and is dynamically allocated in the cluster that contains
	228	* the inode, when a thread makes an open() or opendir() system call.
[459]	229	* It cannot exist a file structure without an inode structure in same cluster.
[266]	230	* As the fd_array (containing extended pointers on the open file descriptors)
[23]	231	* is replicated in all process descriptors, we need a references counter.
[1]	232	*****************************************************************************************/
	233
	234	typedef enum
	235	{
[23]	236	FD_ATTR_READ_ENABLE = 0x01, /! read access possible /
	237	FD_ATTR_WRITE_ENABLE = 0x02, /! write access possible /
	238	FD_ATTR_APPEND = 0x04, /! append on each write /
	239	FD_ATTR_CLOSE_EXEC = 0x08, /! close file on exec /
	240	FD_ATTR_SYNC = 0x10, /! synchronise FS on each write /
	241	FD_ATTR_IS_DIR = 0x20, /! this is a directory /
[1]	242	}
[23]	243	vfs_file_attr_t;
[1]	244
	245	typedef struct vfs_file_s
	246	{
[23]	247	struct vfs_ctx_s * ctx; /! local pointer on FS context. /
[1]	248	uint32_t gc; /! generation counter /
[23]	249	vfs_file_attr_t attr; /! file attributes bit vector (see above) /
	250	vfs_inode_type_t type; /! same type as inode /
[1]	251	uint32_t offset; /! seek position in file /
[23]	252	uint32_t refcount; /! all pointers on this file descriptor /
	253	remote_rwlock_t lock; /! protect offset modifications /
[1]	254	struct mapper_s * mapper; /! associated file cache /
	255	struct vfs_inode_s * inode; /! local pointer on associated inode /
[23]	256	void * extend; /! FS specific extension /
[1]	257	}
	258	vfs_file_t;
	259
	260
	261	/*****************************************************************************************/
	262	/****************** VFS global functions *********************************************/
	263	/*****************************************************************************************/
	264
	265
	266	/******************************************************************************************
[23]	267	* This function mount a given file system type for a given process TODO.
[1]	268	*****************************************************************************************/
	269	error_t vfs_mount_fs_root( struct device_s * device,
	270	uint32_t fs_type,
	271	struct process_s * process );
	272
	273
	274	/*****************************************************************************************/
[188]	275	/***************** VFS Context related functions **************************************/
[1]	276	/*****************************************************************************************/
	277
	278	/******************************************************************************************
[188]	279	* This function initialise a (statically allocated) VFS context in local cluster.
	280	******************************************************************************************
	281	* @ fs_type : file system type.
	282	* @ attr : global attributes (for all files in FS.
	283	* @ total_clusters : total number of clusters on device.
	284	* @ cluster_size : cluster size on device (bytes).
	285	* @ vfs_root_xp : extended pointer on VFS root inode.
	286	* @ extend : fs_type_specific extension.
	287	*****************************************************************************************/
	288	void vfs_ctx_init( vfs_fs_type_t type,
	289	uint32_t attr,
	290	uint32_t total_clusters,
	291	uint32_t cluster_size,
	292	xptr_t vfs_root_xp,
	293	void * extend );
	294
	295	/******************************************************************************************
[1]	296	* This function allocates an inode identifier from the local cluster inum allocator.
	297	* The inum respects a fixed format:
	298	* - the 16 MSB bits contain the cluster identifier : cxy
	299	* - the 16 LSB bits contains the local inode identifier : lid
	300	******************************************************************************************
	301	* @ ctx : local pointer on file system context.
	302	* @ inum : [ou] buffer for allocated inode identifier.
	303	* @ return 0 if success / return non-zero if error.
	304	*****************************************************************************************/
	305	error_t vfs_ctx_inum_alloc( vfs_ctx_t * ctx,
	306	uint32_t * inum );
	307
	308	/******************************************************************************************
	309	* This function release an inode identifier.
	310	******************************************************************************************
	311	* @ ctx : local pointer on file system context.
	312	* @ inum : released inode identifier.
	313	*****************************************************************************************/
	314	void vfs_ctx_inum_release( vfs_ctx_t * ctx,
	315	uint32_t inum );
	316
	317
	318
	319
	320	/*****************************************************************************************/
	321	/******************* Inode related functions *****************************************/
	322	/*****************************************************************************************/
	323
	324	/******************************************************************************************
	325	* This function allocates memory from local cluster for an inode descriptor and the
	326	* associated mapper. It initialise these descriptors from arguments values.
	327	* The parent dentry must have been previously created.
	328	* If the client thread is not running in the cluster containing this inode,
	329	* it must use the rpc_vfs_inode_create_client() function.
	330	******************************************************************************************
	331	* @ dentry_xp : extended pointer on associated dentry (in parent inode cluster).
[23]	332	* @ fs_type : file system type.
	333	* @ inode_type : inode type.
[188]	334	* @ extend : local pointer on vs_type_specific extension.
[1]	335	* @ attr : inode attributes.
[23]	336	* @ rights : inode access rights.
[1]	337	* @ uid : user owner ID.
	338	* @ gid : group owner ID.
	339	* @ inode_xp : [out] buffer for extended pointer on created inode.
[459]	340	* @ return 0 if success / return ENOMEM or EINVAL if error.
[1]	341	*****************************************************************************************/
[23]	342	error_t vfs_inode_create( xptr_t dentry_xp,
	343	vfs_fs_type_t fs_type,
	344	vfs_inode_type_t inode_type,
[188]	345	void * extend,
[23]	346	uint32_t attr,
	347	uint32_t rights,
	348	uid_t uid,
	349	gid_t gid,
	350	xptr_t * inode_xp );
[1]	351
	352	/******************************************************************************************
	353	* This function releases memory allocated to an inode descriptor.
	354	* It must be executed by a thread running in the cluster containing the inode,
[459]	355	* and the inode refcount must be zero. If the client thread is not running in the owner
	356	* cluster, you must use the rpc_vfs_inode_destroy_client() function.
[1]	357	******************************************************************************************
	358	* @ inode : local pointer on inode descriptor.
[459]	359	* @ return 0 if success / return EINVAL if error.
[1]	360	*****************************************************************************************/
[459]	361	error_t vfs_inode_destroy( vfs_inode_t * inode );
[1]	362
[238]	363	/******************************************************************************************
	364	* This function scan an existing parent inode directory, identified by the <parent>
	365	* argument to find a directory entry identified by the <name> argument, and update
	366	* the remote child inode, identified by the <child_xp> argument.
	367	* Depending on the file system type, it calls the relevant, FS specific function,
	368	* to scan the directory, and set the "type", "size", and "extend" fields.
	369	* It must be called by a thread running in the cluster containing the parent inode.
	370	******************************************************************************************
	371	* @ parent : local pointer on parent inode (directory).
	372	* @ name : child name.
	373	* @ child_xp : extended pointer on remote child inode (file or directory)
	374	* @ return 0 if success / return ENOENT if not found.
	375	*****************************************************************************************/
	376	error_t vfs_inode_load( vfs_inode_t * parent,
	377	char * name,
	378	xptr_t child_xp );
	379
[1]	380	/******************************************************************************************
[23]	381	* This function atomically increment/decrement the inode refcount.
[1]	382	* It can be called by any thread running in any cluster.
	383	*****************************************************************************************/
	384	void vfs_inode_remote_up( xptr_t inode_xp );
	385	void vfs_inode_remote_down( xptr_t inode_xp );
	386
	387	/******************************************************************************************
	388	* This function returns the <size> of a file/dir from a remote inode,
	389	* taking the remote_rwlock protecting <size> in READ_MODE.
	390	*****************************************************************************************
	391	* @ inode_xp : extended pointer on the remote inode.
	392	* @ return the current size.
	393	*****************************************************************************************/
	394	uint32_t vfs_inode_get_size( xptr_t inode_xp );
	395
	396	/******************************************************************************************
	397	* This function set the <size> of a file/dir to a remote inode,
	398	* taking the remote_rwlock protecting <size> in WRITE_MODE.
	399	*****************************************************************************************
	400	* @ inode_xp : extended pointer on the remote inode.
	401	* @ size : value to be written.
	402	*****************************************************************************************/
	403	void vfs_inode_set_size( xptr_t inode_xp,
	404	uint32_t size );
	405
	406	/******************************************************************************************
	407	* This function takes the main lock of a remote inode.
	408	* This lock protect all inode fiels, including the children dentries.
	409	*****************************************************************************************
	410	* @ inode_xp : extended pointer on the remote inode.
	411	*****************************************************************************************/
[101]	412	void vfs_inode_lock( xptr_t inode_xp );
[1]	413
	414	/******************************************************************************************
	415	* This function releases the main lock of a remote inode.
	416	* This lock protect all inode fiels, including the children dentries.
	417	*****************************************************************************************
	418	* @ inode_xp : extended pointer on the remote inode.
	419	*****************************************************************************************/
[101]	420	void vfs_inode_unlock( xptr_t inode_xp );
[1]	421
	422	/******************************************************************************************
[409]	423	* This debug function copies the name of a remote inode identified by the <inode_xp>
	424	* argument to a local buffer identified by the <name> argument.
	425	* The local buffer size must be at least CONFIG_VFS_MAX_NAME_LENGTH.
[101]	426	*****************************************************************************************
	427	* @ inode_xp : extended pointer on the remote inode.
[409]	428	* @ name : local buffer pointer.
[1]	429	*****************************************************************************************/
[409]	430	void vfs_inode_get_name( xptr_t inode_xp,
	431	char * name );
[1]	432
[204]	433
[1]	434	/*****************************************************************************************/
	435	/*************** Dentry related functions ********************************************/
	436	/*****************************************************************************************/
	437
	438	/******************************************************************************************
	439	* This function allocates memory from local cluster for a dentry descriptor,
	440	* initialises it from arguments values, and returns the extended pointer on dentry.
	441	* The inode field is not initialized, because the inode does not exist yet.
	442	* If the client thread is not running in the target cluster for this inode,
	443	* it must use the rpc_dentry_create_client() function.
	444	******************************************************************************************
[23]	445	* @ fs_type : file system type.
[1]	446	* @ name : directory entry file/dir name.
	447	* @ parent : local pointer on parent inode.
[23]	448	* @ dentry_xp : [out] buffer for extended pointer on created dentry.
[1]	449	* @ return 0 if success / return ENOMEM or EINVAL if error.
	450	*****************************************************************************************/
[23]	451	error_t vfs_dentry_create( vfs_fs_type_t fs_type,
	452	char * name,
	453	vfs_inode_t * parent,
	454	xptr_t * dentry_xp );
[1]	455
	456	/******************************************************************************************
	457	* This function releases memory allocated to a dentry descriptor.
	458	* It must be executed by a thread running in the cluster containing the dentry,
[459]	459	* and the dentry refcount must be zero. If the client thread is not running in the owner
	460	* cluster, you must use the rpc_dentry_destroy_client() function.
[1]	461	******************************************************************************************
	462	* @ dentry : local pointer on dentry descriptor.
[459]	463	* @ return 0 if success / return EINVAL if error.
[1]	464	*****************************************************************************************/
[459]	465	error_t vfs_dentry_destroy( vfs_dentry_t * dentry );
[1]	466
	467	/******************************************************************************************
[23]	468	* These functions atomically increment/decrement the dentry refcount.
[1]	469	* It can be called by any thread running in any cluster.
	470	*****************************************************************************************/
	471	void vfs_dentry_remote_up( xptr_t dentry_xp );
[23]	472	void vfs_dentry_remote_down( xptr_t dentry_xp );
[1]	473
[23]	474
	475	/*****************************************************************************************/
	476	/********************** File descriptor related functions ****************************/
	477	/*****************************************************************************************/
	478
[1]	479	/******************************************************************************************
[23]	480	* This function allocates memory and initializes a new local file descriptor.
	481	* It must be executed in the cluster containing the inode.
	482	* If the client thread is not running in the owner cluster, it must use the
	483	* rpc_vfs_file_create_client() function.
	484	******************************************************************************************
	485	* @ inode : local pointer on associated inode.
	486	* @ attr : file descriptor attributes.
	487	* @ file_xp : [out] buffer for extended pointer on created file descriptor.
	488	* @ return 0 if success / return ENOMEM if error.
[1]	489	*****************************************************************************************/
[23]	490	error_t vfs_file_create( vfs_inode_t * inode,
	491	uint32_t attr,
	492	xptr_t * file_xp );
[1]	493
[23]	494	/******************************************************************************************
	495	* This function releases memory allocated to a local file descriptor.
	496	* It must be executed by a thread running in the cluster containing the inode,
	497	* and the file refcount must be zero.
	498	* If the client thread is not running in the owner cluster, it must use the
	499	* rpc_vfs_file_destroy_client() function.
	500	******************************************************************************************
	501	* @ file : local pointer on file descriptor.
	502	*****************************************************************************************/
	503	void vfs_file_destroy( vfs_file_t * file );
[1]	504
[23]	505	/******************************************************************************************
	506	* These functions increment (resp. decrement) the count field in a remote file
	507	* descriptor, using a remote_atomic access.
	508	*****************************************************************************************/
	509	void vfs_file_count_up ( xptr_t file_xp );
	510	void vfs_file_count_down( xptr_t file_xp );
	511
	512
	513
[1]	514	/*****************************************************************************************/
[23]	515	/***************** Inode-Tree related functions **************************************/
[1]	516	/*****************************************************************************************/
	517
	518	/******************************************************************************************
[188]	519	* This function randomly selects a cluster for a new inode.
	520	******************************************************************************************
	521	* @ returns the selected cluster identifier.
	522	*****************************************************************************************/
[484]	523	cxy_t vfs_cluster_random_select( void );
[188]	524
	525	/******************************************************************************************
[1]	526	* This function returns in a kernel buffer allocated by the caller function,
	527	* the pathname of a file/dir identified by an extended pointer on the inode.
	528	* It traverse the Inode Tree from the target node to the root.
	529	* It can be called by any thread running in any cluster.
	530	******************************************************************************************
	531	* @ inode_xp : pointer on inode descriptor.
	532	* @ buffer : kernel buffer for pathname (must be allocated by caller).
	533	* @ size : max number of characters in buffer.
	534	* @ return 0 if success / return EINVAL if buffer too small.
	535	*****************************************************************************************/
	536	error_t vfs_get_path( xptr_t inode_xp,
	537	char * buffer,
	538	uint32_t max_size );
	539
	540	/******************************************************************************************
	541	* This function takes a pathname (absolute or relative to cwd) and returns an extended
[23]	542	* pointer on the associated inode.
[459]	543	* - If a given directory name in the path is not found in the inode tree, it try to load
	544	* the missing dentry/inode couple, from informations found in the parent directory.
[23]	545	* - If this directory entry does not exist on device, it returns an error.
	546	* - If the the file identified by the pathname does not exist on device but the
	547	* flag CREATE is set, the inode is created.
	548	* - If the the file identified by the pathname exist on device but both flags EXCL
	549	* and CREATE are set, an error is returned.
[1]	550	******************************************************************************************
[23]	551	* @ cwd_xp : extended pointer on current directory (for relative path).
	552	* @ pathname : path in kernel space (can be relative or absolute).
	553	* @ lookup_mode : flags defining the working mode (defined above in this file).
[238]	554	* @ inode_xp : [out] buffer for extended pointer on searched inode.
[407]	555	* @ return 0 if success / ENOENT if inode not found , EACCES if permisson denied,
	556	* EAGAIN if a new complete lookup must be made
[1]	557	*****************************************************************************************/
[23]	558	error_t vfs_lookup( xptr_t cwd_xp,
	559	char * pathname,
	560	uint32_t lookup_mode,
	561	xptr_t * inode_xp );
[1]	562
	563	/******************************************************************************************
	564	* This function creates a new couple dentry/inode, and insert it in the Inode-Tree.
[407]	565	* It can be executed by any thread running in any cluster (can be different from both
[296]	566	* the child cluster and the parent cluster), as it uses the rpc_dentry_create_client()
	567	* and rpc_inode_create client() if required. This is done in three steps:
[204]	568	* 1) The dentry is created in the cluster containing the existing <parent_xp> inode.
	569	* The new dentry name is defined by the <name> argument.
	570	* 2) The inode and its associated mapper are created in cluster identified by <child_cxy>.
	571	* The new inode and the parent inode can have different FS types.
[238]	572	* 3) The "child_xp" field in created dentry (pointing on the created inode) is updated.
[1]	573	******************************************************************************************
[188]	574	* @ child_cxy : target cluster for child inode.
[23]	575	* @ inode_type : new inode type
	576	* @ fs_type : new inode FS type.
[1]	577	* @ parent_xp : extended pointer on parent inode.
	578	* @ name : new directory entry name.
[188]	579	* @ extend : fs_type_specific inode extension.
[1]	580	* @ child_xp : [out] buffer for extended pointer on child inode.
[204]	581	* @ return 0 if success / ENOMEM if dentry or inode cannot be created.
[1]	582	*****************************************************************************************/
[188]	583	error_t vfs_add_child_in_parent( cxy_t child_cxy,
	584	vfs_inode_type_t inode_type,
[23]	585	vfs_fs_type_t fs_type,
	586	xptr_t parent_xp,
	587	char * name,
[188]	588	void * extend,
[23]	589	xptr_t * child_xp );
[1]	590
	591	/******************************************************************************************
[23]	592	* This function removes a couple dentry/inode from the Inode-Tree, and remove it from
	593	* the external device.
[1]	594	******************************************************************************************
	595	* @ child_xp : extended pointer on removed inode.
	596	*****************************************************************************************/
[459]	597	error_t vfs_remove_child_from_parent( xptr_t inode_xp );
[1]	598
[188]	599	/******************************************************************************************
	600	* This recursive function diplays a complete inode/dentry sub-tree.
	601	* Any inode can be selected as the sub-tree root.
[238]	602	* TODO this function is not protected against a concurrent inode/dentry removal...
[188]	603	******************************************************************************************
	604	* @ inode_xp : extended pointer on sub-tree root inode.
	605	*****************************************************************************************/
	606	void vfs_display( xptr_t inode_xp );
[23]	607
	608
	609
	610
	611
[1]	612	/*****************************************************************************************/
[23]	613	/**************** File access API ****************************************************/
[1]	614	/*****************************************************************************************/
	615
	616	/******************************************************************************************
	617	* This function allocates a vfs_file_t structure in the cluster containing the inode
[407]	618	* associated to the file identified by the <cwd_xp> & <path> arguments.
	619	* It initializes it, register it in the reference process fd_array identified by the
	620	* <process> argument, and returns both the extended pointer on the file descriptor,
	621	* and the allocated index in the fd_array.
[1]	622	* The pathname can be relative to current directory or absolute.
[23]	623	* If the inode does not exist in the inode cache, it try to find the file on the mounted
[1]	624	* device, and creates an inode on a pseudo randomly selected cluster if found.
	625	* It the requested file does not exist on device, it creates a new inode if the
[407]	626	* O_CREAT flag is set, and return an error otherwise.
[1]	627	******************************************************************************************
[407]	628	* @ process : local pointer on local process descriptor copy.
[23]	629	* @ path : file pathname (absolute or relative to current directory).
[407]	630	* @ flags : defined above.
[23]	631	* @ mode : access rights (as defined by chmod)
	632	* @ file_xp : [out] buffer for extended pointer on created remote file descriptor.
	633	* @ file_id : [out] buffer for created file descriptor index in reference fd_array.
[1]	634	* @ return 0 if success / return non-zero if error.
	635	*****************************************************************************************/
[407]	636	error_t vfs_open( struct process_s * process,
	637	char * path,
	638	uint32_t flags,
	639	uint32_t mode,
	640	xptr_t * file_xp,
	641	uint32_t * file_id );
[1]	642
	643	/******************************************************************************************
[313]	644	* This function moves <size> bytes between a remote file mapper, identified by the
	645	* <file_xp> argument, and a - possibly distributed - user space <buffer>, taken into
	646	* account the offset in <file_xp>. The transfer direction is defined by <to_buffer>.
[407]	647	* It is called by the sys_read() and sys_write() functions.
[23]	648	******************************************************************************************
[265]	649	* @ to_buffer : mapper -> buffer if true / buffer -> mapper if false.
[23]	650	* @ file_xp : extended pointer on the remote file descriptor.
[313]	651	* @ buffer : user space pointer on buffer (can be physically distributed).
[1]	652	* @ size : requested number of bytes from offset.
[407]	653	* @ returns number of bytes actually moved if success / -1 if error.
[1]	654	*****************************************************************************************/
[407]	655	int vfs_user_move( bool_t to_buffer,
	656	xptr_t file_xp,
	657	void * buffer,
	658	uint32_t size );
[1]	659
	660	/******************************************************************************************
[317]	661	* This function moves <size> bytes between a remote file mapper, identified by the
	662	* <file_xp> argument, and a - possibly remote - kernel <buffer_xp>, taken into
	663	* account the offset in <file_xp>. The transfer direction is defined by <to_buffer>.
[407]	664	* It is called by the elf_load_process() function.
[317]	665	******************************************************************************************
	666	* @ to_buffer : mapper -> buffer if true / buffer -> mapper if false.
	667	* @ file_xp : extended pointer on the remote file descriptor.
	668	* @ buffer_xp : user space pointer on buffer (can be physically distributed).
	669	* @ size : requested number of bytes from offset.
[407]	670	* @ returns 0 if success / -1 if error.
[317]	671	*****************************************************************************************/
	672	error_t vfs_kernel_move( bool_t to_buffer,
	673	xptr_t file_xp,
	674	xptr_t buffer_xp,
	675	uint32_t size );
	676
	677	/******************************************************************************************
[1]	678	* This function set a new value in the offset of the open file descriptor <file_xp>.
	679	* This value depends on the <whence> argument:
	680	* - if VFS_SEEK_SET, new value is <offset>
	681	* - if VFS_SEEK_CUR, new value is current_offset + <offset>
	682	* - if VFS_SEEK_END, new value is file_size + <offset>
	683	******************************************************************************************
	684	* @ file_xp : extended pointer on the remote open file descriptor.
	685	* @ offset : local pointer on source kernel buffer.
	686	* @ whence : VFS_SEEK_SET / VFS_SEEK_CUR / VFS_SEEK_END.
	687	* @ new_offset : [out] buffer for new offset value.
	688	* @ returns 0 if success / -1 if error.
	689	*****************************************************************************************/
	690	error_t vfs_lseek( xptr_t file_xp,
	691	uint32_t offset,
	692	uint32_t whence,
	693	uint32_t * new_offset );
	694
	695	/******************************************************************************************
[459]	696	* This function close the -non-replicated- file descriptor identified by the <file_xp>
	697	* and <file_id> arguments.
	698	* 1) All entries in the fd_array copies are directly reset by the calling thread,
[23]	699	* using remote accesses.
	700	* 2) The memory allocated to file descriptor in cluster containing the inode is released.
	701	* It requires a RPC if cluster containing the file descriptor is remote.
[1]	702	******************************************************************************************
[459]	703	* @ file_xp : extended pointer on the file descriptor in owner cluster.
[23]	704	* @ file_id : file descriptor index in fd_array.
	705	* @ returns 0 if success / -1 if error.
[1]	706	*****************************************************************************************/
[23]	707	error_t vfs_close( xptr_t file_xp,
	708	uint32_t file_id );
[1]	709
	710	/******************************************************************************************
[23]	711	* This function remove from the file system a directory entry identified by the
	712	* <cwd_xp> & <path> arguments.
[1]	713	******************************************************************************************
[23]	714	* @ cwd_xp : extended pointer on the current working directory file descriptor.
[1]	715	* @ path : pathname (absolute or relative to current directory).
[23]	716	* @ returns 0 if success / -1 if error.
[1]	717	*****************************************************************************************/
	718	error_t vfs_unlink( xptr_t cwd_xp,
	719	char * path );
	720
	721	/******************************************************************************************
[23]	722	* This function returns, in the structure pointed by the <k_stat> kernel pointer,
	723	* various informations on the file descriptor identified by the <file_xp> argument.
	724	* TODO not implemented yet...
	725	******************************************************************************************
	726	* @ file_xp : extended pointer on the file descriptor of the searched directory .
[407]	727	* @ k_stat : local pointer on the stat structure in kernel space.
[23]	728	* @ returns 0 if success / -1 if error.
[1]	729	*****************************************************************************************/
[407]	730	error_t vfs_stat( xptr_t file_xp,
	731	struct stat * k_stat );
[1]	732
	733	/******************************************************************************************
[23]	734	* This function returns, in the structure pointed by the <k_dirent> kernel pointer,
	735	* various infos on the directory entry currently pointed by the <file_xp> file descriptor.
	736	* TODO not implemented yet...
	737	******************************************************************************************
	738	* @ file_xp : extended pointer on the file descriptor of the searched directory .
[407]	739	* @ k_dirent : local pointer on the dirent structure in kernel space.
[23]	740	* @ returns 0 if success / -1 if error.
[1]	741	*****************************************************************************************/
[407]	742	error_t vfs_readdir( xptr_t file_xp,
	743	struct dirent * k_dirent );
[1]	744
	745	/******************************************************************************************
[23]	746	* This function creates a new inode and associated dentry for the directory defined
	747	* by the <cwd_xp> & <path> arguments.
	748	* TODO not implemented yet...
	749	******************************************************************************************
	750	* @ cwd_xp : extended pointer on the current working directory file descriptor.
	751	* @ path : pathname (absolute or relative to current directory).
	752	* @ mode : access rights (as defined by chmod)
	753	* @ returns 0 if success / -1 if error.
[1]	754	*****************************************************************************************/
[23]	755	error_t vfs_mkdir( xptr_t cwd_xp,
	756	char * path,
	757	uint32_t mode );
[1]	758
	759	/******************************************************************************************
[23]	760	* This function remove a directory identified by the <cwd_xp / path> arguments
	761	* from the file system.
	762	* TODO not implemented yet...
	763	******************************************************************************************
	764	* @ cwd_xp : extended pointer on the current working directory file descriptor.
	765	* @ path : pathname (absolute or relative to current directory).
	766	* @ returns 0 if success / -1 if error.
[1]	767	*****************************************************************************************/
[23]	768	error_t vfs_rmdir( xptr_t cwd_xp,
	769	char * path );
[1]	770
	771	/******************************************************************************************
[23]	772	* This function makes the directory identified by <cwd_xp / path> arguments to become
	773	* the working directory for the calling process.
	774	******************************************************************************************
	775	* @ cwd_xp : extended pointer on current directory file descriptor (relative path).
	776	* @ path : file pathname (absolute or relative to current directory).
	777	* return 0 if success / -1 if error.
[1]	778	*****************************************************************************************/
[23]	779	error_t vfs_chdir( xptr_t cwd_xp,
	780	char * path );
[1]	781
	782	/******************************************************************************************
[23]	783	* This function change the access rigths for the file identified by the <cwd_xp / path>
	784	* arguments. The new access rights are defined by the <mode> argument value.
	785	******************************************************************************************
	786	* @ cwd_xp : extended pointer on current directory file descriptor (relative path).
	787	* @ path : file pathname (absolute or relative to current directory).
	788	* @ mode : access rights new value.
	789	* return 0 if success / -1 if error.
[1]	790	*****************************************************************************************/
[23]	791	error_t vfs_chmod( xptr_t cwd_xp,
	792	char * path,
	793	uint32_t mode );
[1]	794
	795	/******************************************************************************************
[23]	796	* This function creates a named FIFO file.
	797	* TODO not implemented yet
	798	******************************************************************************************
	799	* @ path : FIFO pathname (absolute or relative to current directory).
	800	* @ cwd_xp : extended pointer on the current working directory file descriptor.
	801	* @ mode : access rights new value.
[1]	802	*****************************************************************************************/
[23]	803	error_t vfs_mkfifo( xptr_t cwd_xp,
	804	char * path,
	805	uint32_t mode );
[1]	806
	807
	808	/*****************************************************************************************/
[23]	809	/**************** Mapper access API **************************************************/
[1]	810	/*****************************************************************************************/
	811
[23]	812	/******************************************************************************************
[238]	813	* This function makes an I/O operation to move one page to/from device from/to the mapper.
	814	* It is used in case of MISS on the mapper, or when a dirty page in the mapper must
	815	* be updated in the File System.
[23]	816	* Depending on the file system type, it calls the proper, FS specific function.
	817	* It must be executed by a thread running in the cluster containing the mapper.
	818	* The mapper pointer is obtained from the page descriptor.
	819	* It takes the mapper lock before launching the IO operation.
	820	******************************************************************************************
[238]	821	* @ page : local pointer on the page descriptor.
	822	* @ to_mapper : transfer direction.
[23]	823	* @ returns 0 if success / return EINVAL if it cannot access the external device.
[1]	824	*****************************************************************************************/
[238]	825	error_t vfs_mapper_move_page( struct page_s * page,
	826	bool_t to_mapper );
[1]	827
[23]	828	/******************************************************************************************
[459]	829	* This function makes the I/O operations required to move, from device to mapper,
	830	* all pages covering a given inode, identified by the <inode> argument. The target
	831	* inode can be a directory or a file, but this function is mainly used to load (prefetch)
	832	* a complete directory to the mapper.
[23]	833	* Depending on the file system type, it calls the proper, FS specific function.
	834	* It must be executed by a thread running in the cluster containing the mapper.
[238]	835	* The mapper pointer is obtained from the inode descriptor.
[23]	836	* It takes the mapper lock before launching the IO operation.
	837	******************************************************************************************
[238]	838	* @ inode : local pointer on inode.
	839	* @ return 0 if success / return EIO if device access failure.
[1]	840	*****************************************************************************************/
[238]	841	error_t vfs_mapper_load_all( vfs_inode_t * inode );
[1]	842
	843
	844	#endif /* _VFS_H_ */

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

Download in other formats: