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

Last change on this file since 625 was 625, checked in by alain, 3 years ago

Fix a bug in the vmm_remove_vseg() function: the physical pages
associated to an user DATA vseg were released to the kernel when
the target process descriptor was in the reference cluster.
This physical pages release should be done only when the page
forks counter value is zero.
All other modifications are cosmetic.

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