The LXR Cross Referencer for SOS root directory/ sos/ fs.c	[ source navigation ] [ diff markup ] [ identifier search ] [ general search ]
	Article: [ 1 ] [ 2 ] [ 3 ] [ 4 ] [ 5 ] [ 6 ] [ 6.5 ] [ 7 ] [ 7.5 ] [ 8 ] [ 9 ] [ 9.5 ]

---

Diff markup

Differences between /sos/fs.c (Article 9) and /sos/fs.c (Article 9.5)

---

 /* Copyright (C) 2005      David Decotigny     !!  /* Copyright (C) 2005,2006 David Decotigny
    Copyright (C) 2000-2005 The KOS Team (Thoma        Copyright (C) 2000-2005 The KOS Team (Thomas Petazzoni, David
                            Decotigny, Julien M                                Decotigny, Julien Munier)
                                                    
    This program is free software; you can redi        This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU Genera        modify it under the terms of the GNU General Public License
    as published by the Free Software Foundatio        as published by the Free Software Foundation; either version 2
    of the License, or (at your option) any lat        of the License, or (at your option) any later version.
                                                       
    This program is distributed in the hope tha        This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the         but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details        GNU General Public License for more details.
                                                       
    You should have received a copy of the GNU         You should have received a copy of the GNU General Public License
    along with this program; if not, write to t        along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place - Suite 3        Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
    USA.                                               USA. 
 */                                                 */
                                                    
 #include <sos/assert.h>                            #include <sos/assert.h>
 #include <sos/list.h>                              #include <sos/list.h>
 #include <sos/kmem_slab.h>                         #include <sos/kmem_slab.h>
 #include <sos/kmalloc.h>                           #include <sos/kmalloc.h>
 #include "chardev.h"                               #include "chardev.h"
                                                    
 #include "fs.h"                                    #include "fs.h"
                                                    
                                                    
 /** List of available filesystems registered i     /** List of available filesystems registered in the system */
 static struct sos_fs_manager_type * fs_list =      static struct sos_fs_manager_type * fs_list = NULL;
                                                    
 /** Last UID delivered for the FS instances */     /** Last UID delivered for the FS instances */
 static sos_ui64_t last_fs_instance_uid;            static sos_ui64_t last_fs_instance_uid;
                                                    
                                                    
 /* *******************************************     /* **********************************************************
  * Forward declarations                             * Forward declarations
  */                                                 */
 static sos_ret_t fs_fetch_node(struct sos_fs_m     static sos_ret_t fs_fetch_node(struct sos_fs_manager_instance *fs,
                                sos_ui64_t stor                                    sos_ui64_t storage_location,
                                struct sos_fs_n                                    struct sos_fs_node ** result_fsnode);
                                                    
 static sos_ret_t                                   static sos_ret_t
 fs_allocate_node(struct sos_fs_manager_instanc     fs_allocate_node(struct sos_fs_manager_instance * fs,
                  sos_fs_node_type_t type,                           sos_fs_node_type_t type,
                  sos_ui32_t flags,                                  sos_ui32_t flags,
                  const struct sos_process * cr                      const struct sos_process * creator,
                  sos_ui32_t access_rights,                          sos_ui32_t access_rights,
                  struct sos_fs_node ** result_                      struct sos_fs_node ** result_fsnode);
                                                    
 static sos_ret_t mark_dirty_fsnode(struct sos_     static sos_ret_t mark_dirty_fsnode(struct sos_fs_node * fsnode,
                                    sos_bool_t                                         sos_bool_t force_sync);
                                                    
 static sos_ret_t sos_fs_sync_node(struct sos_f     static sos_ret_t sos_fs_sync_node(struct sos_fs_node * fsnode);
                                                    
 static sos_ret_t sos_fs_sync_fs(struct sos_fs_     static sos_ret_t sos_fs_sync_fs(struct sos_fs_manager_instance * fs);
                                                    
 static sos_ret_t                                   static sos_ret_t
 fs_lookup_node(const struct sos_fs_pathname *      fs_lookup_node(const struct sos_fs_pathname * path,
                sos_bool_t follow_symlinks,                        sos_bool_t follow_symlinks,
                const struct sos_fs_nscache_nod                    const struct sos_fs_nscache_node * root_nsnode,
                const struct sos_fs_nscache_nod                    const struct sos_fs_nscache_node * start_nsnode,
                struct sos_fs_nscache_node ** r                    struct sos_fs_nscache_node ** result_nsnode,
                struct sos_fs_pathname * result                    struct sos_fs_pathname * result_remaining_path,
                int lookup_recursion_level);                       int lookup_recursion_level);
                                                    
 static sos_ret_t                                   static sos_ret_t
 fs_resolve_symlink(const struct sos_fs_nscache     fs_resolve_symlink(const struct sos_fs_nscache_node * root_nsnode,
                    const struct sos_fs_nscache                        const struct sos_fs_nscache_node * symlink_nsnode,
                    struct sos_fs_nscache_node                         struct sos_fs_nscache_node ** target_nsnode,
                    int lookup_recursion_level)                        int lookup_recursion_level);
                                                    
 static sos_ret_t                                   static sos_ret_t
 fs_register_child_node(const struct sos_proces     fs_register_child_node(const struct sos_process * creator,
                        struct sos_fs_nscache_n                            struct sos_fs_nscache_node * parent_nsnode,
                        const struct sos_fs_pat                            const struct sos_fs_pathname * name,
                        struct sos_fs_node * fs                            struct sos_fs_node * fsnode,
                        sos_ui32_t flags,                                  sos_ui32_t flags,
                        struct sos_fs_nscache_n                            struct sos_fs_nscache_node ** result_nsnode);
                                                    
 static sos_ret_t                                   static sos_ret_t
 fs_create_child_node(struct sos_fs_nscache_nod     fs_create_child_node(struct sos_fs_nscache_node * parent_nsnode,
                      const struct sos_fs_pathn                          const struct sos_fs_pathname * name,
                      sos_fs_node_type_t type,                           sos_fs_node_type_t type,
                      sos_ui32_t flags,                                  sos_ui32_t flags,
                      const struct sos_process                           const struct sos_process * creator,
                      sos_ui32_t access_rights,                          sos_ui32_t access_rights,
                      struct sos_fs_nscache_nod                          struct sos_fs_nscache_node ** result_nsnode);
                                                    
 static sos_ret_t                                   static sos_ret_t
 fs_connect_existing_child_node(const struct so     fs_connect_existing_child_node(const struct sos_process * creator,
                                struct sos_fs_n                                    struct sos_fs_nscache_node * parent_nsnode,
                                const struct so                                    const struct sos_fs_pathname * name,
                                struct sos_fs_n                                    struct sos_fs_nscache_node * nsnode);
                                                    
 static sos_ret_t                                   static sos_ret_t
 fs_create_node(const struct sos_fs_pathname *      fs_create_node(const struct sos_fs_pathname * _path,
                const struct sos_process * crea                    const struct sos_process * creator,
                sos_ui32_t access_rights,                          sos_ui32_t access_rights,
                sos_fs_node_type_t type,                           sos_fs_node_type_t type,
                struct sos_fs_nscache_node ** r                    struct sos_fs_nscache_node ** result_nsnode);
                                                    
 static sos_ret_t                                   static sos_ret_t
 fs_remove_node(const struct sos_process * acto     fs_remove_node(const struct sos_process * actor,
                struct sos_fs_nscache_node * ns                    struct sos_fs_nscache_node * nsnode);
                                                    
                                                    
 /* *******************************************     /* **********************************************************
  * Basic low-level memory & co related functio      * Basic low-level memory & co related functions
  */                                                 */
                                                    
 sos_ret_t                                          sos_ret_t
 sos_fs_subsystem_setup(const char * root_devic     sos_fs_subsystem_setup(const char * root_device,
                        const char * fsname,                               const char * fsname,
                        const char * mount_args                            const char * mount_args,
                        struct sos_fs_manager_i                            struct sos_fs_manager_instance ** result_rootfs)
 {                                                  {
   sos_ret_t retval;                                  sos_ret_t retval;
   struct sos_fs_manager_type * fs_type;              struct sos_fs_manager_type * fs_type;
   struct sos_fs_manager_instance * new_fs;           struct sos_fs_manager_instance * new_fs;
   struct sos_fs_node * rdev_fsnode;                  struct sos_fs_node * rdev_fsnode;
   int nb_fstypes;                                    int nb_fstypes;
                                                    
   /* root_device is ignored for now */               /* root_device is ignored for now */
   rdev_fsnode    = NULL;                             rdev_fsnode    = NULL;
                                                    
   last_fs_instance_uid = 0;                          last_fs_instance_uid = 0;
   *result_rootfs = NULL;                             *result_rootfs = NULL;
                                                    
   retval = sos_fs_nscache_subsystem_setup();         retval = sos_fs_nscache_subsystem_setup();
   if (SOS_OK != retval)                              if (SOS_OK != retval)
     return retval;                                     return retval;
                                                    
   /* Look for the FS manager type */                 /* Look for the FS manager type */
   list_foreach(fs_list, fs_type, nb_fstypes)         list_foreach(fs_list, fs_type, nb_fstypes)
     {                                                  {
       if (! strcmp(fsname, fs_type->name))               if (! strcmp(fsname, fs_type->name))
         break;                                             break;
     }                                                  }
   if (! list_foreach_early_break(fs_list, fs_t       if (! list_foreach_early_break(fs_list, fs_type, nb_fstypes))
     return -SOS_ENODEV;                                return -SOS_ENODEV;
                                                    
   retval = fs_type->mount(fs_type,                   retval = fs_type->mount(fs_type,
                           rdev_fsnode,                                       rdev_fsnode,
                           mount_args, & new_fs                               mount_args, & new_fs);
   if (SOS_OK != retval)                              if (SOS_OK != retval)
     {                                                  {
       if (rdev_fsnode)                                   if (rdev_fsnode)
         sos_fs_unref_fsnode(rdev_fsnode);                  sos_fs_unref_fsnode(rdev_fsnode);
       return retval;                                     return retval;
     }                                                  }
                                                    
   /* Update some reserved fields */                  /* Update some reserved fields */
   sos_fs_nscache_get_fs_node(new_fs->root)->fs       sos_fs_nscache_get_fs_node(new_fs->root)->fs = new_fs;
                                                    
   *result_rootfs = new_fs;                           *result_rootfs = new_fs;
   return SOS_OK;                                     return SOS_OK;
 }                                                  }
                                                    
                                                    
 sos_ret_t sos_fs_ref_fsnode(struct sos_fs_node     sos_ret_t sos_fs_ref_fsnode(struct sos_fs_node * fsnode)
 {                                                  {
   fsnode->inmem_ref_cnt ++;                          fsnode->inmem_ref_cnt ++;
   return SOS_OK;                                     return SOS_OK;
 }                                                  }
                                                    
                                                    
 sos_ret_t _sos_fs_unref_fsnode(struct sos_fs_n     sos_ret_t _sos_fs_unref_fsnode(struct sos_fs_node * node)
 {                                                  {
   SOS_ASSERT_FATAL(node->inmem_ref_cnt > 0);         SOS_ASSERT_FATAL(node->inmem_ref_cnt > 0);
                                                    
   /* Commit the changes the the FS when the la       /* Commit the changes the the FS when the last reference is being
      removed */                                         removed */
   if ((node->inmem_ref_cnt == 1) && (node->dir       if ((node->inmem_ref_cnt == 1) && (node->dirty))
     {                                                  {
       SOS_ASSERT_FATAL(SOS_OK == sos_fs_sync_n           SOS_ASSERT_FATAL(SOS_OK == sos_fs_sync_node(node));
     }                                                  }
                                                          
   node->inmem_ref_cnt --;                            node->inmem_ref_cnt --;
                                                    
   if (node->inmem_ref_cnt == 0)                      if (node->inmem_ref_cnt == 0)
     {                                                  {
       if (SOS_FS_NODE_DEVICE_CHAR == node->typ           if (SOS_FS_NODE_DEVICE_CHAR == node->type)
         sos_chardev_helper_release_fsnode(node             sos_chardev_helper_release_fsnode(node);
                                                   >>        else if (SOS_FS_NODE_DEVICE_BLOCK == node->type)
                                                   >>          sos_blockdev_helper_release_fsnode(node);
       sos_hash_remove(node->fs->nodecache, nod           sos_hash_remove(node->fs->nodecache, node);
       node->destructor(node);                            node->destructor(node);
     }                                                  }
                                                    
   return SOS_OK;                                     return SOS_OK;
 }                                                  }
                                                    
                                                    
 sos_ret_t sos_fs_ref_opened_file(struct sos_fs     sos_ret_t sos_fs_ref_opened_file(struct sos_fs_opened_file * of)
 {                                                  {
   of->ref_cnt ++;                                    of->ref_cnt ++;
   return SOS_OK;                                     return SOS_OK;
 }                                                  }
                                                    
                                                    
 sos_ret_t _sos_fs_unref_opened_file(struct sos     sos_ret_t _sos_fs_unref_opened_file(struct sos_fs_opened_file ** _of)
 {                                                  {
   struct sos_fs_opened_file * of = *_of;             struct sos_fs_opened_file * of = *_of;
   *_of = NULL;                                       *_of = NULL;
                                                    
   SOS_ASSERT_FATAL(of->ref_cnt > 0);                 SOS_ASSERT_FATAL(of->ref_cnt > 0);
   of->ref_cnt --;                                    of->ref_cnt --;
                                                    
   if (0 == of->ref_cnt)                              if (0 == of->ref_cnt)
     {                                                  {
       sos_ret_t retval;                                  sos_ret_t retval;
       struct sos_fs_nscache_node * nsnode = of           struct sos_fs_nscache_node * nsnode = of->direntry;
       struct sos_fs_node * fsnode = sos_fs_nsc           struct sos_fs_node * fsnode = sos_fs_nscache_get_fs_node(nsnode);
                                                    
       retval = fsnode->close_opened_file(fsnod           retval = fsnode->close_opened_file(fsnode, of);
       if (SOS_OK != retval)                              if (SOS_OK != retval)
         return retval;                                     return retval;
                                                          
       return sos_fs_nscache_unref_node(nsnode)           return sos_fs_nscache_unref_node(nsnode);
     }                                                  }
                                                    
   return SOS_OK;                                     return SOS_OK;
 }                                                  }
                                                    
                                                    
 /* *******************************************     /* **********************************************************
  * Some helper functions                            * Some helper functions
  */                                                 */
                                                    
 /** Fetch the given fsnode from hash first, or     /** Fetch the given fsnode from hash first, or from disk when not in
     hash */                                            hash */
 static sos_ret_t fs_fetch_node(struct sos_fs_m     static sos_ret_t fs_fetch_node(struct sos_fs_manager_instance *fs,
                                sos_ui64_t stor                                    sos_ui64_t storage_location,
                                struct sos_fs_n                                    struct sos_fs_node ** result_fsnode)
 {                                                  {
   sos_ret_t retval;                                  sos_ret_t retval;
                                                    
   /* If it is already loaded in memory, no nee       /* If it is already loaded in memory, no need to look further */
   *result_fsnode = (struct sos_fs_node*)             *result_fsnode = (struct sos_fs_node*)
     sos_hash_lookup(fs->nodecache,                     sos_hash_lookup(fs->nodecache,
                     & storage_location);                               & storage_location);
   if (*result_fsnode)                                if (*result_fsnode)
     return SOS_OK;                                     return SOS_OK;
                                                    
   /* Otherwise, call the appropriate method of       /* Otherwise, call the appropriate method of the FS */
   retval = fs->fetch_node_from_disk(fs, storag       retval = fs->fetch_node_from_disk(fs, storage_location, result_fsnode);
   if (SOS_OK != retval)                              if (SOS_OK != retval)
     return retval;                                     return retval;
                                                    
   (*result_fsnode)->generation    = 0;               (*result_fsnode)->generation    = 0;
                                                    
   /* Special case for device nodes */                /* Special case for device nodes */
   if (SOS_FS_NODE_DEVICE_CHAR == (*result_fsno       if (SOS_FS_NODE_DEVICE_CHAR == (*result_fsnode)->type)
     SOS_ASSERT_FATAL(SOS_OK                            SOS_ASSERT_FATAL(SOS_OK
                      == sos_chardev_helper_ref                          == sos_chardev_helper_ref_new_fsnode(*result_fsnode));
                                                   >>    else if (SOS_FS_NODE_DEVICE_BLOCK == (*result_fsnode)->type)
                                                   >>      SOS_ASSERT_FATAL(SOS_OK
                                                   >>                       == sos_blockdev_helper_ref_new_fsnode(*result_fsnode));
                                                   >>  
   sos_hash_insert(fs->nodecache, *result_fsnod       sos_hash_insert(fs->nodecache, *result_fsnode);
   return SOS_OK;                                     return SOS_OK;
 }                                                  }
                                                    
                                                    
 /**                                                /**
  * Helper function to allocate a new on-disk n      * Helper function to allocate a new on-disk node
  */                                                 */
 static sos_ret_t                                   static sos_ret_t
 fs_allocate_node(struct sos_fs_manager_instanc     fs_allocate_node(struct sos_fs_manager_instance * fs,
                  sos_fs_node_type_t type,                           sos_fs_node_type_t type,
                  sos_ui32_t flags,                                  sos_ui32_t flags,
                  const struct sos_process * cr                      const struct sos_process * creator,
                  sos_ui32_t access_rights,                          sos_ui32_t access_rights,
                  struct sos_fs_node ** result_                      struct sos_fs_node ** result_fsnode)
 {                                                  {
   sos_ret_t retval;                                  sos_ret_t retval;
                                                    
   /* Make sure FS is writable ! */                   /* Make sure FS is writable ! */
   if (fs->flags & SOS_FS_MOUNT_READONLY)             if (fs->flags & SOS_FS_MOUNT_READONLY)
     return -SOS_EPERM;                                 return -SOS_EPERM;
                                                    
   /* Allocate the node on disk */                    /* Allocate the node on disk */
   retval = fs->allocate_new_node(fs, type,           retval = fs->allocate_new_node(fs, type,
                                  creator, acce                                      creator, access_rights,
                                  flags,                                             flags,
                                  result_fsnode                                      result_fsnode);
   if (SOS_OK != retval)                              if (SOS_OK != retval)
     return retval;                                     return retval;
                                                    
   /* Update some resrved fields */                   /* Update some resrved fields */
   (*result_fsnode)->fs = fs;                         (*result_fsnode)->fs = fs;
                                                    
   /* Special case for device nodes */                /* Special case for device nodes */
   if (SOS_FS_NODE_DEVICE_CHAR == (*result_fsno       if (SOS_FS_NODE_DEVICE_CHAR == (*result_fsnode)->type)
     {                                                  {
       SOS_ASSERT_FATAL(SOS_OK                            SOS_ASSERT_FATAL(SOS_OK
                        == sos_chardev_helper_r                            == sos_chardev_helper_ref_new_fsnode(*result_fsnode));
     }                                                  }
                                                   >>    else if (SOS_FS_NODE_DEVICE_BLOCK == (*result_fsnode)->type)
                                                   >>      {
                                                   >>        SOS_ASSERT_FATAL(SOS_OK
                                                   >>                         == sos_blockdev_helper_ref_new_fsnode(*result_fsnode));
                                                   >>      }
                                                   >>  
                                                    
   /* insert it in the node cache */                  /* insert it in the node cache */
   retval = sos_hash_insert(fs->nodecache, *res       retval = sos_hash_insert(fs->nodecache, *result_fsnode);
   if (SOS_OK != retval)                              if (SOS_OK != retval)
     {                                                  {
       sos_fs_unref_fsnode(*result_fsnode);               sos_fs_unref_fsnode(*result_fsnode);
       return retval;                                     return retval;
     }                                                  }
                                                    
   /* Success: Consider the node as dirty */          /* Success: Consider the node as dirty */
   mark_dirty_fsnode(*result_fsnode, FALSE);          mark_dirty_fsnode(*result_fsnode, FALSE);
   return retval;                                     return retval;
 }                                                  }
                                                    
                                                    
 /** Helper function to add the given node in t     /** Helper function to add the given node in the dirty list, or to
     write it directly to the disk if the syste         write it directly to the disk if the system is mounted in SYNC
     mode */                                            mode */
 static sos_ret_t mark_dirty_fsnode(struct sos_     static sos_ret_t mark_dirty_fsnode(struct sos_fs_node * fsnode,
                                    sos_bool_t                                         sos_bool_t force_sync)
 {                                                  {
   sos_ret_t retval;                                  sos_ret_t retval;
   sos_bool_t was_dirty = fsnode->dirty;              sos_bool_t was_dirty = fsnode->dirty;
                                                    
   fsnode->dirty = TRUE;                              fsnode->dirty = TRUE;
   fsnode->generation ++;                             fsnode->generation ++;
   retval = SOS_OK;                                   retval = SOS_OK;
                                                    
   /* If the fsnode is newly dirty, add it to t       /* If the fsnode is newly dirty, add it to the dirty list of the
      FS */                                              FS */
   if (!was_dirty && fsnode->dirty)                   if (!was_dirty && fsnode->dirty)
     list_add_tail_named(fsnode->fs->dirty_node         list_add_tail_named(fsnode->fs->dirty_nodes, fsnode,
                         prev_dirty, next_dirty                             prev_dirty, next_dirty);
                                                    
   if (force_sync || (fsnode->fs->flags & SOS_F       if (force_sync || (fsnode->fs->flags & SOS_FS_MOUNT_SYNC))
     {                                          !!      return sos_fs_sync_node(fsnode);
       /* Commit the node changes to the FS */  << 
       if (SOS_OK == sos_fs_sync_node(fsnode))  << 
         {                                      << 
           /* Commit the FS changes to the devi << 
           if (SOS_OK                           << 
               == fsnode->fs->device->sync(fsno << 
             return SOS_OK;                     << 
                                                << 
           /* We got a problem: FORCE re-add th << 
           was_dirty = FALSE;                   << 
           fsnode->dirty = TRUE;                << 
           retval = -SOS_EBUSY;                 << 
         }                                      << 
     }                                          << 
                                                    
   return retval;                                     return retval;
 }                                                  }
                                                    
                                                    
 /** Remove the given node from the dirty list      /** Remove the given node from the dirty list of the FS */
 static sos_ret_t sos_fs_sync_node(struct sos_f     static sos_ret_t sos_fs_sync_node(struct sos_fs_node * fsnode)
 {                                                  {
   sos_ret_t retval;                                  sos_ret_t retval;
                                                    
   if (! fsnode->dirty)                               if (! fsnode->dirty)
     return SOS_OK;                                     return SOS_OK;
                                                    
   retval = fsnode->sync(fsnode);               !!    retval = fsnode->ops_file->sync(fsnode);
   if (SOS_OK != retval)                              if (SOS_OK != retval)
     return retval;                                     return retval;
                                                    
   /* Remove it from the dirty list */                /* Remove it from the dirty list */
   list_delete_named(fsnode->fs->dirty_nodes, f       list_delete_named(fsnode->fs->dirty_nodes, fsnode,
                     prev_dirty, next_dirty);                           prev_dirty, next_dirty);
   fsnode->dirty = FALSE;                             fsnode->dirty = FALSE;
                                                    
                                                   >>    /* Commit the FS changes to the device */
                                                   >>    if (fsnode->fs->device)
                                                   >>      {
                                                   >>        retval = sos_blockdev_helper_sync_fsnode(fsnode->fs->device);
                                                   >>        if (SOS_OK != retval)
                                                   >>          {
                                                   >>            /* We got a problem ! Mark the node dirty again */
                                                   >>            list_add_tail_named(fsnode->fs->dirty_nodes, fsnode,
                                                   >>                                prev_dirty, next_dirty);
                                                   >>            fsnode->dirty = TRUE;
                                                   >>            return retval;
                                                   >>          }
                                                   >>      }
                                                   >>  
   return SOS_OK;                                     return SOS_OK;
 }                                                  }
                                                    
                                                    
 /** Collapse the whole dirty list of the FS an     /** Collapse the whole dirty list of the FS and commit the changes to
     the underlying device */                           the underlying device */
 static sos_ret_t sos_fs_sync_fs(struct sos_fs_     static sos_ret_t sos_fs_sync_fs(struct sos_fs_manager_instance * fs)
 {                                                  {
   struct sos_fs_node * fsnode;                       struct sos_fs_node * fsnode;
   while (NULL != (fsnode = list_get_head_named       while (NULL != (fsnode = list_get_head_named(fs->dirty_nodes,
                                                                                                   prev_dirty, next_dirty)))
     {                                                  {
       sos_ret_t retval = sos_fs_sync_node(fsno           sos_ret_t retval = sos_fs_sync_node(fsnode);
       if (SOS_OK != retval)                              if (SOS_OK != retval)
         return retval;                                     return retval;
     }                                                  }
                                                << 
   if (NULL != fs->device)                      << 
       return fs->device->sync(fs->device);     << 
                                                    
   return SOS_OK;                                     return SOS_OK;
 }                                                  }
                                                    
                                                    
 /**                                                /**
  * Resolve the given symlink: return the nsnod      * Resolve the given symlink: return the nsnode for the destination
  * of the symlink, or error status for danglin      * of the symlink, or error status for dangling symlinks
  *                                                  *
  * @note result_nsnode is a NEW reference to t      * @note result_nsnode is a NEW reference to the node. It should be
  * unreferenced when unused                         * unreferenced when unused
  */                                                 */
 static sos_ret_t                                   static sos_ret_t
 fs_resolve_symlink(const struct sos_fs_nscache     fs_resolve_symlink(const struct sos_fs_nscache_node * root_nsnode,
                    const struct sos_fs_nscache                        const struct sos_fs_nscache_node * symlink_nsnode,
                    struct sos_fs_nscache_node                         struct sos_fs_nscache_node ** target_nsnode,
                    int lookup_recursion_level)                        int lookup_recursion_level)
 {                                                  {
   sos_ret_t retval;                                  sos_ret_t retval;
   const struct sos_fs_nscache_node * start_nsn       const struct sos_fs_nscache_node * start_nsnode;
   struct sos_fs_node * symlink_fsnode;               struct sos_fs_node * symlink_fsnode;
   struct sos_fs_pathname path;                       struct sos_fs_pathname path;
   struct sos_fs_pathname remaining;                  struct sos_fs_pathname remaining;
                                                    
   symlink_fsnode = sos_fs_nscache_get_fs_node(       symlink_fsnode = sos_fs_nscache_get_fs_node(symlink_nsnode);
   retval = symlink_fsnode->ops_symlink->expand       retval = symlink_fsnode->ops_symlink->expand(symlink_fsnode,
                                                                                                   & path.contents,
                                                                                                   & path.length);
   if (SOS_OK != retval)                              if (SOS_OK != retval)
     return retval;                                     return retval;
   if (path.length <= 0)                              if (path.length <= 0)
     return -SOS_ENOENT;                                return -SOS_ENOENT;
                                                    
   /* Absolute path for target ? */                   /* Absolute path for target ? */
   if (path.contents[0] == '/')                       if (path.contents[0] == '/')
     start_nsnode = root_nsnode;                        start_nsnode = root_nsnode;
   else                                               else
     {                                                  {
       retval = sos_fs_nscache_get_parent(symli           retval = sos_fs_nscache_get_parent(symlink_nsnode,
                                          (stru                                              (struct sos_fs_nscache_node**)& start_nsnode);
       if (SOS_OK != retval)                              if (SOS_OK != retval)
         return retval;                                     return retval;
     }                                                  }
                                                    
   retval = fs_lookup_node(& path, TRUE, root_n       retval = fs_lookup_node(& path, TRUE, root_nsnode, start_nsnode,
                           target_nsnode,                                     target_nsnode,
                           & remaining, lookup_                               & remaining, lookup_recursion_level);
   if (SOS_OK != retval)                              if (SOS_OK != retval)
     return retval;                                     return retval;
                                                    
   /* The target of the symlink could not be co       /* The target of the symlink could not be completely opened ! */
   if (remaining.length != 0)                         if (remaining.length != 0)
     {                                                  {
       sos_fs_nscache_unref_node(*target_nsnode           sos_fs_nscache_unref_node(*target_nsnode);
       return -SOS_ENOENT;                                return -SOS_ENOENT;
     }                                                  }
                                                    
   return SOS_OK;                                     return SOS_OK;
 }                                                  }
                                                    
                                                    
 #define MAX_LOOKUP_RECURSION_LEVEL 5               #define MAX_LOOKUP_RECURSION_LEVEL 5
                                                    
                                                    
 /**                                                /**
  * @return OK in any case, except if 1/ a syml      * @return OK in any case, except if 1/ a symlink could not be
  * resolved, or 2/ a path "a/b" is given where      * resolved, or 2/ a path "a/b" is given where "a" is not a directory,
  * or 3/ a fsnode that should exist could not       * or 3/ a fsnode that should exist could not be retrieved from disk.
  *                                                  *
  * @param result_remaining_path contains the p      * @param result_remaining_path contains the path that could not be resolved
  *                                                  *
  * @param result_nsnode a NEW reference to the      * @param result_nsnode a NEW reference to the farthest node that
  * could be resolved. It should be unreference      * could be resolved. It should be unreferenced when unused
  */                                                 */
 static sos_ret_t                                   static sos_ret_t
 fs_lookup_node(const struct sos_fs_pathname *      fs_lookup_node(const struct sos_fs_pathname * path,
                sos_bool_t follow_symlinks,                        sos_bool_t follow_symlinks,
                const struct sos_fs_nscache_nod                    const struct sos_fs_nscache_node * root_nsnode,
                const struct sos_fs_nscache_nod                    const struct sos_fs_nscache_node * start_nsnode,
                struct sos_fs_nscache_node ** r                    struct sos_fs_nscache_node ** result_nsnode,
                struct sos_fs_pathname * result                    struct sos_fs_pathname * result_remaining_path,
                int lookup_recursion_level)                        int lookup_recursion_level)
 {                                                  {
   sos_ret_t retval;                                  sos_ret_t retval;
   struct sos_fs_nscache_node * current_nsnode;       struct sos_fs_nscache_node * current_nsnode;
                                                    
   /* Make sure we did not go too deep while re       /* Make sure we did not go too deep while resolving symlinks */
   lookup_recursion_level ++;                         lookup_recursion_level ++;
   if (lookup_recursion_level > MAX_LOOKUP_RECU       if (lookup_recursion_level > MAX_LOOKUP_RECURSION_LEVEL)
     {                                                  {
       return -SOS_ELOOP;                                 return -SOS_ELOOP;
     }                                                  }
                                                    
   if (path->length <= 0)                             if (path->length <= 0)
     return -SOS_ENOENT;                                return -SOS_ENOENT;
                                                    
   *result_nsnode = NULL;                             *result_nsnode = NULL;
   memcpy(result_remaining_path, path, sizeof(*       memcpy(result_remaining_path, path, sizeof(*path));
                                                    
   current_nsnode = (struct sos_fs_nscache_node       current_nsnode = (struct sos_fs_nscache_node *)start_nsnode;
   sos_fs_nscache_ref_node(current_nsnode);           sos_fs_nscache_ref_node(current_nsnode);
   while (1)                                          while (1)
     {                                                  {
       struct sos_fs_pathname current_component           struct sos_fs_pathname current_component, remaining;
       struct sos_fs_nscache_node * next_nsnode           struct sos_fs_nscache_node * next_nsnode = NULL;
       sos_bool_t slashes_after_first_component           sos_bool_t slashes_after_first_component;
                                                    
 /*       dbg_dump_pathname("Before", result_re     /*       dbg_dump_pathname("Before", result_remaining_path); */
                                                    
       /* Extract the next component of the pat           /* Extract the next component of the path */
       slashes_after_first_component                      slashes_after_first_component
         = sos_fs_pathname_split_path(result_re             = sos_fs_pathname_split_path(result_remaining_path,
                                      & current                                          & current_component, & remaining);
 /*       dbg_dump_pathname("After", result_rem     /*       dbg_dump_pathname("After", result_remaining_path); */
 /*       dbg_dump_pathname("Cur", & current_co     /*       dbg_dump_pathname("Cur", & current_component); */
 /*       dbg_dump_pathname("Rem", & remaining)     /*       dbg_dump_pathname("Rem", & remaining); */
 /*       sos_bochs_printf("Slash after=%d\n",      /*       sos_bochs_printf("Slash after=%d\n", slashes_after_first_component); */
                                                    
       /* Could resolve the whole path ? */               /* Could resolve the whole path ? */
       if (current_component.length == 0)                 if (current_component.length == 0)
         {                                                  {
           /* Ok, fine, we got it ! */                        /* Ok, fine, we got it ! */
           memcpy(result_remaining_path, & rema               memcpy(result_remaining_path, & remaining, sizeof(remaining));
           *result_nsnode = current_nsnode;                   *result_nsnode = current_nsnode;        
           return SOS_OK;                                     return SOS_OK;
         }                                                  }
                                                    
       /* Otherwise: make sure we reached a DIR           /* Otherwise: make sure we reached a DIR node */
       if (sos_fs_nscache_get_fs_node(current_n           if (sos_fs_nscache_get_fs_node(current_nsnode)->type
           != SOS_FS_NODE_DIRECTORY)                          != SOS_FS_NODE_DIRECTORY)
         {                                                  {
           sos_fs_nscache_unref_node(current_ns               sos_fs_nscache_unref_node(current_nsnode);
           return -SOS_ENOENT;                                return -SOS_ENOENT;
         }                                                  }
                                                          
       /* Make sure this directory is "executab           /* Make sure this directory is "executable" */
       if (! (sos_fs_nscache_get_fs_node(curren           if (! (sos_fs_nscache_get_fs_node(current_nsnode)->access_rights
              & SOS_FS_EXECUTABLE) )                             & SOS_FS_EXECUTABLE) )
         {                                                  {
           sos_fs_nscache_unref_node(current_ns               sos_fs_nscache_unref_node(current_nsnode);
           return -SOS_EACCES;                                return -SOS_EACCES;
         }                                                  }
                                                    
       /* If we can find the entry in the names           /* If we can find the entry in the namespace cache, it is really
          fine ! */                                          fine ! */
       retval = sos_fs_nscache_lookup(current_n           retval = sos_fs_nscache_lookup(current_nsnode,
                                      & current                                          & current_component,
                                      root_nsno                                          root_nsnode,
                                      & next_ns                                          & next_nsnode);
       if (SOS_OK != retval)                              if (SOS_OK != retval)
         {                                                  {
           struct sos_fs_node * current_fsnode,               struct sos_fs_node * current_fsnode, * next_fsnode;
           sos_ui64_t storage_location;                       sos_ui64_t storage_location;
                                                    
           /*                                                 /*
            * Not found in the namespace cache.                * Not found in the namespace cache. Must read from the
            * disk...                                          * disk...
            */                                                 */
           current_fsnode = sos_fs_nscache_get_               current_fsnode = sos_fs_nscache_get_fs_node(current_nsnode);
                                                    
           retval = current_fsnode->ops_dir                   retval = current_fsnode->ops_dir
             ->lookup(current_fsnode,                           ->lookup(current_fsnode,
                      current_component.content                          current_component.contents,
                      current_component.length,                          current_component.length,
                      & storage_location);                               & storage_location);
           if (SOS_OK != retval)                              if (SOS_OK != retval)
             {                                                  {
               /* Well, we cannot go further, s                   /* Well, we cannot go further, stop here */
               *result_nsnode = current_nsnode;                   *result_nsnode = current_nsnode;
               return SOS_OK;                                     return SOS_OK;
             }                                                  }
                                                    
           /* Now retrieve this node from disk                /* Now retrieve this node from disk or from the cache into
              memory */                                          memory */
           retval = fs_fetch_node(current_fsnod               retval = fs_fetch_node(current_fsnode->fs,
                                  storage_locat                                      storage_location, & next_fsnode);
           if (SOS_OK != retval)                              if (SOS_OK != retval)
             {                                                  {
               sos_fs_nscache_unref_node(curren                   sos_fs_nscache_unref_node(current_nsnode);
               return retval;                                     return retval;
             }                                                  }
                                                          
           /* Integrate it in the nscache */                  /* Integrate it in the nscache */
           retval = sos_fs_nscache_add_new_chil               retval = sos_fs_nscache_add_new_child_node(current_nsnode,
                                                                                                         & current_component,
                                                                                                         next_fsnode,
                                                                                                         & next_nsnode);
           sos_fs_nscache_unref_node(current_ns               sos_fs_nscache_unref_node(current_nsnode);
           if (SOS_OK != retval)                              if (SOS_OK != retval)
             return retval;                                     return retval;
         }                                                  }
       else                                               else
         sos_fs_nscache_unref_node(current_nsno             sos_fs_nscache_unref_node(current_nsnode);
                                                    
       /* Reaching a symlink ? */                         /* Reaching a symlink ? */
       if (sos_fs_nscache_get_fs_node(next_nsno           if (sos_fs_nscache_get_fs_node(next_nsnode)->type
           == SOS_FS_NODE_SYMLINK)                            == SOS_FS_NODE_SYMLINK)
         {                                                  {
           /* Expand the link only for non-term               /* Expand the link only for non-terminal nodes, or for the
              terminal node only if follow_syml                  terminal node only if follow_symlinks is TRUE */
           if ( (remaining.length != 0)                       if ( (remaining.length != 0)
                || follow_symlinks )                               || follow_symlinks )
             {                                                  {
               struct sos_fs_nscache_node * sym                   struct sos_fs_nscache_node * symlink_target;
                                                    
               retval = fs_resolve_symlink(root                   retval = fs_resolve_symlink(root_nsnode, next_nsnode,
                                           & sy                                               & symlink_target,
                                           look                                               lookup_recursion_level);
               sos_fs_nscache_unref_node(next_n                   sos_fs_nscache_unref_node(next_nsnode);
               if (SOS_OK != retval)                              if (SOS_OK != retval)
                 return retval; /* Dangling sym                     return retval; /* Dangling symlink */
                                                    
               next_nsnode = symlink_target;                      next_nsnode = symlink_target;
             }                                                  }
         }                                                  }
                                                          
       /* Make sure there was no slash after th           /* Make sure there was no slash after this component, unless
          this component is a directory */                   this component is a directory */
       if (slashes_after_first_component                  if (slashes_after_first_component
           &&                                                 &&
           ( sos_fs_nscache_get_fs_node(next_ns               ( sos_fs_nscache_get_fs_node(next_nsnode)->type
             != SOS_FS_NODE_DIRECTORY) )                        != SOS_FS_NODE_DIRECTORY) )
         {                                                  {
           sos_fs_nscache_unref_node(next_nsnod               sos_fs_nscache_unref_node(next_nsnode);
           return -SOS_ENOTDIR;                               return -SOS_ENOTDIR;
         }                                                  }
                                                    
       /* Ok, fine, we got it, update the path            /* Ok, fine, we got it, update the path we still have to explore */
       memcpy(result_remaining_path, & remainin           memcpy(result_remaining_path, & remaining, sizeof(remaining));
       current_nsnode = next_nsnode;                      current_nsnode = next_nsnode;
     }                                                  }
                                                    
   sos_display_fatal_error("Should not get ther       sos_display_fatal_error("Should not get there");
   return -SOS_EFATAL;                                return -SOS_EFATAL;
 }                                                  }
                                                    
                                                    
 /**                                                /**
  * It is assumed that parent does not already       * It is assumed that parent does not already have a child with the
  * given name. We make sure that the "path" is      * given name. We make sure that the "path" is a single entity (ie
  * not "a/b")                                       * not "a/b")
  * @return Error if fsnode is not on the same       * @return Error if fsnode is not on the same FS as parent_nsnode
  */                                                 */
 static sos_ret_t                                   static sos_ret_t
 fs_register_child_node(const struct sos_proces     fs_register_child_node(const struct sos_process * creator,
                        struct sos_fs_nscache_n                            struct sos_fs_nscache_node * parent_nsnode,
                        const struct sos_fs_pat                            const struct sos_fs_pathname * name,
                        struct sos_fs_node * fs                            struct sos_fs_node * fsnode,
                        sos_ui32_t flags,                                  sos_ui32_t flags,
                        struct sos_fs_nscache_n                            struct sos_fs_nscache_node ** result_nsnode)
 {                                                  {
   sos_ret_t retval;                                  sos_ret_t retval;
   struct sos_fs_node * parent_fsnode;                struct sos_fs_node * parent_fsnode;
   struct sos_fs_pathname first_component, rema       struct sos_fs_pathname first_component, remaining;
   sos_bool_t slashes_after_first_component = F       sos_bool_t slashes_after_first_component = FALSE;
                                                    
   parent_fsnode = sos_fs_nscache_get_fs_node(p       parent_fsnode = sos_fs_nscache_get_fs_node(parent_nsnode);
   if (parent_fsnode->type != SOS_FS_NODE_DIREC       if (parent_fsnode->type != SOS_FS_NODE_DIRECTORY)
     return -SOS_ENOTDIR;                               return -SOS_ENOTDIR;
                                                    
   if (name->length <= 0)                             if (name->length <= 0)
     return -SOS_EINVAL;                                return -SOS_EINVAL;
                                                    
   slashes_after_first_component                      slashes_after_first_component
     = sos_fs_pathname_split_path(name, & first         = sos_fs_pathname_split_path(name, & first_component, & remaining);
                                                    
   if (fsnode->type != SOS_FS_NODE_DIRECTORY)         if (fsnode->type != SOS_FS_NODE_DIRECTORY)
     {                                                  {
       /* Make sure the given name is exactly a           /* Make sure the given name is exactly a single path component
          (ie no '/') */                                     (ie no '/') */
       if (slashes_after_first_component)                 if (slashes_after_first_component)
         return -SOS_EINVAL;                                return -SOS_EINVAL;
     }                                                  }
   else                                               else
     {                                                  {
       /* Make sure there aren't any other comp           /* Make sure there aren't any other component behind the '/'s, if
          any */                                             any */
       if (remaining.length > 0)                          if (remaining.length > 0)
         return -SOS_EINVAL;                                return -SOS_EINVAL;
     }                                                  }
                                                    
   /* Make sure the parent directory is writeab       /* Make sure the parent directory is writeable */
   if (! (parent_fsnode->access_rights & SOS_FS       if (! (parent_fsnode->access_rights & SOS_FS_WRITABLE) )
     return -SOS_EACCES;                                return -SOS_EACCES;
                                                    
   /* Make sure that the entries are located on       /* Make sure that the entries are located on the same FS */
   if (fsnode->fs != parent_fsnode->fs)               if (fsnode->fs != parent_fsnode->fs)
     return -SOS_EXDEV;                                 return -SOS_EXDEV;
                                                    
   /* Make sure that the nsnode won't be destro       /* Make sure that the nsnode won't be destroyed */
   sos_fs_nscache_ref_node(parent_nsnode);            sos_fs_nscache_ref_node(parent_nsnode);
                                                    
   /* Allocate the node in directory */               /* Allocate the node in directory */
   retval = parent_fsnode->ops_dir->link(parent       retval = parent_fsnode->ops_dir->link(parent_fsnode,
                                         creato                                             creator,
                                         first_                                             first_component.contents,
                                         first_                                             first_component.length,
                                         fsnode                                             fsnode);
   if (SOS_OK != retval)                              if (SOS_OK != retval)
     {                                                  {
       sos_fs_nscache_unref_node(parent_nsnode)           sos_fs_nscache_unref_node(parent_nsnode);
       return retval;                                     return retval;
     }                                                  }
                                                    
   /* Success: Consider the directory as dirty        /* Success: Consider the directory as dirty */
   mark_dirty_fsnode(parent_fsnode, FALSE);           mark_dirty_fsnode(parent_fsnode, FALSE);
                                                    
   /* Allocate the node in nscache cache */           /* Allocate the node in nscache cache */
   retval = sos_fs_nscache_add_new_child_node(p       retval = sos_fs_nscache_add_new_child_node(parent_nsnode, & first_component,
                                              f                                                  fsnode, result_nsnode);
                                                    
   sos_fs_nscache_unref_node(parent_nsnode);          sos_fs_nscache_unref_node(parent_nsnode);
   return retval;                                     return retval;
 }                                                  }
                                                    
                                                    
 /** It is assumed that parent does not already     /** It is assumed that parent does not already have a child with the
     given name. We make sure that the "path" i         given name. We make sure that the "path" is a single entity (ie
     not "a/b"). Return a NEW reference to the          not "a/b"). Return a NEW reference to the newly-created NS node */
 static sos_ret_t                                   static sos_ret_t
 fs_create_child_node(struct sos_fs_nscache_nod     fs_create_child_node(struct sos_fs_nscache_node * parent_nsnode,
                      const struct sos_fs_pathn                          const struct sos_fs_pathname * name,
                      sos_fs_node_type_t type,                           sos_fs_node_type_t type,
                      sos_ui32_t flags,                                  sos_ui32_t flags,
                      const struct sos_process                           const struct sos_process * creator,
                      sos_ui32_t access_rights,                          sos_ui32_t access_rights,
                      struct sos_fs_nscache_nod                          struct sos_fs_nscache_node ** result_nsnode)
 {                                                  {
   sos_ret_t retval;                                  sos_ret_t retval;
   struct sos_fs_node * fsnode, * parent_fsnode       struct sos_fs_node * fsnode, * parent_fsnode;
                                                    
   parent_fsnode = sos_fs_nscache_get_fs_node(p       parent_fsnode = sos_fs_nscache_get_fs_node(parent_nsnode);
   if (parent_fsnode->type != SOS_FS_NODE_DIREC       if (parent_fsnode->type != SOS_FS_NODE_DIRECTORY)
     return -SOS_ENOTDIR;                               return -SOS_ENOTDIR;
                                                    
   /* Make sure that the nsnode won't be destro       /* Make sure that the nsnode won't be destroyed */
   sos_fs_nscache_ref_node(parent_nsnode);            sos_fs_nscache_ref_node(parent_nsnode);
                                                    
   retval = fs_allocate_node(parent_fsnode->fs,       retval = fs_allocate_node(parent_fsnode->fs, type, flags, creator,
                             access_rights, & f                                 access_rights, & fsnode);
   if (SOS_OK != retval)                              if (SOS_OK != retval)
     {                                                  {
       sos_fs_nscache_unref_node(parent_nsnode)           sos_fs_nscache_unref_node(parent_nsnode);
       return retval;                                     return retval;
     }                                                  }
                                                    
   retval = fs_register_child_node(creator,           retval = fs_register_child_node(creator,
                                   parent_nsnod                                       parent_nsnode, name, fsnode, flags,
                                   result_nsnod                                       result_nsnode);
   sos_fs_nscache_unref_node(parent_nsnode);          sos_fs_nscache_unref_node(parent_nsnode);
                                                    
   /* The function does not need it anymore */        /* The function does not need it anymore */
   sos_fs_unref_fsnode(fsnode);                       sos_fs_unref_fsnode(fsnode);
                                                    
   return retval;                                     return retval;
 }                                                  }
                                                    
                                                    
 /**                                                /**
  * It is assumed that parent does not already       * It is assumed that parent does not already have a child with the
  * given name, and that the new child does not      * given name, and that the new child does not have a parent yet. We
  * make sure that the "path" is a single entit      * make sure that the "path" is a single entity (ie not "a/b") @return
  * Error if fsnode is not on the same FS as pa      * Error if fsnode is not on the same FS as parent_nsnode
  */                                                 */
 static sos_ret_t                                   static sos_ret_t
 fs_connect_existing_child_node(const struct so     fs_connect_existing_child_node(const struct sos_process * creator,
                                struct sos_fs_n                                    struct sos_fs_nscache_node * parent_nsnode,
                                const struct so                                    const struct sos_fs_pathname * name,
                                struct sos_fs_n                                    struct sos_fs_nscache_node * nsnode)
 {                                                  {
   sos_ret_t retval;                                  sos_ret_t retval;
   struct sos_fs_node * parent_fsnode, * fsnode       struct sos_fs_node * parent_fsnode, * fsnode;
   struct sos_fs_pathname first_component, rema       struct sos_fs_pathname first_component, remaining;
   sos_bool_t slashes_after_first_component = F       sos_bool_t slashes_after_first_component = FALSE;
                                                    
   fsnode = sos_fs_nscache_get_fs_node(nsnode);       fsnode = sos_fs_nscache_get_fs_node(nsnode);
   parent_fsnode = sos_fs_nscache_get_fs_node(p       parent_fsnode = sos_fs_nscache_get_fs_node(parent_nsnode);
   if (parent_fsnode->type != SOS_FS_NODE_DIREC       if (parent_fsnode->type != SOS_FS_NODE_DIRECTORY)
     return -SOS_ENOTDIR;                               return -SOS_ENOTDIR;
                                                    
   if (name->length <= 0)                             if (name->length <= 0)
     return -SOS_EINVAL;                                return -SOS_EINVAL;
                                                    
   slashes_after_first_component                      slashes_after_first_component
     = sos_fs_pathname_split_path(name, & first         = sos_fs_pathname_split_path(name, & first_component, & remaining);
                                                    
   if (fsnode->type != SOS_FS_NODE_DIRECTORY)         if (fsnode->type != SOS_FS_NODE_DIRECTORY)
     {                                                  {
       /* Make sure the given name is exactly a           /* Make sure the given name is exactly a single path component
          (ie no '/') */                                     (ie no '/') */
       if (slashes_after_first_component)                 if (slashes_after_first_component)
         return -SOS_EINVAL;                                return -SOS_EINVAL;
     }                                                  }
   else                                               else
     {                                                  {
       /* Make sure there aren't any other comp           /* Make sure there aren't any other component behind the '/'s, if
          any */                                             any */
       if (remaining.length > 0)                          if (remaining.length > 0)
         return -SOS_EINVAL;                                return -SOS_EINVAL;
     }                                                  }
                                                    
   /* Make sure the parent directory is writeab       /* Make sure the parent directory is writeable */
   if (! (parent_fsnode->access_rights & SOS_FS       if (! (parent_fsnode->access_rights & SOS_FS_WRITABLE) )
     return -SOS_EACCES;                                return -SOS_EACCES;
                                                    
   /* Make sure that the entries are located on       /* Make sure that the entries are located on the same FS */
   if (fsnode->fs != parent_fsnode->fs)               if (fsnode->fs != parent_fsnode->fs)
     return -SOS_EXDEV;                                 return -SOS_EXDEV;
                                                    
   /* Make sure that the nsnode won't be destro       /* Make sure that the nsnode won't be destroyed */
   sos_fs_nscache_ref_node(parent_nsnode);            sos_fs_nscache_ref_node(parent_nsnode);
                                                    
   /* Allocate the node in directory */               /* Allocate the node in directory */
   retval = parent_fsnode->ops_dir->link(parent       retval = parent_fsnode->ops_dir->link(parent_fsnode,
                                         creato                                             creator,
                                         first_                                             first_component.contents,
                                         first_                                             first_component.length,
                                         fsnode                                             fsnode);
   if (SOS_OK != retval)                              if (SOS_OK != retval)
     {                                                  {
       sos_fs_nscache_unref_node(parent_nsnode)           sos_fs_nscache_unref_node(parent_nsnode);
       return retval;                                     return retval;
     }                                                  }
                                                    
   /* Success: Consider the directory as dirty        /* Success: Consider the directory as dirty */
   mark_dirty_fsnode(parent_fsnode, FALSE);           mark_dirty_fsnode(parent_fsnode, FALSE);
                                                    
   /* Allocate the node in nscache cache */           /* Allocate the node in nscache cache */
   retval = sos_fs_nscache_add_existing_child_n       retval = sos_fs_nscache_add_existing_child_node(parent_nsnode,
                                                                                                      & first_component,
                                                                                                      nsnode);
   sos_fs_nscache_unref_node(parent_nsnode);          sos_fs_nscache_unref_node(parent_nsnode);
   return retval;                                     return retval;
 }                                                  }
                                                    
                                                    
 /** Return a new reference to the new node ins     /** Return a new reference to the new node inserted unless
     result_nsnode is NULL */                           result_nsnode is NULL */
 static sos_ret_t                                   static sos_ret_t
 fs_create_node(const struct sos_fs_pathname *      fs_create_node(const struct sos_fs_pathname * _path,
                const struct sos_process * crea                    const struct sos_process * creator,
                sos_ui32_t access_rights,                          sos_ui32_t access_rights,
                sos_fs_node_type_t type,                           sos_fs_node_type_t type,
                struct sos_fs_nscache_node ** r                    struct sos_fs_nscache_node ** result_nsnode)
 {                                                  {
   sos_ret_t retval;                                  sos_ret_t retval;
   struct sos_fs_pathname path;                       struct sos_fs_pathname path;
   struct sos_fs_nscache_node *nsnode, *new_nsn       struct sos_fs_nscache_node *nsnode, *new_nsnode;
                                                    
   path.contents = _path->contents;                   path.contents = _path->contents;
   path.length   = _path->length;                     path.length   = _path->length;
                                                    
   if (path.length <= 0)                              if (path.length <= 0)
     return -SOS_ENOENT;                                return -SOS_ENOENT;
                                                    
   if (path.contents[0] == '/')                       if (path.contents[0] == '/')
     nsnode = sos_process_get_root(creator)->di         nsnode = sos_process_get_root(creator)->direntry;
   else                                               else
     nsnode = sos_process_get_cwd(creator)->dir         nsnode = sos_process_get_cwd(creator)->direntry;
                                                    
   retval = fs_lookup_node(& path,                    retval = fs_lookup_node(& path,
                           TRUE,                                              TRUE,
                           sos_process_get_root                               sos_process_get_root(creator)->direntry,
                           nsnode,                                            nsnode,
                           & nsnode,                                          & nsnode,
                           & path,                                            & path,
                           0);                                                0);
   if (SOS_OK != retval)                              if (SOS_OK != retval)
     return retval;                                     return retval;
                                                    
   if (path.length <= 0)                              if (path.length <= 0)
     {                                                  {
       /* Found the exact match ! */                      /* Found the exact match ! */
       sos_fs_nscache_unref_node(nsnode);                 sos_fs_nscache_unref_node(nsnode);
       return -SOS_EEXIST;                                return -SOS_EEXIST;
     }                                                  }
                                                    
   /* Create a new entry in the file system */        /* Create a new entry in the file system */
   retval = fs_create_child_node(nsnode,              retval = fs_create_child_node(nsnode,
                                 & path,                                            & path,
                                 type,                                              type,
                                 /* flags */0,                                      /* flags */0,
                                 creator, acces                                     creator, access_rights,
                                 & new_nsnode);                                     & new_nsnode);
   sos_fs_nscache_unref_node(nsnode);                 sos_fs_nscache_unref_node(nsnode);
                                                    
   /* node not needed by this function ? */           /* node not needed by this function ? */
   if (NULL == result_nsnode)                         if (NULL == result_nsnode)
     sos_fs_nscache_unref_node(new_nsnode);             sos_fs_nscache_unref_node(new_nsnode);
   else                                               else
     *result_nsnode = new_nsnode;                       *result_nsnode = new_nsnode;
                                                    
   return retval;                                     return retval;
 }                                                  }
                                                    
                                                    
 static sos_ret_t                                   static sos_ret_t
 fs_remove_node(const struct sos_process * acto     fs_remove_node(const struct sos_process * actor,
                struct sos_fs_nscache_node * ns                    struct sos_fs_nscache_node * nsnode)
 {                                                  {
   sos_ret_t retval;                                  sos_ret_t retval;
   struct sos_fs_nscache_node * parent_nsnode;        struct sos_fs_nscache_node * parent_nsnode;
   struct sos_fs_node * parent_fsnode;                struct sos_fs_node * parent_fsnode;
   struct sos_fs_pathname childname;                  struct sos_fs_pathname childname;
                                                    
   /* Refuse to do anything if this is the root       /* Refuse to do anything if this is the root of a mounted FS */
   if (nsnode == sos_fs_nscache_get_fs_node(nsn       if (nsnode == sos_fs_nscache_get_fs_node(nsnode)->fs->root)
     return -SOS_EBUSY;                                 return -SOS_EBUSY;
                                                    
   retval = sos_fs_nscache_get_parent(nsnode, &       retval = sos_fs_nscache_get_parent(nsnode, & parent_nsnode);
   if (SOS_OK != retval)                              if (SOS_OK != retval)
     return retval;                                     return retval;
   parent_fsnode = sos_fs_nscache_get_fs_node(p       parent_fsnode = sos_fs_nscache_get_fs_node(parent_nsnode);
                                                    
   /* Make sure FS is writable ! */                   /* Make sure FS is writable ! */
   if (parent_fsnode->fs->flags & SOS_FS_MOUNT_       if (parent_fsnode->fs->flags & SOS_FS_MOUNT_READONLY)
     return -SOS_EPERM;                                 return -SOS_EPERM;
                                                    
   /* Make sure the parent directory is writeab       /* Make sure the parent directory is writeable */
   if (! (parent_fsnode->access_rights & SOS_FS       if (! (parent_fsnode->access_rights & SOS_FS_WRITABLE) )
     return -SOS_EACCES;                                return -SOS_EACCES;
                                                    
   sos_fs_nscache_ref_node(parent_nsnode);            sos_fs_nscache_ref_node(parent_nsnode);
                                                    
   sos_fs_nscache_get_name(nsnode, & childname)       sos_fs_nscache_get_name(nsnode, & childname);
   retval = parent_fsnode->ops_dir->unlink(pare       retval = parent_fsnode->ops_dir->unlink(parent_fsnode, actor,
                                           chil                                               childname.contents,
                                           chil                                               childname.length);
   if (SOS_OK == retval)                              if (SOS_OK == retval)
     sos_fs_nscache_disconnect_node(nsnode);            sos_fs_nscache_disconnect_node(nsnode);
                                                    
   /* Unallocate the node */                          /* Unallocate the node */
   if (SOS_OK == retval)                              if (SOS_OK == retval)
     mark_dirty_fsnode(parent_fsnode, FALSE);           mark_dirty_fsnode(parent_fsnode, FALSE);
                                                    
   sos_fs_nscache_unref_node(parent_nsnode);          sos_fs_nscache_unref_node(parent_nsnode);
   return retval;                                     return retval;
 }                                                  }
                                                    
                                                    
 /* *******************************************     /* **********************************************************
  * Exported functions                               * Exported functions
  */                                                 */
                                                    
 sos_ret_t sos_fs_new_opened_file(const struct      sos_ret_t sos_fs_new_opened_file(const struct sos_process * owner,
                                  struct sos_fs                                      struct sos_fs_nscache_node * nsnode,
                                  sos_ui32_t op                                      sos_ui32_t open_flags,
                                  struct sos_fs                                      struct sos_fs_opened_file ** result_of)
 {                                                  {
   sos_ret_t retval;                                  sos_ret_t retval;
   struct sos_fs_node * fsnode = sos_fs_nscache       struct sos_fs_node * fsnode = sos_fs_nscache_get_fs_node(nsnode);
                                                    
   retval = fsnode->new_opened_file(fsnode, own       retval = fsnode->new_opened_file(fsnode, owner, open_flags, result_of);
   if (SOS_OK != retval)                              if (SOS_OK != retval)
       return retval;                                     return retval;
                                                    
   (*result_of)->ref_cnt    = 1;                      (*result_of)->ref_cnt    = 1;
   (*result_of)->generation = 1;                      (*result_of)->generation = 1;
                                                    
   retval = sos_fs_nscache_register_opened_file       retval = sos_fs_nscache_register_opened_file(nsnode, *result_of);
   if (SOS_OK != retval)                              if (SOS_OK != retval)
     {                                                  {
       fsnode->close_opened_file(fsnode, *resul           fsnode->close_opened_file(fsnode, *result_of);
       return retval;                                     return retval;
     }                                                  }
                                                    
   (*result_of)->open_flags = open_flags;             (*result_of)->open_flags = open_flags;
   return SOS_OK;                                     return SOS_OK;
 }                                                  }
                                                    
                                                    
 sos_ret_t                                          sos_ret_t
 sos_fs_duplicate_opened_file(struct sos_fs_ope     sos_fs_duplicate_opened_file(struct sos_fs_opened_file * src_of,
                              const struct sos_                                  const struct sos_process * dst_proc,
                              struct sos_fs_ope                                  struct sos_fs_opened_file ** result_of)
 {                                                  {
   sos_ret_t retval = src_of->duplicate(src_of,       sos_ret_t retval = src_of->duplicate(src_of, dst_proc, result_of);
   if (SOS_OK != retval)                              if (SOS_OK != retval)
     return retval;                                     return retval;
                                                    
   SOS_ASSERT_FATAL((*result_of)->owner == dst_       SOS_ASSERT_FATAL((*result_of)->owner == dst_proc);
   (*result_of)->ref_cnt    = 1;                      (*result_of)->ref_cnt    = 1;
   (*result_of)->generation = 1;                      (*result_of)->generation = 1;
   retval = sos_fs_nscache_register_opened_file       retval = sos_fs_nscache_register_opened_file(src_of->direntry, *result_of);
   if (SOS_OK != retval)                              if (SOS_OK != retval)
     {                                                  {
       struct sos_fs_node * fsnode = sos_fs_nsc           struct sos_fs_node * fsnode = sos_fs_nscache_get_fs_node(src_of->direntry);
       fsnode->close_opened_file(fsnode, *resul           fsnode->close_opened_file(fsnode, *result_of);
       return retval;                                     return retval;
     }                                                  }
                                                    
   return retval;                                     return retval;
 }                                                  }
                                                    
                                                    
 sos_ret_t sos_fs_open(const struct sos_process     sos_ret_t sos_fs_open(const struct sos_process *owner,
                       const char *_path,                                 const char *_path,
                       sos_size_t _pathlen,                               sos_size_t _pathlen,
                       sos_ui32_t open_flags,                             sos_ui32_t open_flags,
                       sos_ui32_t creat_access_                           sos_ui32_t creat_access_rights,
                       struct sos_fs_opened_fil                           struct sos_fs_opened_file ** of)
 {                                                  {
   sos_ret_t retval;                                  sos_ret_t retval;
   struct sos_fs_nscache_node *nsnode;                struct sos_fs_nscache_node *nsnode;
   struct sos_fs_node * fsnode;                       struct sos_fs_node * fsnode;
   struct sos_fs_pathname path;                       struct sos_fs_pathname path;
                                                    
   /* O_DIR | O_CREAT combination not supported       /* O_DIR | O_CREAT combination not supported */
   if ( (open_flags & SOS_FS_OPEN_DIRECTORY)          if ( (open_flags & SOS_FS_OPEN_DIRECTORY)
        && ( (open_flags & (SOS_FS_OPEN_CREAT              && ( (open_flags & (SOS_FS_OPEN_CREAT
                            | SOS_FS_OPEN_TRUNC                                | SOS_FS_OPEN_TRUNC)) ) )
     return -SOS_EINVAL;                                return -SOS_EINVAL;
                                                    
   if (_pathlen <= 0)                                 if (_pathlen <= 0)
     return -SOS_ENOENT;                               return -SOS_ENOENT;
                                                   
   path.contents = _path;                            path.contents = _path;
   path.length   = _pathlen;                         path.length   = _pathlen;
                                                   
   if (path.contents[0] == '/')                      if (path.contents[0] == '/')
     nsnode = sos_process_get_root(owner)->dir         nsnode = sos_process_get_root(owner)->direntry;
   else                                              else
     nsnode = sos_process_get_cwd(owner)->dire         nsnode = sos_process_get_cwd(owner)->direntry;
                                                   
   retval = fs_lookup_node(& path,                   retval = fs_lookup_node(& path,
                           ! (open_flags & SOS                               ! (open_flags & SOS_FS_OPEN_NOFOLLOW),
                           sos_process_get_roo                               sos_process_get_root(owner)->direntry,
                           nsnode,                                           nsnode,
                           & nsnode,                                         & nsnode,
                           & path,                                           & path,
                           0);                                               0);
   if (SOS_OK != retval)                             if (SOS_OK != retval)
     return retval;                                    return retval;
                                                   
   if (path.length <= 0)                             if (path.length <= 0)
     {                                                 {
       /* Found the exact match ! */                     /* Found the exact match ! */
                                                   
       /* Handle O_EXCL flag */                          /* Handle O_EXCL flag */
       if (open_flags & SOS_FS_OPEN_EXCL)                if (open_flags & SOS_FS_OPEN_EXCL)
         {                                                 {
           sos_fs_nscache_unref_node(nsnode);                sos_fs_nscache_unref_node(nsnode);
           return -SOS_EEXIST;                               return -SOS_EEXIST;
         }                                                 }
                                                   
       fsnode = sos_fs_nscache_get_fs_node(nsn           fsnode = sos_fs_nscache_get_fs_node(nsnode);
       if ((open_flags & SOS_FS_OPEN_DIRECTORY           if ((open_flags & SOS_FS_OPEN_DIRECTORY)
           && (fsnode->type != SOS_FS_NODE_DIR               && (fsnode->type != SOS_FS_NODE_DIRECTORY))
         {                                                 {
           sos_fs_nscache_unref_node(nsnode);                sos_fs_nscache_unref_node(nsnode);
           return -SOS_ENOTDIR;                              return -SOS_ENOTDIR;
         }                                                 }
                                                   
       /* Handle O_TRUNC flag */                         /* Handle O_TRUNC flag */
       if ((open_flags & SOS_FS_OPEN_TRUNC)              if ((open_flags & SOS_FS_OPEN_TRUNC)
           && fsnode->ops_file->truncate)                    && fsnode->ops_file->truncate)
         {                                                 {
           retval = fsnode->ops_file->truncate               retval = fsnode->ops_file->truncate(fsnode, 0);
           if (SOS_OK != retval)                             if (SOS_OK != retval)
             {                                                 {
               sos_fs_nscache_unref_node(nsnod                   sos_fs_nscache_unref_node(nsnode);
               return retval;                                    return retval;
             }                                                 }
         }                                                 }
     }                                                 }
   else                                              else
     {                                                 {
       struct sos_fs_nscache_node * parent_nsn           struct sos_fs_nscache_node * parent_nsnode = nsnode;
                                                   
       /* Did not find an exact match. Should            /* Did not find an exact match. Should create the node ! */
       if (! (open_flags & SOS_FS_OPEN_CREAT))           if (! (open_flags & SOS_FS_OPEN_CREAT))
         {                                                 {
           sos_fs_nscache_unref_node(parent_ns               sos_fs_nscache_unref_node(parent_nsnode);
           return -SOS_ENOENT;                               return -SOS_ENOENT;
         }                                                 }
                                                   
       /* Create a new entry in the file syste           /* Create a new entry in the file system */
       retval = fs_create_child_node(parent_ns           retval = fs_create_child_node(parent_nsnode,
                                     & path,                                           & path,
                                     SOS_FS_NO                                         SOS_FS_NODE_REGULAR_FILE,
                                     open_flag                                         open_flags,
                                     owner,                                            owner,
                                     creat_acc                                         creat_access_rights,
                                     & nsnode)                                         & nsnode);
       sos_fs_nscache_unref_node(parent_nsnode           sos_fs_nscache_unref_node(parent_nsnode);
       if (SOS_OK != retval)                             if (SOS_OK != retval)
         {                                                 {
           return retval;                                    return retval;
         }                                                 }
                                                   
       fsnode = sos_fs_nscache_get_fs_node(nsn           fsnode = sos_fs_nscache_get_fs_node(nsnode);
     }                                                 }
                                                   
   /* Recompute access rights */                     /* Recompute access rights */
   open_flags &= ~(SOS_FS_OPEN_CREAT                 open_flags &= ~(SOS_FS_OPEN_CREAT
                   | SOS_FS_OPEN_EXCL                                | SOS_FS_OPEN_EXCL
                   | SOS_FS_OPEN_NOFOLLOW                            | SOS_FS_OPEN_NOFOLLOW
                   | SOS_FS_OPEN_DIRECTORY);                         | SOS_FS_OPEN_DIRECTORY);
   if (! (fsnode->access_rights & SOS_FS_WRITA       if (! (fsnode->access_rights & SOS_FS_WRITABLE))
     open_flags &= ~(SOS_FS_OPEN_WRITE);               open_flags &= ~(SOS_FS_OPEN_WRITE);
   if (! (fsnode->access_rights & SOS_FS_READA       if (! (fsnode->access_rights & SOS_FS_READABLE))
     open_flags &= ~(SOS_FS_OPEN_READ);                open_flags &= ~(SOS_FS_OPEN_READ);
   if (fsnode->fs->flags & SOS_FS_MOUNT_READON       if (fsnode->fs->flags & SOS_FS_MOUNT_READONLY)
     open_flags &= ~(SOS_FS_OPEN_READ);                open_flags &= ~(SOS_FS_OPEN_READ);
                                                   
   /*                                                /*
    * Ok, open it right now !                         * Ok, open it right now !
    */                                                */
   retval = sos_fs_new_opened_file(owner, nsno       retval = sos_fs_new_opened_file(owner, nsnode, open_flags, of);
                                                   
   sos_fs_nscache_unref_node(nsnode);                sos_fs_nscache_unref_node(nsnode);
   return retval;                                    return retval;
 }                                                 }
                                                   
                                                   
 sos_ret_t sos_fs_close(struct sos_fs_opened_f     sos_ret_t sos_fs_close(struct sos_fs_opened_file * of)
 {                                                 {
   return sos_fs_unref_opened_file(of);              return sos_fs_unref_opened_file(of);
 }                                                 }
                                                   
                                                   
 sos_ret_t sos_fs_mark_dirty(struct sos_fs_ope     sos_ret_t sos_fs_mark_dirty(struct sos_fs_opened_file * of)
 {                                                 {
   struct sos_fs_node * fsnode = sos_fs_nscach       struct sos_fs_node * fsnode = sos_fs_nscache_get_fs_node(of->direntry);
                                                   
   /* This function should never get called if       /* This function should never get called if the FS is read-only */
   SOS_ASSERT_FATAL(! (fsnode->fs->flags & SOS       SOS_ASSERT_FATAL(! (fsnode->fs->flags & SOS_FS_MOUNT_READONLY));
                                                   
   return mark_dirty_fsnode(fsnode, of->open_f       return mark_dirty_fsnode(fsnode, of->open_flags & SOS_FS_OPEN_SYNC);
 }                                                 }
                                                   
                                                   
 sos_ret_t sos_fs_read(struct sos_fs_opened_fi     sos_ret_t sos_fs_read(struct sos_fs_opened_file * of,
                       sos_uaddr_t dest_buf,                             sos_uaddr_t dest_buf,
                       sos_size_t * /* in/ou *                           sos_size_t * /* in/ou */len)
 {                                                 {
   if (! (of->open_flags & SOS_FS_OPEN_READ))        if (! (of->open_flags & SOS_FS_OPEN_READ))
     return -SOS_EPERM;                                return -SOS_EPERM;
                                                   
   if (! of->ops_file->read)                         if (! of->ops_file->read)
     return -SOS_ENOSYS;                               return -SOS_ENOSYS;
                                                   
   return of->ops_file->read(of, dest_buf, len       return of->ops_file->read(of, dest_buf, len);
 }                                                 }
                                                   
                                                   
 sos_ret_t sos_fs_write(struct sos_fs_opened_f     sos_ret_t sos_fs_write(struct sos_fs_opened_file * of,
                        sos_uaddr_t src_buf,                              sos_uaddr_t src_buf,
                        sos_size_t * /* in/out                            sos_size_t * /* in/out */len)
 {                                                 {
  if (! (of->open_flags & SOS_FS_OPEN_WRITE))       if (! (of->open_flags & SOS_FS_OPEN_WRITE))
    return -SOS_EPERM;                                return -SOS_EPERM;
                                                   
  if (! of->ops_file->write)                        if (! of->ops_file->write)
    return -SOS_ENOSYS;                               return -SOS_ENOSYS;
                                                   
   return of->ops_file->write(of, src_buf, len       return of->ops_file->write(of, src_buf, len);
 }                                                 }
                                                   
                                                   
 sos_ret_t sos_fs_seek(struct sos_fs_opened_fi     sos_ret_t sos_fs_seek(struct sos_fs_opened_file *of,
                       sos_lsoffset_t offset,                            sos_lsoffset_t offset,
                       sos_seek_whence_t whenc                           sos_seek_whence_t whence,
                       sos_lsoffset_t * result                           sos_lsoffset_t * result_position)
 {                                                 {
   if (! of->ops_file->seek)                         if (! of->ops_file->seek)
     return -SOS_ENOSYS;                               return -SOS_ENOSYS;
                                                   
   return of->ops_file->seek(of, offset, whenc       return of->ops_file->seek(of, offset, whence, result_position);
 }                                                 }
                                                   
                                                   
 sos_ret_t sos_fs_ftruncate(struct sos_fs_open     sos_ret_t sos_fs_ftruncate(struct sos_fs_opened_file *of,
                            sos_lsoffset_t len                                sos_lsoffset_t length)
 {                                                 {
   sos_ret_t retval;                                 sos_ret_t retval;
   struct sos_fs_node * fsnode = sos_fs_nscach       struct sos_fs_node * fsnode = sos_fs_nscache_get_fs_node(of->direntry);
                                                   
   if (! (of->open_flags & SOS_FS_OPEN_WRITE))       if (! (of->open_flags & SOS_FS_OPEN_WRITE))
     return -SOS_EPERM;                                return -SOS_EPERM;
                                                   
   if (! fsnode->ops_file->truncate)                 if (! fsnode->ops_file->truncate)
     return -SOS_ENOSYS;                               return -SOS_ENOSYS;
                                                   
   retval = fsnode->ops_file->truncate(fsnode,       retval = fsnode->ops_file->truncate(fsnode, length);
   if (SOS_OK == retval)                             if (SOS_OK == retval)
     mark_dirty_fsnode(fsnode, FALSE);                 mark_dirty_fsnode(fsnode, FALSE);
                                                   
   return retval;                                    return retval;
 }                                                 }
                                                   
                                                   
 sos_ret_t sos_fs_mmap(struct sos_fs_opened_fi     sos_ret_t sos_fs_mmap(struct sos_fs_opened_file *of,
                       sos_uaddr_t *uaddr, sos                           sos_uaddr_t *uaddr, sos_size_t size,
                       sos_ui32_t access_right                           sos_ui32_t access_rights,
                       sos_ui32_t flags,                                 sos_ui32_t flags,
                       sos_luoffset_t offset)                            sos_luoffset_t offset)
 {                                                 {
   sos_ui32_t required_access = 0;                   sos_ui32_t required_access = 0;
   struct sos_fs_node * fsnode = sos_fs_nscach       struct sos_fs_node * fsnode = sos_fs_nscache_get_fs_node(of->direntry);
                                                   
   if (! of->ops_file->mmap)                         if (! of->ops_file->mmap)
     return -SOS_ENOSYS;                               return -SOS_ENOSYS;
                                                   
   /* Translate VM requested rights into FS eq       /* Translate VM requested rights into FS equivalent */
   if (access_rights & SOS_VM_MAP_PROT_READ)         if (access_rights & SOS_VM_MAP_PROT_READ)
     required_access |= SOS_FS_OPEN_READ;              required_access |= SOS_FS_OPEN_READ;
   if ( (access_rights & SOS_VM_MAP_PROT_WRITE       if ( (access_rights & SOS_VM_MAP_PROT_WRITE) && (flags & SOS_VR_MAP_SHARED) )
     required_access |= SOS_FS_OPEN_WRITE;             required_access |= SOS_FS_OPEN_WRITE;
   if (access_rights & SOS_VM_MAP_PROT_EXEC)         if (access_rights & SOS_VM_MAP_PROT_EXEC)
     required_access |= SOS_FS_OPEN_READ;              required_access |= SOS_FS_OPEN_READ;
                                                   
   /* Make sure that the opened file allowed t       /* Make sure that the opened file allowed this access */
   if ((of->open_flags & required_access) != r       if ((of->open_flags & required_access) != required_access)
     return -SOS_EPERM;                                return -SOS_EPERM;
                                                   
   if ( (access_rights & SOS_VM_MAP_PROT_EXEC)       if ( (access_rights & SOS_VM_MAP_PROT_EXEC)
        && (fsnode->fs->flags & SOS_FS_MOUNT_N            && (fsnode->fs->flags & SOS_FS_MOUNT_NOEXEC) )
     return -SOS_EPERM;                                return -SOS_EPERM;
                                                   
   return of->ops_file->mmap(of, uaddr, size,        return of->ops_file->mmap(of, uaddr, size, access_rights, flags, offset);  
 }                                                 }
                                                   
                                                   
 sos_ret_t sos_fs_fcntl(struct sos_fs_opened_f     sos_ret_t sos_fs_fcntl(struct sos_fs_opened_file *of,
                        int req_id,                                       int req_id,
                        sos_ui32_t req_arg /*                             sos_ui32_t req_arg /* Usually: sos_uaddr_t */)
 {                                                 {
   if (! of->ops_file->fcntl)                        if (! of->ops_file->fcntl)
     return -SOS_ENOSYS;                               return -SOS_ENOSYS;
                                                   
   return of->ops_file->fcntl(of, req_id, req_       return of->ops_file->fcntl(of, req_id, req_arg);
 }                                                 }
                                                   
                                                   
 sos_ret_t sos_fs_ioctl(struct sos_fs_opened_f     sos_ret_t sos_fs_ioctl(struct sos_fs_opened_file *of,
                        int req_id,                                       int req_id,
                        sos_ui32_t req_arg /*                             sos_ui32_t req_arg /* Usually: sos_uaddr_t */)
 {                                                 {
   struct sos_fs_node * fsnode = sos_fs_nscach       struct sos_fs_node * fsnode = sos_fs_nscache_get_fs_node(of->direntry);
                                                   
   if (fsnode->type == SOS_FS_NODE_DEVICE_CHAR       if (fsnode->type == SOS_FS_NODE_DEVICE_CHAR)
     {                                                 {
       if (! of->ops_chardev->ioctl)                     if (! of->ops_chardev->ioctl)
         return -SOS_ENOSYS;                               return -SOS_ENOSYS;
                                                   
       return of->ops_chardev->ioctl(of, req_i           return of->ops_chardev->ioctl(of, req_id, req_arg);
     }                                                 }
                                                   >>    else if (fsnode->type == SOS_FS_NODE_DEVICE_BLOCK)
                                                   >>      {
                                                   >>        if (! of->ops_blockdev->ioctl)
                                                   >>          return -SOS_ENOSYS;
                                                   >>  
                                                   >>        return of->ops_blockdev->ioctl(of, req_id, req_arg);
                                                   >>      }
                                                     
   return -SOS_ENOSYS;                               return -SOS_ENOSYS;
 }                                                 }
                                                   
                                                   
 sos_ret_t sos_fs_readdir(struct sos_fs_opened     sos_ret_t sos_fs_readdir(struct sos_fs_opened_file * of,
                          struct sos_fs_dirent                              struct sos_fs_dirent * result)
 {                                                 {
   struct sos_fs_node * fsnode = sos_fs_nscach       struct sos_fs_node * fsnode = sos_fs_nscache_get_fs_node(of->direntry);
                                                   
   if (fsnode->type != SOS_FS_NODE_DIRECTORY)        if (fsnode->type != SOS_FS_NODE_DIRECTORY)
     return -SOS_ENOTDIR;                              return -SOS_ENOTDIR;
                                                   
   return of->ops_dir->readdir(of, result);          return of->ops_dir->readdir(of, result);
 }                                                 }
                                                   
                                                   
 sos_ret_t sos_fs_creat(const struct sos_proce     sos_ret_t sos_fs_creat(const struct sos_process * creator,
                        const char * _path,                               const char * _path,
                        sos_size_t _pathlen,                              sos_size_t _pathlen,
                        sos_ui32_t access_righ                            sos_ui32_t access_rights)
 {                                                 {
   struct sos_fs_pathname path;                      struct sos_fs_pathname path;
                                                   
   path.contents = _path;                            path.contents = _path;
   path.length   = _pathlen;                         path.length   = _pathlen;
                                                   
   return fs_create_node(& path, creator, acce       return fs_create_node(& path, creator, access_rights,
                         SOS_FS_NODE_REGULAR_F                             SOS_FS_NODE_REGULAR_FILE, NULL);
 }                                                 }
                                                   
                                                   
 sos_ret_t sos_fs_link(const struct sos_proces     sos_ret_t sos_fs_link(const struct sos_process * creator,
                       const char * _old_path,                           const char * _old_path,
                       sos_size_t _old_pathlen                           sos_size_t _old_pathlen,
                       const char * _new_path,                           const char * _new_path,
                       sos_size_t _new_pathlen                           sos_size_t _new_pathlen)
 {                                                 {
   sos_ret_t retval;                                 sos_ret_t retval;
   struct sos_fs_nscache_node *old_nsnode, *de       struct sos_fs_nscache_node *old_nsnode, *dest_parent_nsnode, *new_nsnode;
   struct sos_fs_node * fsnode;                      struct sos_fs_node * fsnode;
   struct sos_fs_pathname old_path, new_path;        struct sos_fs_pathname old_path, new_path;
                                                   
   if (_old_pathlen <= 0)                            if (_old_pathlen <= 0)
     return -SOS_ENOENT;                               return -SOS_ENOENT;
   if (_new_pathlen <= 0)                            if (_new_pathlen <= 0)
     return -SOS_ENOENT;                               return -SOS_ENOENT;
                                                   
   /* Resolve target FS node using "old_path"        /* Resolve target FS node using "old_path" */
   old_path.contents = _old_path;                    old_path.contents = _old_path;
   old_path.length   = _old_pathlen;                 old_path.length   = _old_pathlen;
                                                   
   if (old_path.contents[0] == '/')                  if (old_path.contents[0] == '/')
     old_nsnode = sos_process_get_root(creator         old_nsnode = sos_process_get_root(creator)->direntry;
   else                                              else
     old_nsnode = sos_process_get_cwd(creator)         old_nsnode = sos_process_get_cwd(creator)->direntry;
                                                   
   retval = fs_lookup_node(& old_path,               retval = fs_lookup_node(& old_path,
                           FALSE /* don't foll                               FALSE /* don't follow symlink */,
                           sos_process_get_roo                               sos_process_get_root(creator)->direntry,
                           old_nsnode,                                       old_nsnode,
                           & old_nsnode,                                     & old_nsnode,
                           & old_path,                                       & old_path,
                           0);                                               0);
   if (SOS_OK != retval)                             if (SOS_OK != retval)
     return retval;                                    return retval;
                                                   
   if (old_path.length > 0)                          if (old_path.length > 0)
     {                                                 {
       /* Could not resolve full path ! */               /* Could not resolve full path ! */
       sos_fs_nscache_unref_node(old_nsnode);            sos_fs_nscache_unref_node(old_nsnode);
       return -SOS_ENOENT;                               return -SOS_ENOENT;
     }                                                 }
                                                   
   fsnode = sos_fs_nscache_get_fs_node(old_nsn       fsnode = sos_fs_nscache_get_fs_node(old_nsnode);
                                                   
   /* Not allowed to link directories ! */           /* Not allowed to link directories ! */
   if (fsnode->type == SOS_FS_NODE_DIRECTORY)        if (fsnode->type == SOS_FS_NODE_DIRECTORY)
     {                                                 {
       sos_fs_nscache_unref_node(old_nsnode);            sos_fs_nscache_unref_node(old_nsnode);
       return -SOS_ENOENT;                               return -SOS_ENOENT;
     }                                                 }
                                                   
   /* Resolve destination path */                    /* Resolve destination path */
   new_path.contents = _new_path;                    new_path.contents = _new_path;
   new_path.length   = _new_pathlen;                 new_path.length   = _new_pathlen;
                                                   
   if (new_path.contents[0] == '/')                  if (new_path.contents[0] == '/')
     dest_parent_nsnode = sos_process_get_root         dest_parent_nsnode = sos_process_get_root(creator)->direntry;
   else                                              else
     dest_parent_nsnode = sos_process_get_cwd(         dest_parent_nsnode = sos_process_get_cwd(creator)->direntry;
                                                   
   retval = fs_lookup_node(& new_path,               retval = fs_lookup_node(& new_path,
                           TRUE /* Follow syml                               TRUE /* Follow symlink */,
                           sos_process_get_roo                               sos_process_get_root(creator)->direntry,
                           dest_parent_nsnode,                               dest_parent_nsnode,
                           & dest_parent_nsnod                               & dest_parent_nsnode,
                           & new_path,                                       & new_path,
                           0);                                               0);
   if (SOS_OK != retval)                             if (SOS_OK != retval)
     {                                                 {
       sos_fs_nscache_unref_node(old_nsnode);            sos_fs_nscache_unref_node(old_nsnode);
       return retval;                                    return retval;
     }                                                 }
                                                   
   if (new_path.length == 0)                         if (new_path.length == 0)
     {                                                 {
       /* Found the exact match ! Not allowed            /* Found the exact match ! Not allowed to overwrite it ! */
       sos_fs_nscache_unref_node(dest_parent_n           sos_fs_nscache_unref_node(dest_parent_nsnode);
       sos_fs_nscache_unref_node(old_nsnode);            sos_fs_nscache_unref_node(old_nsnode);
       return -SOS_EEXIST;                               return -SOS_EEXIST;
     }                                                 }
                                                   
   /* Create a new entry in the file system */       /* Create a new entry in the file system */
   retval = fs_register_child_node(creator, de       retval = fs_register_child_node(creator, dest_parent_nsnode, & new_path,
                                   fsnode, 0,                                        fsnode, 0,
                                   & new_nsnod                                       & new_nsnode);
                                                   
   sos_fs_nscache_unref_node(dest_parent_nsnod       sos_fs_nscache_unref_node(dest_parent_nsnode);
   sos_fs_nscache_unref_node(old_nsnode);            sos_fs_nscache_unref_node(old_nsnode);
   sos_fs_nscache_unref_node(new_nsnode);            sos_fs_nscache_unref_node(new_nsnode);
   return retval;                                    return retval;
 }                                                 }
                                                   
                                                   
 sos_ret_t sos_fs_rename(const struct sos_proc     sos_ret_t sos_fs_rename(const struct sos_process * actor,
                         const char * _old_pat                             const char * _old_path,
                         sos_size_t _old_pathl                             sos_size_t _old_pathlen,
                         const char * _new_pat                             const char * _new_path,
                         sos_size_t _new_pathl                             sos_size_t _new_pathlen)
 {                                                 {
   sos_ret_t retval;                                 sos_ret_t retval;
   struct sos_fs_nscache_node *old_nsnode, *ol       struct sos_fs_nscache_node *old_nsnode, *old_parent_nsnode,
     *dest_parent_nsnode, *replaced_nsnode;            *dest_parent_nsnode, *replaced_nsnode;
   struct sos_fs_pathname old_name, replaced_n       struct sos_fs_pathname old_name, replaced_name;
   struct sos_fs_pathname old_path, new_path;        struct sos_fs_pathname old_path, new_path;
                                                   
   old_nsnode = old_parent_nsnode = dest_paren       old_nsnode = old_parent_nsnode = dest_parent_nsnode = replaced_nsnode = NULL;
                                                   
   if (_old_pathlen <= 0)                            if (_old_pathlen <= 0)
     return -SOS_ENOENT;                               return -SOS_ENOENT;
   if (_new_pathlen <= 0)                            if (_new_pathlen <= 0)
     return -SOS_ENOENT;                               return -SOS_ENOENT;
                                                   
   /* Resolve target FS node using "old_path"        /* Resolve target FS node using "old_path" */
   old_path.contents = _old_path;                    old_path.contents = _old_path;
   old_path.length   = _old_pathlen;                 old_path.length   = _old_pathlen;
                                                   
   if (old_path.contents[0] == '/')                  if (old_path.contents[0] == '/')
     old_nsnode = sos_process_get_root(actor)-         old_nsnode = sos_process_get_root(actor)->direntry;
   else                                              else
     old_nsnode = sos_process_get_cwd(actor)->         old_nsnode = sos_process_get_cwd(actor)->direntry;
                                                   
   retval = fs_lookup_node(& old_path,               retval = fs_lookup_node(& old_path,
                           FALSE /* don't foll                               FALSE /* don't follow symlink */,
                           sos_process_get_roo                               sos_process_get_root(actor)->direntry,
                           old_nsnode,                                       old_nsnode,
                           & old_nsnode,                                     & old_nsnode,
                           & old_path,                                       & old_path,
                           0);                                               0);
   if (SOS_OK != retval)                             if (SOS_OK != retval)
     return retval;                                    return retval;
                                                   
   if (old_path.length > 0)                          if (old_path.length > 0)
     {                                                 {
       /* Could not resolve full path ! */               /* Could not resolve full path ! */
       sos_fs_nscache_unref_node(old_nsnode);            sos_fs_nscache_unref_node(old_nsnode);
       return -SOS_ENOENT;                               return -SOS_ENOENT;
     }                                                 }
                                                   
   /* Not allowed to rename mountpoints ! */         /* Not allowed to rename mountpoints ! */
   if (sos_fs_nscache_is_mountnode(old_nsnode)       if (sos_fs_nscache_is_mountnode(old_nsnode))
     {                                                 {
       sos_fs_nscache_unref_node(old_nsnode);            sos_fs_nscache_unref_node(old_nsnode);
       return -SOS_ENOENT;                               return -SOS_ENOENT;
     }                                                 }
                                                   
   /* Keep a reference on this node's parent,        /* Keep a reference on this node's parent, in case we must undo the
      rename */                                         rename */
   retval = sos_fs_nscache_get_parent(old_nsno       retval = sos_fs_nscache_get_parent(old_nsnode, & old_parent_nsnode);
   if (SOS_OK != retval)                             if (SOS_OK != retval)
     {                                                 {
       sos_fs_nscache_unref_node(old_nsnode);            sos_fs_nscache_unref_node(old_nsnode);
       return retval;                                    return retval;
     }                                                 }
   sos_fs_nscache_ref_node(old_parent_nsnode);       sos_fs_nscache_ref_node(old_parent_nsnode);
                                                   
   /* Resolve destination path */                    /* Resolve destination path */
   replaced_nsnode   = NULL;                         replaced_nsnode   = NULL;
   new_path.contents = _new_path;                    new_path.contents = _new_path;
   new_path.length   = _new_pathlen;                 new_path.length   = _new_pathlen;
                                                   
   if (new_path.contents[0] == '/')                  if (new_path.contents[0] == '/')
     dest_parent_nsnode = sos_process_get_root         dest_parent_nsnode = sos_process_get_root(actor)->direntry;
   else                                              else
     dest_parent_nsnode = sos_process_get_cwd(         dest_parent_nsnode = sos_process_get_cwd(actor)->direntry;
                                                   
   retval = fs_lookup_node(& new_path,               retval = fs_lookup_node(& new_path,
                           TRUE /* Follow syml                               TRUE /* Follow symlink */,
                           sos_process_get_roo                               sos_process_get_root(actor)->direntry,
                           dest_parent_nsnode,                               dest_parent_nsnode,
                           & dest_parent_nsnod                               & dest_parent_nsnode,
                           & new_path,                                       & new_path,
                           0);                                               0);
   if (SOS_OK != retval)                             if (SOS_OK != retval)
     {                                                 {
       goto undo_rename;                                 goto undo_rename;
     }                                                 }
                                                   
   /* Nothing to do ? */                             /* Nothing to do ? */
   if (old_nsnode == dest_parent_nsnode)             if (old_nsnode == dest_parent_nsnode)
     {                                                 {
       sos_fs_nscache_unref_node(old_nsnode);            sos_fs_nscache_unref_node(old_nsnode);
       sos_fs_nscache_unref_node(old_parent_ns           sos_fs_nscache_unref_node(old_parent_nsnode);
       sos_fs_nscache_unref_node(dest_parent_n           sos_fs_nscache_unref_node(dest_parent_nsnode);
       return SOS_OK;                                    return SOS_OK;
     }                                                 }
                                                   
   /* Remove old nsnode from file ns cache */        /* Remove old nsnode from file ns cache */
   sos_fs_nscache_get_name(old_nsnode, & old_n       sos_fs_nscache_get_name(old_nsnode, & old_name);
   retval = fs_remove_node(actor, old_nsnode);       retval = fs_remove_node(actor, old_nsnode);
   if (SOS_OK != retval)                             if (SOS_OK != retval)
     {                                                 {
       sos_fs_nscache_unref_node(old_nsnode);            sos_fs_nscache_unref_node(old_nsnode);
       sos_fs_nscache_unref_node(old_parent_ns           sos_fs_nscache_unref_node(old_parent_nsnode);
       sos_fs_nscache_unref_node(dest_parent_n           sos_fs_nscache_unref_node(dest_parent_nsnode);
       return -SOS_ENOENT;                               return -SOS_ENOENT;
     }                                                 }
                                                   
   if (new_path.length == 0)                         if (new_path.length == 0)
     {                                                 {
       /* Found the exact match ! We disconnec           /* Found the exact match ! We disconnect it from the namespace,
          but keep it aside */                              but keep it aside */
                                                   
       /* Not allowed to replace directories *           /* Not allowed to replace directories */
       if (sos_fs_nscache_get_fs_node(dest_par           if (sos_fs_nscache_get_fs_node(dest_parent_nsnode)->type
           == SOS_FS_NODE_DIRECTORY)                         == SOS_FS_NODE_DIRECTORY)
         {                                                 {
           retval = -SOS_EBUSY;                              retval = -SOS_EBUSY;
           goto undo_rename;                                 goto undo_rename;
         }                                                 }
                                                   
       replaced_nsnode = dest_parent_nsnode;             replaced_nsnode = dest_parent_nsnode;
       dest_parent_nsnode = NULL;                        dest_parent_nsnode = NULL;
                                                   
       /* Retrieve the parent of the node to r           /* Retrieve the parent of the node to replace */
       retval = sos_fs_nscache_get_parent(repl           retval = sos_fs_nscache_get_parent(replaced_nsnode,
                                          & de                                              & dest_parent_nsnode);
       if (SOS_OK != retval)                             if (SOS_OK != retval)
         {                                                 {
           dest_parent_nsnode = replaced_nsnod               dest_parent_nsnode = replaced_nsnode;
           goto undo_rename;                                 goto undo_rename;
         }                                                 }
                                                   
       sos_fs_nscache_ref_node(dest_parent_nsn           sos_fs_nscache_ref_node(dest_parent_nsnode);
                                                   
       /* Disconnect this node from its parent           /* Disconnect this node from its parent */
       sos_fs_nscache_get_name(replaced_nsnode           sos_fs_nscache_get_name(replaced_nsnode, & replaced_name);
       retval = fs_remove_node(actor, replaced           retval = fs_remove_node(actor, replaced_nsnode);
       if (SOS_OK != retval)                             if (SOS_OK != retval)
         goto undo_rename;                                 goto undo_rename;
     }                                                 }
                                                   
   /* Create a new entry in the file system */       /* Create a new entry in the file system */
   retval = fs_connect_existing_child_node(act       retval = fs_connect_existing_child_node(actor, dest_parent_nsnode,
                                           & n                                               & new_path,
                                           old                                               old_nsnode);
   if (SOS_OK != retval)                             if (SOS_OK != retval)
     goto undo_rename;                                 goto undo_rename;
                                                   
   sos_fs_nscache_unref_node(old_nsnode);            sos_fs_nscache_unref_node(old_nsnode);
   sos_fs_nscache_unref_node(old_parent_nsnode       sos_fs_nscache_unref_node(old_parent_nsnode);
   sos_fs_nscache_unref_node(dest_parent_nsnod       sos_fs_nscache_unref_node(dest_parent_nsnode);
   if (NULL != replaced_nsnode)                      if (NULL != replaced_nsnode)
     sos_fs_nscache_unref_node(replaced_nsnode         sos_fs_nscache_unref_node(replaced_nsnode);
                                                   
   return retval;                                    return retval;
                                                   
  undo_rename:                                      undo_rename:
                                                   
   /* Handle special case: the node replaced s       /* Handle special case: the node replaced something. In case the
      previous operation failed, we try to rei          previous operation failed, we try to reinsert the replaced
      node */                                           node */
   if (NULL != replaced_nsnode)                      if (NULL != replaced_nsnode)
     {                                                 {
       fs_connect_existing_child_node(actor, d           fs_connect_existing_child_node(actor, dest_parent_nsnode,
                                      & replac                                          & replaced_name,
                                      replaced                                          replaced_nsnode);
       sos_fs_nscache_unref_node(replaced_nsno           sos_fs_nscache_unref_node(replaced_nsnode);
     }                                                 }
                                                   
   fs_connect_existing_child_node(actor, old_p       fs_connect_existing_child_node(actor, old_parent_nsnode,
                                  & old_name,                                       & old_name,
                                  old_nsnode);                                      old_nsnode);
   sos_fs_nscache_unref_node(old_nsnode);            sos_fs_nscache_unref_node(old_nsnode);
   sos_fs_nscache_unref_node(old_parent_nsnode       sos_fs_nscache_unref_node(old_parent_nsnode);
                                                   
   if (NULL != dest_parent_nsnode)                   if (NULL != dest_parent_nsnode)
     sos_fs_nscache_unref_node(dest_parent_nsn         sos_fs_nscache_unref_node(dest_parent_nsnode);
                                                   
   return retval;                                    return retval;
 }                                                 }
                                                   
                                                   
 sos_ret_t sos_fs_unlink(const struct sos_proc     sos_ret_t sos_fs_unlink(const struct sos_process * actor,
                         const char * _path,                               const char * _path,
                         sos_size_t _pathlen)                              sos_size_t _pathlen)
 {                                                 {
   sos_ret_t retval;                                 sos_ret_t retval;
   struct sos_fs_pathname path;                      struct sos_fs_pathname path;
   struct sos_fs_nscache_node * nsnode;              struct sos_fs_nscache_node * nsnode;
                                                   
   path.contents = _path;                            path.contents = _path;
   path.length   = _pathlen;                         path.length   = _pathlen;
                                                   
   if (path.length <= 0)                             if (path.length <= 0)
     return -SOS_ENOENT;                               return -SOS_ENOENT;
                                                   
   if (path.contents[0] == '/')                      if (path.contents[0] == '/')
     nsnode = sos_process_get_root(actor)->dir         nsnode = sos_process_get_root(actor)->direntry;
   else                                              else
     nsnode = sos_process_get_cwd(actor)->dire         nsnode = sos_process_get_cwd(actor)->direntry;
                                                   
   retval = fs_lookup_node(& path, FALSE,            retval = fs_lookup_node(& path, FALSE,
                           sos_process_get_roo                               sos_process_get_root(actor)->direntry,
                           nsnode,                                           nsnode,
                           & nsnode, & path, 0                               & nsnode, & path, 0);
   if (SOS_OK != retval)                             if (SOS_OK != retval)
     return retval;                                    return retval;
                                                   
   /* Make sure the whole path has been resolv       /* Make sure the whole path has been resolved */
   if (path.length > 0)                              if (path.length > 0)
     {                                                 {
       sos_fs_nscache_unref_node(nsnode);                sos_fs_nscache_unref_node(nsnode);
       return -SOS_ENOENT;                               return -SOS_ENOENT;
     }                                                 }
                                                   
   if (sos_fs_nscache_get_fs_node(nsnode)->typ       if (sos_fs_nscache_get_fs_node(nsnode)->type == SOS_FS_NODE_DIRECTORY)
     retval = -SOS_EISDIR;                             retval = -SOS_EISDIR;
   else                                              else
     retval = fs_remove_node(actor, nsnode);           retval = fs_remove_node(actor, nsnode);
                                                   
   sos_fs_nscache_unref_node(nsnode);                sos_fs_nscache_unref_node(nsnode);
   return retval;                                    return retval;
 }                                                 }
                                                   
                                                   
 sos_ret_t sos_fs_symlink(const struct sos_pro     sos_ret_t sos_fs_symlink(const struct sos_process * creator,
                          const char * _path,                               const char * _path,
                          sos_size_t _pathlen,                              sos_size_t _pathlen,
                          sos_uaddr_t symlink_                              sos_uaddr_t symlink_target,
                          sos_size_t symlink_t                              sos_size_t symlink_target_len)
 {                                                 {
   sos_ret_t retval;                                 sos_ret_t retval;
   struct sos_fs_pathname path;                      struct sos_fs_pathname path;
   struct sos_fs_node * fsnode;                      struct sos_fs_node * fsnode;
   struct sos_fs_nscache_node * symlink;             struct sos_fs_nscache_node * symlink;
   struct sos_fs_opened_file * tmp_of;               struct sos_fs_opened_file * tmp_of;
   sos_size_t len;                                   sos_size_t len;
                                                   
   path.contents = _path;                            path.contents = _path;
   path.length   = _pathlen;                         path.length   = _pathlen;
                                                   
   retval = fs_create_node(& path, creator, SO       retval = fs_create_node(& path, creator, SOS_FS_S_IRWXALL,
                           SOS_FS_NODE_SYMLINK                               SOS_FS_NODE_SYMLINK, & symlink);
   if (SOS_OK != retval)                             if (SOS_OK != retval)
     return retval;                                    return retval;
                                                   
   /* Artificially open the symlink to change        /* Artificially open the symlink to change its contents */
   fsnode = sos_fs_nscache_get_fs_node(symlink       fsnode = sos_fs_nscache_get_fs_node(symlink);
   retval = fsnode->new_opened_file(fsnode, cr       retval = fsnode->new_opened_file(fsnode, creator,
                                    SOS_FS_OPE                                        SOS_FS_OPEN_WRITE, & tmp_of);
   if (SOS_OK != retval)                             if (SOS_OK != retval)
     {                                                 {
       fs_remove_node(creator, symlink);                 fs_remove_node(creator, symlink);
       sos_fs_nscache_unref_node(symlink);               sos_fs_nscache_unref_node(symlink);
       return retval;                                    return retval;
     }                                                 }
                                                   
   tmp_of->ref_cnt = 1;                              tmp_of->ref_cnt = 1;
   retval = sos_fs_nscache_register_opened_fil       retval = sos_fs_nscache_register_opened_file(symlink, tmp_of);
   if (SOS_OK != retval)                             if (SOS_OK != retval)
     {                                                 {
       fsnode->close_opened_file(fsnode, tmp_o           fsnode->close_opened_file(fsnode, tmp_of);
       fs_remove_node(creator, symlink);                 fs_remove_node(creator, symlink);
       sos_fs_nscache_unref_node(symlink);               sos_fs_nscache_unref_node(symlink);
       return retval;                                    return retval;
     }                                                 }
                                                   
   len = symlink_target_len;                         len = symlink_target_len;
   retval = sos_fs_write(tmp_of, symlink_targe       retval = sos_fs_write(tmp_of, symlink_target, & len);
   mark_dirty_fsnode(fsnode, FALSE);                 mark_dirty_fsnode(fsnode, FALSE);
   fsnode->close_opened_file(fsnode, tmp_of);        fsnode->close_opened_file(fsnode, tmp_of);
                                                     
   if ((SOS_OK != retval) || (len != symlink_t       if ((SOS_OK != retval) || (len != symlink_target_len))
     {                                                 {
       fs_remove_node(creator, symlink);                 fs_remove_node(creator, symlink);
       if (SOS_OK == retval)                             if (SOS_OK == retval)
         retval = -SOS_ENAMETOOLONG;                       retval = -SOS_ENAMETOOLONG;
     }                                                 }
                                                   
   sos_fs_nscache_unref_node(symlink);               sos_fs_nscache_unref_node(symlink);
   return retval;                                    return retval;
 }                                                 }
                                                   
                                                   
 sos_ret_t sos_fs_mkdir(const struct sos_proce     sos_ret_t sos_fs_mkdir(const struct sos_process * creator,
                        const char * _path,                               const char * _path,
                        sos_size_t _pathlen,                              sos_size_t _pathlen,
                        sos_ui32_t access_righ                            sos_ui32_t access_rights)
 {                                                 {
   struct sos_fs_pathname path;                      struct sos_fs_pathname path;
                                                   
   path.contents = _path;                            path.contents = _path;
   path.length   = _pathlen;                         path.length   = _pathlen;
                                                   
   return fs_create_node(& path, creator, acce       return fs_create_node(& path, creator, access_rights,
                         SOS_FS_NODE_DIRECTORY                             SOS_FS_NODE_DIRECTORY, NULL);
 }                                                 }
                                                   
                                                   
 sos_ret_t sos_fs_rmdir(const struct sos_proce     sos_ret_t sos_fs_rmdir(const struct sos_process * actor,
                        const char * _path,                               const char * _path,
                        sos_size_t _pathlen)                              sos_size_t _pathlen)
 {                                                 {
   sos_ret_t retval;                                 sos_ret_t retval;
   struct sos_fs_pathname path;                      struct sos_fs_pathname path;
   struct sos_fs_nscache_node * nsnode;              struct sos_fs_nscache_node * nsnode;
                                                   
   path.contents = _path;                            path.contents = _path;
   path.length   = _pathlen;                         path.length   = _pathlen;
                                                   
   if (path.length <= 0)                             if (path.length <= 0)
     return -SOS_ENOENT;                               return -SOS_ENOENT;
                                                   
   if (path.contents[0] == '/')                      if (path.contents[0] == '/')
     nsnode = sos_process_get_root(actor)->dir         nsnode = sos_process_get_root(actor)->direntry;
   else                                              else
     nsnode = sos_process_get_cwd(actor)->dire         nsnode = sos_process_get_cwd(actor)->direntry;
                                                   
   retval = fs_lookup_node(& path, FALSE,            retval = fs_lookup_node(& path, FALSE,
                           sos_process_get_roo                               sos_process_get_root(actor)->direntry,
                           nsnode,                                           nsnode,
                           & nsnode, & path, 0                               & nsnode, & path, 0);
   if (SOS_OK != retval)                             if (SOS_OK != retval)
     return retval;                                    return retval;
                                                   
   /* Make sure the whole path has been resolv       /* Make sure the whole path has been resolved */
   if (path.length > 0)                              if (path.length > 0)
     {                                                 {
       sos_fs_nscache_unref_node(nsnode);                sos_fs_nscache_unref_node(nsnode);
       return -SOS_ENOENT;                               return -SOS_ENOENT;
     }                                                 }
                                                   
   /* Cannot rmdir non-dir nodes */                  /* Cannot rmdir non-dir nodes */
   if (sos_fs_nscache_get_fs_node(nsnode)->typ       if (sos_fs_nscache_get_fs_node(nsnode)->type != SOS_FS_NODE_DIRECTORY)
     retval = -SOS_ENOTDIR;                            retval = -SOS_ENOTDIR;
                                                   
   /* Cannot remove directory if it is still u       /* Cannot remove directory if it is still used by somebody else */
   else if (sos_fs_nscache_get_ref_cnt(nsnode)       else if (sos_fs_nscache_get_ref_cnt(nsnode) > 1)
     retval = -SOS_EBUSY;                              retval = -SOS_EBUSY;
                                                   
   /* Cannot remove directory if it is still h       /* Cannot remove directory if it is still has children stored on
      disk */                                           disk */
   else if (sos_fs_nscache_get_fs_node(nsnode)       else if (sos_fs_nscache_get_fs_node(nsnode)->ondisk_lnk_cnt > 1)
     retval = -SOS_ENOTEMPTY;                          retval = -SOS_ENOTEMPTY;
                                                   
   /* Otherwise, yes : suppress the node on di       /* Otherwise, yes : suppress the node on disk */
   else                                              else
     retval = fs_remove_node(actor, nsnode);           retval = fs_remove_node(actor, nsnode);
                                                   
   sos_fs_nscache_unref_node(nsnode);                sos_fs_nscache_unref_node(nsnode);
   return retval;                                    return retval;
 }                                                 }
                                                   
                                                   
 sos_ret_t sos_fs_mknod(const struct sos_proce     sos_ret_t sos_fs_mknod(const struct sos_process * creator,
                        const char * _path,                               const char * _path,
                        sos_size_t _pathlen,                              sos_size_t _pathlen,
                        sos_fs_node_type_t typ                            sos_fs_node_type_t type /* only block/char allowed */,
                        sos_ui32_t access_righ                            sos_ui32_t access_rights,
                        const struct sos_fs_de                            const struct sos_fs_dev_id_t * devid)
 {                                                 {
   sos_ret_t retval;                                 sos_ret_t retval;
   struct sos_fs_pathname path;                      struct sos_fs_pathname path;
   struct sos_fs_nscache_node * nsnode;              struct sos_fs_nscache_node * nsnode;
   struct sos_fs_node * fsnode;                      struct sos_fs_node * fsnode;
                                                   
   if (type != SOS_FS_NODE_DEVICE_CHAR)        !!    if ((type != SOS_FS_NODE_DEVICE_BLOCK)
                                                   >>        && (type != SOS_FS_NODE_DEVICE_CHAR))
     return -SOS_EINVAL;                               return -SOS_EINVAL;
                                                   
   path.contents = _path;                            path.contents = _path;
   path.length   = _pathlen;                         path.length   = _pathlen;
                                                   
   retval = fs_create_node(& path, creator, ac       retval = fs_create_node(& path, creator, access_rights,
                           type, & nsnode);                                  type, & nsnode);
   if (SOS_OK != retval)                             if (SOS_OK != retval)
     return retval;                                    return retval;
                                                   
   fsnode = sos_fs_nscache_get_fs_node(nsnode)       fsnode = sos_fs_nscache_get_fs_node(nsnode);
   fsnode->dev_id.device_class    = devid->dev       fsnode->dev_id.device_class    = devid->device_class;
   fsnode->dev_id.device_instance = devid->dev       fsnode->dev_id.device_instance = devid->device_instance;
                                                   
   sos_fs_nscache_unref_node(nsnode);                sos_fs_nscache_unref_node(nsnode);
   return SOS_OK;                                    return SOS_OK;
 }                                                 }
                                                   
                                                   
 sos_ret_t sos_fs_stat(const struct sos_proces     sos_ret_t sos_fs_stat(const struct sos_process * actor,
                       const char * _path,                               const char * _path,
                       sos_size_t _pathlen,                              sos_size_t _pathlen,
                       int nofollow,                                     int nofollow,
                       struct sos_fs_stat * re                           struct sos_fs_stat * result)
 {                                                 {
   sos_ret_t retval;                                 sos_ret_t retval;
   struct sos_fs_pathname path;                      struct sos_fs_pathname path;
   struct sos_fs_nscache_node * nsnode;              struct sos_fs_nscache_node * nsnode;
   struct sos_fs_node * fsnode;                      struct sos_fs_node * fsnode;
                                                   
   path.contents = _path;                            path.contents = _path;
   path.length   = _pathlen;                         path.length   = _pathlen;
                                                   
   if (path.length <= 0)                             if (path.length <= 0)
     return -SOS_ENOENT;                               return -SOS_ENOENT;
                                                   
   if (path.contents[0] == '/')                      if (path.contents[0] == '/')
     nsnode = sos_process_get_root(actor)->dir         nsnode = sos_process_get_root(actor)->direntry;
   else                                              else
     nsnode = sos_process_get_cwd(actor)->dire         nsnode = sos_process_get_cwd(actor)->direntry;
                                                   
   retval = fs_lookup_node(& path, (nofollow !       retval = fs_lookup_node(& path, (nofollow != 0),
                           sos_process_get_roo                               sos_process_get_root(actor)->direntry,
                           nsnode,                                           nsnode,
                           & nsnode, & path, 0                               & nsnode, & path, 0);
   if (SOS_OK != retval)                             if (SOS_OK != retval)
     return retval;                                    return retval;
                                                   
   /* Make sure the whole path has been resolv       /* Make sure the whole path has been resolved */
   if (path.length > 0)                              if (path.length > 0)
     {                                                 {
       sos_fs_nscache_unref_node(nsnode);                sos_fs_nscache_unref_node(nsnode);
       return -SOS_ENOENT;                               return -SOS_ENOENT;
     }                                                 }
                                                   
   fsnode = sos_fs_nscache_get_fs_node(nsnode)       fsnode = sos_fs_nscache_get_fs_node(nsnode);
   retval = fsnode->ops_file->stat(fsnode, res       retval = fsnode->ops_file->stat(fsnode, result);
                                                     
   sos_fs_nscache_unref_node(nsnode);                sos_fs_nscache_unref_node(nsnode);
   return retval;                                    return retval;
 }                                                 }
                                                   
                                                   
 sos_ret_t sos_fs_fsync(struct sos_fs_opened_f     sos_ret_t sos_fs_fsync(struct sos_fs_opened_file * of)
 {                                                 {
   struct sos_fs_node * fsnode = sos_fs_nscach       struct sos_fs_node * fsnode = sos_fs_nscache_get_fs_node(of->direntry);
   return fsnode->sync(fsnode);                !!    return sos_fs_sync_node(fsnode);
 }                                                 }
                                                   
                                                   
 sos_ret_t sos_fs_chmod(const struct sos_proce     sos_ret_t sos_fs_chmod(const struct sos_process * actor,
                        const char * _path,                               const char * _path,
                        sos_size_t _pathlen,                              sos_size_t _pathlen,
                        sos_ui32_t access_righ                            sos_ui32_t access_rights)
 {                                                 {
   sos_ret_t retval;                                 sos_ret_t retval;
   struct sos_fs_pathname path;                      struct sos_fs_pathname path;
   struct sos_fs_nscache_node * nsnode;              struct sos_fs_nscache_node * nsnode;
   struct sos_fs_node * fsnode;                      struct sos_fs_node * fsnode;
                                                   
   path.contents = _path;                            path.contents = _path;
   path.length   = _pathlen;                         path.length   = _pathlen;
                                                   
   if (path.length <= 0)                             if (path.length <= 0)
     return -SOS_ENOENT;                               return -SOS_ENOENT;
                                                   
   if (path.contents[0] == '/')                      if (path.contents[0] == '/')
     nsnode = sos_process_get_root(actor)->dir         nsnode = sos_process_get_root(actor)->direntry;
   else                                              else
     nsnode = sos_process_get_cwd(actor)->dire         nsnode = sos_process_get_cwd(actor)->direntry;
                                                   
   retval = fs_lookup_node(& path, TRUE,             retval = fs_lookup_node(& path, TRUE,
                           sos_process_get_roo                               sos_process_get_root(actor)->direntry,
                           nsnode,                                           nsnode,
                           & nsnode, & path, 0                               & nsnode, & path, 0);
   if (SOS_OK != retval)                             if (SOS_OK != retval)
     return retval;                                    return retval;
                                                   
   /* Make sure the whole path has been resolv       /* Make sure the whole path has been resolved */
   if (path.length > 0)                              if (path.length > 0)
     {                                                 {
       sos_fs_nscache_unref_node(nsnode);                sos_fs_nscache_unref_node(nsnode);
       return -SOS_ENOENT;                               return -SOS_ENOENT;
     }                                                 }
                                                   
   fsnode = sos_fs_nscache_get_fs_node(nsnode)       fsnode = sos_fs_nscache_get_fs_node(nsnode);
   retval = fsnode->ops_file->chmod(fsnode, ac       retval = fsnode->ops_file->chmod(fsnode, access_rights);
   if (SOS_OK == retval)                             if (SOS_OK == retval)
     mark_dirty_fsnode(fsnode, FALSE);                 mark_dirty_fsnode(fsnode, FALSE);
                                                     
   sos_fs_nscache_unref_node(nsnode);                sos_fs_nscache_unref_node(nsnode);
   return retval;                                    return retval;
 }                                                 }
                                                   
                                                   
 sos_ret_t sos_fs_vfstat(const struct sos_proc     sos_ret_t sos_fs_vfstat(const struct sos_process * actor,
                         const char * _path,                               const char * _path,
                         sos_size_t _pathlen,                              sos_size_t _pathlen,
                         struct sos_fs_statfs                              struct sos_fs_statfs * result)
 {                                                 {
   sos_ret_t retval;                                 sos_ret_t retval;
   struct sos_fs_pathname path;                      struct sos_fs_pathname path;
   struct sos_fs_nscache_node * nsnode;              struct sos_fs_nscache_node * nsnode;
   struct sos_fs_node * fsnode;                      struct sos_fs_node * fsnode;
                                                   
   path.contents = _path;                            path.contents = _path;
   path.length   = _pathlen;                         path.length   = _pathlen;
                                                   
   if (path.length <= 0)                             if (path.length <= 0)
     return -SOS_ENOENT;                               return -SOS_ENOENT;
                                                   
   if (path.contents[0] == '/')                      if (path.contents[0] == '/')
     nsnode = sos_process_get_root(actor)->dir         nsnode = sos_process_get_root(actor)->direntry;
   else                                              else
     nsnode = sos_process_get_cwd(actor)->dire         nsnode = sos_process_get_cwd(actor)->direntry;
                                                   
   retval = fs_lookup_node(& path, FALSE,            retval = fs_lookup_node(& path, FALSE,
                           sos_process_get_roo                               sos_process_get_root(actor)->direntry,
                           nsnode,                                           nsnode,
                           & nsnode, & path, 0                               & nsnode, & path, 0);
   if (SOS_OK != retval)                             if (SOS_OK != retval)
     return retval;                                    return retval;
                                                   
   /* Make sure the whole path has been resolv       /* Make sure the whole path has been resolved */
   if (path.length > 0)                              if (path.length > 0)
     {                                                 {
       sos_fs_nscache_unref_node(nsnode);                sos_fs_nscache_unref_node(nsnode);
       return -SOS_ENOENT;                               return -SOS_ENOENT;
     }                                                 }
                                                   
   fsnode = sos_fs_nscache_get_fs_node(nsnode)       fsnode = sos_fs_nscache_get_fs_node(nsnode);
   if (fsnode->fs->statfs)                           if (fsnode->fs->statfs)
     retval = fsnode->fs->statfs(fsnode->fs, r         retval = fsnode->fs->statfs(fsnode->fs, result);
   else                                              else
     retval = -SOS_ENOSYS;                             retval = -SOS_ENOSYS;
                                                     
   sos_fs_nscache_unref_node(nsnode);                sos_fs_nscache_unref_node(nsnode);
   return retval;                                    return retval;  
 }                                                 }
                                                   
                                                   
 /** This function is resilient against mounti     /** This function is resilient against mounting/unmounting of other FS */
 sos_ret_t sos_fs_sync_all_fs()                    sos_ret_t sos_fs_sync_all_fs()
 {                                                 {
   int dummy = 0;                                    int dummy = 0;
   sos_ui64_t uid = 0;                               sos_ui64_t uid = 0;
                                                   
   while (1)                                         while (1)
     {                                                 {
       /* Iterate over the FS types */                   /* Iterate over the FS types */
       struct sos_fs_manager_type * fstype;              struct sos_fs_manager_type * fstype;
       int ntype;                                        int ntype;
       list_foreach(fs_list, fstype, ntype)              list_foreach(fs_list, fstype, ntype)
         {                                                 {
           /* Iterate over the FS instances */               /* Iterate over the FS instances */
           struct sos_fs_manager_instance * fs               struct sos_fs_manager_instance * fs;
           int ninst;                                        int ninst;
                                                   
           list_foreach(fstype->instances, fs, !!            /* This scan will be exhaustive and resilient to
                                                   >>               addition/removal of file systems as long as new FS are
                                                   >>               added with list_add_tail (because the scan is "forward",
                                                   >>               ie in order head -> tail) */
                                                   >>  
                                                   >>            /* As long as we don't block, we can safely access the
                                                   >>               prev/next fields of the FS instance */
                                                   >>            list_foreach_forward(fstype->instances, fs, ninst)
             {                                                 {
               if (fs->uid <= uid)                               if (fs->uid <= uid)
                 continue;                                         continue;
                                                   
               uid = fs->uid;                                    uid = fs->uid;
               sos_fs_sync_fs(fs);                               sos_fs_sync_fs(fs);
                                                   
               /* We must NOT continue the loo                   /* We must NOT continue the loops because the
                  prev/next/current fs types/i                      prev/next/current fs types/instances might have been
                  removed or added (sync block                      removed or added (sync blocks, by definition) ! */
               goto lookup_next_fs;                              goto lookup_next_fs;
             }                                                 }
         }                                                 }
                                                   
                                                   >>        /* Reached the end of the list */
                                                   >>        break;
                                                   >>  
     lookup_next_fs:                                   lookup_next_fs:
       /* Loop over */                                   /* Loop over */
       dummy ++;                                         dummy ++;
     }                                                 }
                                                   
   return SOS_OK;                              !!    /* Now flush all the block devices to disk */
                                                   >>    return sos_blockdev_sync_all_devices();
 }                                                 }
                                                   
                                                   
                                                   
 /* ******************************************     /* *************************************************************
  * mount/umount stuff                              * mount/umount stuff
  */                                                */
                                                   
                                                   
 sos_ret_t sos_fs_register_fs_instance(struct      sos_ret_t sos_fs_register_fs_instance(struct sos_fs_manager_instance * fs,
                                       struct                                            struct sos_fs_node * root_fsnode)
 {                                                 {
   sos_ret_t retval;                                 sos_ret_t retval;
   struct sos_fs_nscache_node * nsnode_root;         struct sos_fs_nscache_node * nsnode_root;
                                                   
   retval = sos_fs_nscache_create_mounted_root       retval = sos_fs_nscache_create_mounted_root(root_fsnode, & nsnode_root);
   if (SOS_OK != retval)                             if (SOS_OK != retval)
     return retval;                                    return retval;
                                                   
   fs->uid  = ++last_fs_instance_uid;                fs->uid  = ++last_fs_instance_uid;
   fs->root = nsnode_root;                           fs->root = nsnode_root;
   sos_hash_insert(fs->nodecache, root_fsnode)       sos_hash_insert(fs->nodecache, root_fsnode);
                                                   
   list_add_tail(fs->fs_type->instances, fs);        list_add_tail(fs->fs_type->instances, fs);
   return SOS_OK;                                    return SOS_OK;
 }                                                 }
                                                   
                                                   
 sos_ret_t sos_fs_unregister_fs_instance(struc     sos_ret_t sos_fs_unregister_fs_instance(struct sos_fs_manager_instance * fs)
 {                                                 {
   fs->uid = 0;                                      fs->uid = 0;
   list_delete(fs->fs_type->instances, fs);          list_delete(fs->fs_type->instances, fs);
   return SOS_OK;                                    return SOS_OK;
 }                                                 }
                                                   
                                                   
 sos_ret_t sos_fs_register_fs_type(struct sos_     sos_ret_t sos_fs_register_fs_type(struct sos_fs_manager_type * fstype)
 {                                                 {
   struct sos_fs_manager_type * iterator;            struct sos_fs_manager_type * iterator;
   int nbtypes;                                      int nbtypes;
                                                   
   list_foreach_forward(fs_list, iterator, nbt       list_foreach_forward(fs_list, iterator, nbtypes)
     {                                                 {
       if (! strncmp(fstype->name, iterator->n           if (! strncmp(fstype->name, iterator->name, SOS_FS_MANAGER_NAME_MAXLEN))
         return -SOS_EEXIST;                               return -SOS_EEXIST;
     }                                                 }
                                                   
   list_add_tail(fs_list, fstype);                   list_add_tail(fs_list, fstype);
   return SOS_OK;                                    return SOS_OK;
 }                                                 }
                                                   
                                                   
 sos_ret_t sos_fs_unregister_fs_type(struct so     sos_ret_t sos_fs_unregister_fs_type(struct sos_fs_manager_type * fstype)
 {                                                 {
   struct sos_fs_manager_type * iterator;            struct sos_fs_manager_type * iterator;
   int nbtypes;                                      int nbtypes;
                                                   
   if (! list_is_empty(fstype->instances))           if (! list_is_empty(fstype->instances))
     return -SOS_EBUSY;                                return -SOS_EBUSY;
                                                   
   list_foreach_forward(fs_list, iterator, nbt       list_foreach_forward(fs_list, iterator, nbtypes)
     {                                                 {
       if (! strncmp(fstype->name, iterator->n           if (! strncmp(fstype->name, iterator->name, SOS_FS_MANAGER_NAME_MAXLEN))
         {                                                 {
           list_delete(fs_list, fstype);                     list_delete(fs_list, fstype);
           return SOS_OK;                                    return SOS_OK;
         }                                                 }
     }                                                 }
                                                   
   return -SOS_EINVAL;                               return -SOS_EINVAL;
 }                                                 }
                                                   
                                                   
 /**                                               /**
  * _src_path may be empty                          * _src_path may be empty
  */                                                */
 sos_ret_t sos_fs_mount(struct sos_process * a     sos_ret_t sos_fs_mount(struct sos_process * actor,
                        const char * _src_path                            const char * _src_path,
                        sos_size_t _src_pathle                            sos_size_t _src_pathlen,
                        const char * _dst_path                            const char * _dst_path,
                        sos_size_t _dst_pathle                            sos_size_t _dst_pathlen,
                        const char * fsname,                              const char * fsname,
                        sos_ui32_t mountflags,                            sos_ui32_t mountflags,
                        const char * args,                                const char * args,
                        struct sos_fs_manager_                            struct sos_fs_manager_instance ** result_fs)
 {                                                 {
   sos_ret_t retval;                                 sos_ret_t retval;
   struct sos_fs_pathname src_path, dst_path;        struct sos_fs_pathname src_path, dst_path;
   struct sos_fs_nscache_node * src_nsnode, *        struct sos_fs_nscache_node * src_nsnode, * dst_nsnode;
   struct sos_fs_manager_type * fs_type;             struct sos_fs_manager_type * fs_type;
   struct sos_fs_manager_instance * new_fs;          struct sos_fs_manager_instance * new_fs;
   int nb_fstypes;                                   int nb_fstypes;
                                                   
   if (_dst_pathlen <= 0)                            if (_dst_pathlen <= 0)
     return -SOS_ENOENT;                               return -SOS_ENOENT;
                                                   
   /* Look for the FS manager type */                /* Look for the FS manager type */
   list_foreach(fs_list, fs_type, nb_fstypes)        list_foreach(fs_list, fs_type, nb_fstypes)
     {                                                 {
       if (! strcmp(fsname, fs_type->name))              if (! strcmp(fsname, fs_type->name))
         break;                                            break;
     }                                                 }
   if (! list_foreach_early_break(fs_list, fs_       if (! list_foreach_early_break(fs_list, fs_type, nb_fstypes))
     return -SOS_ENODEV;                               return -SOS_ENODEV;
                                                   
   src_path.contents = _src_path;                    src_path.contents = _src_path;
   src_path.length   = _src_pathlen;                 src_path.length   = _src_pathlen;
                                                   
   /* Compute the start_nsnode for the source        /* Compute the start_nsnode for the source */
   if (src_path.length <= 0)                         if (src_path.length <= 0)
     src_nsnode = NULL;                                src_nsnode = NULL;
   else if (src_path.contents[0] == '/')             else if (src_path.contents[0] == '/')
     src_nsnode = sos_process_get_root(actor)-         src_nsnode = sos_process_get_root(actor)->direntry;
   else                                              else
     src_nsnode = sos_process_get_cwd(actor)->         src_nsnode = sos_process_get_cwd(actor)->direntry;
                                                   
   /* Lookup the source node */                      /* Lookup the source node */
   if (src_nsnode)                                   if (src_nsnode)
     {                                                 {
       retval = fs_lookup_node(& src_path, TRU           retval = fs_lookup_node(& src_path, TRUE,
                               sos_process_get                                   sos_process_get_root(actor)->direntry,
                               src_nsnode,                                       src_nsnode,
                               & src_nsnode, &                                   & src_nsnode, & src_path, 0);
       if (SOS_OK != retval)                             if (SOS_OK != retval)
         return retval;                                    return retval;
                                                   
       /* Make sure the whole path has been re           /* Make sure the whole path has been resolved */
       if (src_path.length > 0)                          if (src_path.length > 0)
         {                                                 {
           sos_fs_nscache_unref_node(src_nsnod               sos_fs_nscache_unref_node(src_nsnode);
           return -SOS_ENOENT;                               return -SOS_ENOENT;
         }                                                 }
     }                                                 }
                                                   
   dst_path.contents = _dst_path;                    dst_path.contents = _dst_path;
   dst_path.length   = _dst_pathlen;                 dst_path.length   = _dst_pathlen;
                                                   
   /* Compute the start_nsnode for the destina       /* Compute the start_nsnode for the destination */
   if (dst_path.contents[0] == '/')                  if (dst_path.contents[0] == '/')
     dst_nsnode = sos_process_get_root(actor)-         dst_nsnode = sos_process_get_root(actor)->direntry;
   else                                              else
     dst_nsnode = sos_process_get_cwd(actor)->         dst_nsnode = sos_process_get_cwd(actor)->direntry;
                                                   
   /* Lookup the destination node */                 /* Lookup the destination node */
   retval = fs_lookup_node(& dst_path, TRUE,         retval = fs_lookup_node(& dst_path, TRUE,
                           sos_process_get_roo                               sos_process_get_root(actor)->direntry,
                           dst_nsnode,                                       dst_nsnode,
                           & dst_nsnode, & dst                               & dst_nsnode, & dst_path, 0);
   if ((SOS_OK != retval) || (dst_path.length        if ((SOS_OK != retval) || (dst_path.length > 0))
     {                                                 {
       if (src_nsnode)                                   if (src_nsnode)
         sos_fs_nscache_unref_node(src_nsnode)             sos_fs_nscache_unref_node(src_nsnode);
       if (dst_path.length > 0)                          if (dst_path.length > 0)
         retval = -SOS_ENOENT;                             retval = -SOS_ENOENT;
       return retval;                                    return retval;
     }                                                 }
                                                   
   /* Actually call the mount callback of the        /* Actually call the mount callback of the FS */
   retval                                            retval
     = fs_type->mount(fs_type,                         = fs_type->mount(fs_type,
                      (src_nsnode)?sos_fs_nsca                          (src_nsnode)?sos_fs_nscache_get_fs_node(src_nsnode):NULL,
                      args, & new_fs);                                  args, & new_fs);
   if (SOS_OK != retval)                             if (SOS_OK != retval)
     {                                                 {
       if (src_nsnode)                                   if (src_nsnode)
         sos_fs_nscache_unref_node(src_nsnode)             sos_fs_nscache_unref_node(src_nsnode);
       sos_fs_nscache_unref_node(dst_nsnode);            sos_fs_nscache_unref_node(dst_nsnode);
       return retval;                                    return retval;
     }                                                 }
                                                   
   /* Make sure the nodecache was created */         /* Make sure the nodecache was created */
   SOS_ASSERT_FATAL(NULL != new_fs->nodecache)       SOS_ASSERT_FATAL(NULL != new_fs->nodecache);
   SOS_ASSERT_FATAL(NULL != new_fs->root);           SOS_ASSERT_FATAL(NULL != new_fs->root);
                                                   
   /* Update some reserved fields */                 /* Update some reserved fields */
   sos_fs_nscache_get_fs_node(new_fs->root)->f       sos_fs_nscache_get_fs_node(new_fs->root)->fs = new_fs;
                                                   
   /* Register the mountpoint in the nscache *       /* Register the mountpoint in the nscache */
   retval = sos_fs_nscache_mount(dst_nsnode, n       retval = sos_fs_nscache_mount(dst_nsnode, new_fs->root);
   SOS_ASSERT_FATAL(SOS_OK == retval);               SOS_ASSERT_FATAL(SOS_OK == retval);
                                                   
   /* Un-reference the temporary nsnodes */          /* Un-reference the temporary nsnodes */
   if (src_nsnode)                                   if (src_nsnode)
     sos_fs_nscache_unref_node(src_nsnode);            sos_fs_nscache_unref_node(src_nsnode);
   sos_fs_nscache_unref_node(dst_nsnode);            sos_fs_nscache_unref_node(dst_nsnode);
                                                   
   if (result_fs)                                    if (result_fs)
     *result_fs = new_fs;                              *result_fs = new_fs;
                                                   
   return SOS_OK;                                    return SOS_OK;
 }                                                 }
                                                   
                                                   
 sos_ret_t sos_fs_umount(struct sos_process *      sos_ret_t sos_fs_umount(struct sos_process * actor,
                         const char * _mounted                             const char * _mounted_root_path,
                         sos_size_t _mounted_r                             sos_size_t _mounted_root_pathlen)
 {                                                 {
   sos_ret_t retval;                                 sos_ret_t retval;
   struct sos_fs_pathname mounted_root_path;         struct sos_fs_pathname mounted_root_path;
   struct sos_fs_nscache_node * mounted_root_n       struct sos_fs_nscache_node * mounted_root_nsnode;
   struct sos_fs_manager_instance * fs;              struct sos_fs_manager_instance * fs;
                                                   
   if (_mounted_root_pathlen <= 0)                   if (_mounted_root_pathlen <= 0)
     return -SOS_ENOENT;                               return -SOS_ENOENT;
                                                   
   mounted_root_path.contents = _mounted_root_       mounted_root_path.contents = _mounted_root_path;
   mounted_root_path.length   = _mounted_root_       mounted_root_path.length   = _mounted_root_pathlen;
                                                   
   /* Compute the start_nsnode for the mounted       /* Compute the start_nsnode for the mounted_root */
   if (mounted_root_path.contents[0] == '/')         if (mounted_root_path.contents[0] == '/')
     mounted_root_nsnode = sos_process_get_roo         mounted_root_nsnode = sos_process_get_root(actor)->direntry;
   else                                              else
     mounted_root_nsnode = sos_process_get_cwd         mounted_root_nsnode = sos_process_get_cwd(actor)->direntry;
                                                   
   /* Lookup the mounted_root node */                /* Lookup the mounted_root node */
   retval = fs_lookup_node(& mounted_root_path       retval = fs_lookup_node(& mounted_root_path, TRUE,
                           sos_process_get_roo                               sos_process_get_root(actor)->direntry,
                           mounted_root_nsnode                               mounted_root_nsnode,
                           & mounted_root_nsno                               & mounted_root_nsnode, & mounted_root_path, 0);
   if (SOS_OK != retval)                             if (SOS_OK != retval)
     return retval;                                    return retval;
                                                   
   /* Make sure the whole path has been resolv       /* Make sure the whole path has been resolved */
   if (mounted_root_path.length > 0)                 if (mounted_root_path.length > 0)
     {                                                 {
       sos_fs_nscache_unref_node(mounted_root_           sos_fs_nscache_unref_node(mounted_root_nsnode);
       return -SOS_ENOENT;                               return -SOS_ENOENT;
     }                                                 }
                                                   
   /* Make sure this node is the real root of        /* Make sure this node is the real root of the FS */
   fs = sos_fs_nscache_get_fs_node(mounted_roo       fs = sos_fs_nscache_get_fs_node(mounted_root_nsnode)->fs;
   if (fs->root != mounted_root_nsnode)              if (fs->root != mounted_root_nsnode)
     {                                                 {
       sos_fs_nscache_unref_node(mounted_root_           sos_fs_nscache_unref_node(mounted_root_nsnode);
       return -SOS_ENOENT;                               return -SOS_ENOENT;
     }                                                 }
                                                   
   /* Disconnect this FS mounted_root from nam       /* Disconnect this FS mounted_root from namespace cache */
   retval = sos_fs_nscache_umount(mounted_root       retval = sos_fs_nscache_umount(mounted_root_nsnode);
                                                   
   /* Mounted_Root not needed anymore */             /* Mounted_Root not needed anymore */
   sos_fs_nscache_unref_node(mounted_root_nsno       sos_fs_nscache_unref_node(mounted_root_nsnode);
   if (SOS_OK != retval)                             if (SOS_OK != retval)
     return retval;                                    return retval;
                                                   
   fs->root = NULL;                                  fs->root = NULL;
                                                   
   /* Flush any changes to disk */                   /* Flush any changes to disk */
   retval = sos_fs_sync_fs(fs);                      retval = sos_fs_sync_fs(fs);
   if (SOS_OK != retval)                             if (SOS_OK != retval)
     {                                                 {
       return retval;                                    return retval;
     }                                                 }
                                                   
   retval = fs->fs_type->umount(fs->fs_type, f       retval = fs->fs_type->umount(fs->fs_type, fs);
   return retval;                                    return retval;
 }                                                 }
                                                      

---

[ source navigation ]

[ diff markup ]

[ identifier search ]

[ general search ]