Changeset 611 for trunk/kernel

Timestamp:

Jan 9, 2019, 3:02:51 PM (6 years ago)

Author:

alain

Message:

Introduce sigificant modifs in VFS to support the <ls> command,
and the . and .. directories entries.

Location:

trunk/kernel

Files:

• Makefile (modified) (1 diff)
• fs/fatfs.c (modified) (3 diffs)
• fs/fatfs.h (modified) (2 diffs)
• fs/vfs.c (modified) (20 diffs)
• fs/vfs.h (modified) (12 diffs)
• kern/cluster.h (modified) (1 diff)
• kern/kernel_init.c (modified) (1 diff)
• kern/process.c (modified) (4 diffs)
• kern/process.h (modified) (2 diffs)
• kern/rpc.c (modified) (43 diffs)
• kern/rpc.h (modified) (6 diffs)
• kern/thread.c (modified) (6 diffs)
• kernel_config.h (modified) (11 diffs)
• libk/remote_mutex.c (modified) (1 diff)
• libk/remote_mutex.h (modified) (1 diff)
• libk/string.h (modified) (2 diffs)
• libk/xhtab.h (modified) (2 diffs)
• mm/kmem.c (modified) (9 diffs)
• mm/kmem.h (modified) (1 diff)
• mm/mapper.c (modified) (1 diff)
• mm/mapper.h (modified) (7 diffs)
• mm/ppm.c (modified) (9 diffs)
• mm/ppm.h (modified) (2 diffs)
• mm/vmm.c (modified) (18 diffs)
• mm/vmm.h (modified) (8 diffs)
• mm/vseg.h (modified) (1 diff)
• syscalls/shared_include/shared_almos.h (modified) (1 diff)
• syscalls/shared_include/shared_dirent.h (modified) (1 diff)
• syscalls/shared_include/shared_stat.h (modified) (4 diffs)
• syscalls/sys_closedir.c (modified) (4 diffs)
• syscalls/sys_display.c (modified) (3 diffs)
• syscalls/sys_mmap.c (modified) (3 diffs)
• syscalls/sys_opendir.c (modified) (6 diffs)
• syscalls/sys_readdir.c (modified) (3 diffs)
• syscalls/syscalls.h (modified) (5 diffs)

trunk/kernel/Makefile

@@ -122 +122 @@
               build/libk/remote_fifo.o      \
               build/libk/remote_mutex.o     \
+              build/libk/remote_dir.o       \
               build/libk/remote_sem.o       \
               build/libk/remote_condvar.o   \

trunk/kernel/fs/fatfs.c

@@ -2011 +2011 @@
 
     // get pointer on local FATFS context
-    fatfs_ctx_t * fatfs_ctx      = fs_context[FS_TYPE_FATFS].extend;
+    fatfs_ctx_t * fatfs_ctx = fs_context[FS_TYPE_FATFS].extend;
 
     // get page base address
@@ -2034 +2034 @@
 #if (DEBUG_FATFS_MOVE_PAGE & 0x1)
 if( DEBUG_FATFS_MOVE_PAGE < cycle )
-{
-    uint32_t * tab = (uint32_t *)buffer;
-    uint32_t line , word;
-    printk("\n***** %s : First 64 words of page %d in FAT mapper\n",
-    __FUNCTION__ , page_id );
-    for( line = 0 ; line < 8 ; line++ )
-    {
-        printk("%X : ", line );
-        for( word = 0 ; word < 8 ; word++ ) printk("%X ", tab[(line<<3) + word] );
-        printk("\n");
-    }
-}
+mapper_display_page( XPTR(page_cxy , mapper_ptr) , page_id , "FAT" );
 #endif
 
@@ -2103 +2092 @@
 #if (DEBUG_FATFS_MOVE_PAGE & 0x1)
 if( DEBUG_FATFS_MOVE_PAGE < cycle )
-{
-    uint32_t * tab = (uint32_t *)buffer;
-    uint32_t line , word;
-    printk("\n***** %s : First 64 words of page %d in <%s> mapper\n",
-    __FUNCTION__, page_id, name );
-    for( line = 0 ; line < 8 ; line++ )
-    {
-        printk("%X : ", line );
-        for( word = 0 ; word < 8 ; word++ ) printk("%X ", tab[(line<<3) + word] );
-        printk("\n");
-    }
-}
+char string[CONFIG_VFS_MAX_NAME_LENGTH];
+vfs_inode_get_name( XPTR(page_cxy , inode_ptr) , string );
+mapper_display_page( XPTR(page_cxy , mapper_ptr) , page_id , string );
 #endif
 

trunk/kernel/fs/fatfs.h

@@ -238 +238 @@
 
 
-
 //////////////////////////////////////////////////////////////////////////////////////////
 // Generic API: These functions are called by the kernel VFS,
@@ -409 +408 @@
  *****************************************************************************************
  * This function moves a page from/to the mapper to/from the FATFS file system on device.
- * The page must have been previously allocated and registered in the mapper, but the  
- * page - and the mapper - can be located in another cluster than the calling thread.
+ * The page must have been previously allocated and registered in the mapper.   
+ * The page - and the mapper - can be located in another cluster than the calling thread.
  * The pointer on the mapper and the page index in file are found in the page descriptor.
- * It is used both for the regular file/directory mappers, and for the FAT mapper.
+ * It is used for both for a regular file/directory mapper, and the FAT mapper.
  * For the FAT mapper, it access the FATFS to get the location on IOC device.
  * For a regular file, it access the FAT mapper to get the cluster index on IOC device.

trunk/kernel/fs/vfs.c

@@ -23 +23 @@
  */
 
-
 #include <kernel_config.h>
 #include <hal_kernel_types.h>
@@ -48 +47 @@
 #include <syscalls.h>
 
-
 //////////////////////////////////////////////////////////////////////////////////////////
 //           Extern variables         
@@ -136 +134 @@
         case INODE_TYPE_SOCK: return "SOCK";
         case INODE_TYPE_DEV:  return "DEV ";
+        case INODE_TYPE_BLK:  return "BLK ";
         case INODE_TYPE_SYML: return "SYML";
         default:              return "undefined";
@@ -1009 +1008 @@
     cxy_t          vfs_root_cxy;       // VFS root inode cluster identifier
     xptr_t         lock_xp;            // extended pointer on lock protecting Inode Tree
-    xptr_t         inode_xp;           // extended pointer on target inode
-    vfs_inode_t  * inode_ptr;          // local pointer on target inode
-    cxy_t          inode_cxy;          // target inode cluster identifier
+    xptr_t         inode_xp;           // extended pointer on new directory inode
+    vfs_inode_t  * inode_ptr;          // local pointer on new directory inode
+    cxy_t          inode_cxy;          // new directory inode cluster identifier
     xptr_t         dentry_xp;          // extended pointer on new dentry
-    vfs_dentry_t * dentry_ptr;         // target dentry local pointer
-    xptr_t         parent_xp;          // extended pointer on new parent inode
-    vfs_inode_t  * parent_ptr;         // local pointer on new parent inode  
-    cxy_t          parent_cxy;         // new parent inode cluster identifier
-    vfs_ctx_t    * parent_ctx_ptr;     // local pointer on target inode context
-    uint32_t       parent_fs_type;     // target inode file system type
+    vfs_dentry_t * dentry_ptr;         // new dentry local pointer
+    xptr_t         parent_xp;          // extended pointer on parent inode
+    vfs_inode_t  * parent_ptr;         // local pointer on parent inode  
+    cxy_t          parent_cxy;         // parent inode cluster identifier
+    vfs_ctx_t    * parent_ctx_ptr;     // local pointer on parent inode context
+    uint32_t       parent_fs_type;     // parent inode file system type
 
     xptr_t         parents_root_xp;    // extended pointer on parents field in inode (root)
@@ -1109 +1108 @@
 #endif
 
-    // 3. create new directory inode in child cluster
+    // 3. create new directory inode
     // TODO : define attr / uid / gid
     uint32_t attr = 0;
@@ -1118 +1117 @@
     inode_cxy = cluster_random_select();
     
-    if( inode_cxy == local_cxy )      // child cluster is local 
+    if( inode_cxy == local_cxy )      // target cluster is local 
     {
         error = vfs_inode_create( parent_fs_type,
@@ -1128 +1127 @@
                                   &inode_xp );
     }
-    else                              // child cluster is remote
+    else                              // target cluster is remote
     {
         rpc_vfs_inode_create_client( inode_cxy,
@@ -1143 +1142 @@
     if( error )
     {
+        remote_rwlock_wr_release( lock_xp );
         printk("\n[ERROR] in %s : cannot create new inode in cluster %x for <%s>\n",
                __FUNCTION__ , inode_cxy , path );
- 
         if( parent_cxy == local_cxy ) vfs_dentry_destroy( dentry_ptr );
         else rpc_vfs_dentry_destroy_client( parent_cxy , dentry_ptr );
@@ -1181 +1180 @@
 #endif
 
+    // 7. create the two special dentries <.> and <..> in new directory
+    // both the new directory mapper, and the Inode Tree are updated
+    error = vfs_add_special_dentries( inode_xp,
+                                      parent_xp );
+
+    if( error )
+    {
+        remote_rwlock_wr_release( lock_xp );
+        printk("\n[ERROR] in %s : cannot create new inode in cluster %x for <%s>\n",
+               __FUNCTION__ , inode_cxy , path );
+        if( parent_cxy == local_cxy ) vfs_dentry_destroy( dentry_ptr );
+        else rpc_vfs_dentry_destroy_client( parent_cxy , dentry_ptr );
+        return -1;
+    }
+
     // release the lock protecting Inode Tree
     remote_rwlock_wr_release( lock_xp );
 
-    // 5. update parent directory mapper 
+    // 8. update parent directory mapper 
     //    and synchronize the parent directory on IOC device
     if (parent_cxy == local_cxy)
@@ -1625 +1639 @@
 }  // end vfs_unlink() 
 
-///////////////////////////////////////////
-error_t vfs_stat( xptr_t     root_inode_xp,
-                  char     * path,
-                  stat_t   * st )
+////////////////////////////////////////////////
+error_t vfs_stat( xptr_t         root_inode_xp,
+                  char         * path,
+                  struct stat  * st )
 {
     error_t       error;
@@ -1936 +1950 @@
                   inode_inum, inode_size, inode_dirty, inode_cxy, inode_ptr, mapper_ptr );
 
-    // scan directory entries  
-    if( inode_type == INODE_TYPE_DIR )
+    // scan directory entries when current inode is a directory
+    // don't scan the the "." and ".." directories to break loops 
+    if( (inode_type == INODE_TYPE_DIR) && 
+        (strcmp( name , "." ) != 0)    &&
+        (strcmp( name , ".." ) != 0) )
     {
         // get extended pointer on directory entries xhtab
@@ -2234 +2251 @@
         error = vfs_get_name_from_path( current , name , &next , &last );
 
-        // VFS root case
+        // handle VFS root case
         if ( error )
         {
@@ -2258 +2275 @@
                                name,
                                &child_xp );
+
+        // get child inode local pointer and cluster
+        child_ptr  = GET_PTR( child_xp );
+        child_cxy  = GET_CXY( child_xp );
 
         // analyse found & last, depending on lookup_mode
@@ -2302 +2323 @@
                 else      child_type = INODE_TYPE_FILE;
  
-                // insert (speculatively) a new child dentry/inode in inode tree
+                // insert a new child dentry/inode couple in inode tree
                 error = vfs_add_child_in_parent( child_cxy,
                                                  child_type, 
@@ -2326 +2347 @@
 #endif
                 // scan parent mapper to find the missing dentry, and complete 
-                // the initialisation of dentry and child inode desciptors
+                // the initialisation of dentry and child inode descriptors
                 if( parent_cxy == local_cxy )
-
                 {
                     error = vfs_fs_child_init( parent_ptr,
@@ -2424 +2444 @@
 if( DEBUG_VFS_LOOKUP < cycle )
 printk("\n[%s] thread[%x,%x] found <%s> in Inode Tree / inode (%x,%x)\n",
-__FUNCTION__, process->pid, this->trdid, name, GET_CXY(child_xp), GET_PTR(child_xp) );
-#endif
-            // get child inode local pointer and cluster
-            child_ptr  = GET_PTR( child_xp );
-            child_cxy  = GET_CXY( child_xp );
-
+__FUNCTION__, process->pid, this->trdid, name, child_cxy, child_ptr );
+#endif
             // check the excl flag
             if( last && create && excl )
@@ -2584 +2600 @@
 
 }  // end vfs_new_child_init()
+
+///////////////////////////////////////////////////
+error_t vfs_add_special_dentries( xptr_t  child_xp,
+                                  xptr_t  parent_xp )
+{
+    error_t         error;
+    vfs_inode_t   * child_ptr;         // local pointer on child inode directory
+    cxy_t           child_cxy;         // child inode directory cluster identifier
+    vfs_inode_t   * parent_ptr;        // local pointer on parent inode directory
+    cxy_t           parent_cxy;        // parent inode directory cluster identifier
+    vfs_ctx_t     * ctx_ptr;           // local pointer on child inode FS context
+    vfs_fs_type_t   fs_type;           // FS type of child inode
+    xptr_t          dentry_xp;         // extended pointer on dentry (used for . and ..)
+    vfs_dentry_t  * dentry_ptr;        // local pointer on dentry (used for . and ..) 
+
+    xptr_t          parents_root_xp;   // extended pointer on inode "parents" field
+    xptr_t          parents_entry_xp;  // extended pointer on dentry "parents" field
+    xptr_t          children_xhtab_xp; // extended pointer on inode "children" field
+    xptr_t          children_entry_xp; // extended pointer on dentry "children" field
+
+#if DEBUG_VFS_ADD_SPECIAL
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+thread_t * this  = CURRENT_THREAD;
+char child_name[CONFIG_VFS_MAX_NAME_LENGTH];
+char parent_name[CONFIG_VFS_MAX_NAME_LENGTH];
+vfs_inode_get_name( child_xp  , child_name );
+vfs_inode_get_name( parent_xp , parent_name );
+if( DEBUG_VFS_ADD_SPECIAL < cycle )
+printk("\n[%s] thread[%x,%x] enter / child <%s> / parent <%s> / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, child_name, parent_name, cycle );
+#endif
+
+    // get new directory cluster and local pointer
+    child_cxy  = GET_CXY( child_xp );
+    child_ptr  = GET_PTR( child_xp );
+
+    // get parent directory cluster and local pointer
+    parent_cxy = GET_CXY( parent_xp );
+    parent_ptr = GET_PTR( parent_xp );
+
+    // get child inode FS type
+    ctx_ptr    = hal_remote_lpt( XPTR( child_cxy , &child_ptr->ctx ) );
+    fs_type    = hal_remote_l32( XPTR( child_cxy , &ctx_ptr->type ) );
+
+    //////////////////////////// create <.> 
+    if( child_cxy == local_cxy )     
+    {
+        error = vfs_dentry_create( fs_type,
+                                   ".",
+                                   &dentry_xp );
+    }
+    else
+    {
+        rpc_vfs_dentry_create_client( child_cxy,
+                                      fs_type,
+                                      ".",
+                                      &dentry_xp,
+                                      &error );
+    }
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot create dentry <.> in cluster %x\n",
+        __FUNCTION__ , child_cxy );
+        return -1;
+    }
+
+    // get <.> dentry local pointer
+    dentry_ptr = GET_PTR( dentry_xp );
+
+#if(DEBUG_VFS_ADD_SPECIAL & 1)
+if( DEBUG_VFS_ADD_SPECIAL < cycle )
+printk("\n[%s] thread[%x,%x] created dentry <.> (%x,%x)\n",
+__FUNCTION__, this->process->pid, this->trdid, child_cxy, dentry_ptr );
+#endif
+
+    // register <.> dentry in child inode xhtab of children
+    children_xhtab_xp = XPTR( child_cxy , &child_ptr->children );
+    children_entry_xp = XPTR( child_cxy , &dentry_ptr->children );
+    error = xhtab_insert( children_xhtab_xp , "." , children_entry_xp );
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot register dentry <.> in xhtab\n",
+        __FUNCTION__ );
+        return -1;
+    }
+
+    // register <.> dentry in child_inode xlist of parents TODO faut-il ?
+    parents_root_xp  = XPTR( child_cxy , &child_ptr->parents );
+    parents_entry_xp = XPTR( child_cxy , &dentry_ptr->parents );
+    xlist_add_first( parents_root_xp , parents_entry_xp );
+    hal_remote_atomic_add( XPTR( child_cxy , &child_ptr->links ) , 1 );
+
+    // update "parent" and "child_xp" fields in <.> dentry
+    hal_remote_s64( XPTR( child_cxy , &dentry_ptr->child_xp ) , child_xp );
+    hal_remote_spt( XPTR( child_cxy , &dentry_ptr->parent ) , child_ptr );
+
+#if(DEBUG_VFS_ADD_SPECIAL & 1)
+if( DEBUG_VFS_ADD_SPECIAL < cycle )
+printk("\n[%s] thread[%x,%x] linked dentry <.> to parent and child inodes\n", 
+__FUNCTION__, this->process->pid, this->trdid ); 
+#endif
+
+    // introduce <.> dentry into child directory mapper
+    if( child_cxy == local_cxy )
+    { 
+        error = vfs_fs_add_dentry( child_ptr,
+                                   dentry_ptr );
+    }
+    else
+    {
+        rpc_vfs_fs_add_dentry_client( child_cxy,
+                                      child_ptr,
+                                      dentry_ptr,
+                                      &error );
+    }
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot introduce dentry <..> in mapper %x\n",
+        __FUNCTION__ );
+        return -1;
+    }
+
+#if(DEBUG_VFS_ADD_SPECIAL & 1)
+if( DEBUG_VFS_ADD_SPECIAL < cycle )
+printk("\n[%s] thread[%x,%x] registered dentry <.> in child mapper\n", 
+__FUNCTION__, this->process->pid, this->trdid ); 
+#endif
+
+    ///////////////////////////// create <..> dentry 
+    if( child_cxy == local_cxy )     
+    {
+        error = vfs_dentry_create( fs_type,
+                                   "..",
+                                   &dentry_xp );
+    }
+    else
+    {
+        rpc_vfs_dentry_create_client( child_cxy,
+                                      fs_type,
+                                      "..",
+                                      &dentry_xp,
+                                      &error );
+    }
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot create dentry <..> in cluster %x\n",
+        __FUNCTION__ , child_cxy );
+        return -1;
+    }
+
+    // get <..> dentry local pointer
+    dentry_ptr = GET_PTR( dentry_xp );
+
+#if(DEBUG_VFS_ADD_SPECIAL & 1)
+if( DEBUG_VFS_ADD_SPECIAL < cycle )
+printk("\n[%s] thread[%x,%x] created dentry <..> (%x,%x)\n",
+__FUNCTION__, this->process->pid, this->trdid, child_cxy, dentry_ptr );
+#endif
+
+    // register <..> dentry in child_inode xhtab of children
+    children_xhtab_xp = XPTR( child_cxy , &child_ptr->children );
+    children_entry_xp = XPTR( child_cxy , &dentry_ptr->children );
+    error = xhtab_insert( children_xhtab_xp , ".." , children_entry_xp );
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot register dentry <..> in xhtab\n",
+        __FUNCTION__ );
+        return -1;
+    }
+
+    // register <..> dentry in parent_inode xlist of parents TODO faut-il ?
+    parents_root_xp  = XPTR( parent_cxy , &parent_ptr->parents );
+    parents_entry_xp = XPTR( child_cxy  , &dentry_ptr->parents );
+    xlist_add_first( parents_root_xp , parents_entry_xp );
+    hal_remote_atomic_add( XPTR( parent_cxy , &parent_ptr->links ) , 1 );
+
+    // update "parent" and "child_xp" fields in <..> dentry
+    hal_remote_s64( XPTR( child_cxy , &dentry_ptr->child_xp ) , parent_xp );
+    hal_remote_spt( XPTR( child_cxy , &dentry_ptr->parent ) , child_ptr );
+
+#if(DEBUG_VFS_ADD_SPECIAL & 1)
+if( DEBUG_VFS_ADD_SPECIAL < cycle )
+printk("\n[%s] thread[%x,%x] linked dentry <..> to parent and child inodes\n", 
+__FUNCTION__, this->process->pid, this->trdid ); 
+#endif
+
+    // introduce <..> dentry into child directory mapper
+    if( child_cxy == local_cxy )
+    { 
+        error = vfs_fs_add_dentry( child_ptr,
+                                   dentry_ptr );
+    }
+    else
+    {
+        rpc_vfs_fs_add_dentry_client( child_cxy,
+                                      child_ptr,
+                                      dentry_ptr,
+                                      &error );
+    }
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot introduce dentry <..> in mapper %x\n",
+        __FUNCTION__ );
+        return -1;
+    }
+
+#if(DEBUG_VFS_ADD_SPECIAL & 1)
+if( DEBUG_VFS_ADD_SPECIAL < cycle )
+printk("\n[%s] thread[%x,%x] registered dentry <..> in child mapper\n", 
+__FUNCTION__, this->process->pid, this->trdid ); 
+#endif
+
+#if DEBUG_VFS_ADD_SPECIAL
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_VFS_ADD_SPECIAL < cycle )
+printk("\n[%s] thread[%x,%x] exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, (uint32_t)hal_get_cycles() );
+#endif
+
+    return 0;
+
+}  // end vfs_add_special_dentries()
 
 //////////////////////////////////////////
@@ -2845 +3083 @@
 
 #if(DEBUG_VFS_ADD_CHILD & 1)
-if( local_cxy == 1 )
-// if( DEBUG_VFS_ADD_CHILD < cycle )
+if( DEBUG_VFS_ADD_CHILD < cycle )
 printk("\n[%s] thread[%x,%x] / dentry (%x,%x) registered in child inode (%x,%x)\n",
 __FUNCTION__, this->process->pid, this->trdid, 
@@ -2852 +3089 @@
 #endif
 
-    // 4. register new_dentry in parent_inode xhtab of children
+    // register new_dentry in parent_inode xhtab of children
     children_xhtab_xp = XPTR( parent_cxy , &parent_inode_ptr->children );
     children_entry_xp = XPTR( parent_cxy , &new_dentry_ptr->children );
@@ -2864 +3101 @@
 #endif
 
-    // 5. update "parent" and "child_xp" fields in new_dentry
+    // update "parent" and "child_xp" fields in new_dentry
     hal_remote_s64( XPTR( parent_cxy , &new_dentry_ptr->child_xp ) , new_inode_xp );
     hal_remote_spt( XPTR( parent_cxy , &new_dentry_ptr->parent ) , parent_inode_ptr );

trunk/kernel/fs/vfs.h

@@ -45 +45 @@
 
 struct vfs_inode_s;
-struct vfs_dentry_t;
-struct vfs_ctx_t;
-struct vfs_file_ref_s;
+struct vfs_dentry_s;
+struct vfs_ctx_s;
 struct vfs_file_s;
-
-struct vfs_inode_op_s;
-struct vfs_dentry_op_s;
-struct vfs_file_op_s;
-struct vfs_ctx_op_s;
-
-struct vfs_lookup_cmd_s;
-struct vfs_lookup_rsp_s;
 
 struct mapper_s;
@@ -63 +54 @@
 struct vseg_s;
 struct page_s;
-
 
 /******************************************************************************************
@@ -133 +123 @@
  *****************************************************************************************/
 
-/* this enum define the VFS inode types values */
-/* WARNING : this enum must be kept consistent with macros in <shared_stat.h> file */
+/* this enum define the VFS inode types values                                           */
+/* WARNING : this enum must be kept consistent with macros in <shared_stat.h> file       */
+/*           and with types in <shared_dirent.h> file.                                   */
 
 typedef enum   
@@ -144 +135 @@
     INODE_TYPE_SOCK  =     4,           /*! POSIX socket                                 */
     INODE_TYPE_DEV   =     5,           /*! character device                             */
-    INODE_TYPE_SYML  =     6,           /*! symbolic link                                */
+    INODE_TYPE_BLK   =     6,           /*! block device                                 */
+    INODE_TYPE_SYML  =     7,           /*! symbolic link                                */
 }
 vfs_inode_type_t;
@@ -184 +176 @@
 #define VFS_ISUID          0x0004000
 #define VFS_ISGID          0x0002000
-define VFS_ISVTX           0x0001000
+#define VFS_ISVTX          0x0001000
 
 #define VFS_IRWXU      0x0000700
@@ -316 +308 @@
  * This function allocates memory from local cluster for an inode descriptor and the 
  * associated mapper. It initialise these descriptors from arguments values. 
- * If the client thread is not running in the cluster containing this inode,
- * it must use the rpc_vfs_inode_create_client() function.
+ * It must called by a local thread. Use the RPC_INODE_CREATE if client thread is remote.
  ******************************************************************************************
  * @ fs_type    : file system type.
@@ -407 +398 @@
 
 
+
 /******************************************************************************************
  *        These low-level functions access / modify a VFS dentry descriptor
@@ -414 +406 @@
  * This function allocates memory from local cluster for a dentry descriptor, 
  * initialises it from  arguments values, and returns the extended pointer on dentry.
- * If the client thread is not running in the target cluster for this inode,
- * it must use the rpc_dentry_create_client() function.
+ * It must called by a local thread. Use the RPC_DENTRY_CREATE if client thread is remote.
  ******************************************************************************************
  * @ fs_type    : file system type.
@@ -548 +539 @@
  * 
  * [Implementation]
- * As there are cross-references between the inode and the associated dentry, this
- * function implement a three steps scenario :
+ * As there are cross-references between inode and dentry, this function implements
+ * a three steps scenario :
  * 1) The dentry descriptor is created in the cluster containing the existing <parent_xp>
- *    inode, and is only partially initialized : "fs_type", "name", "parent_xp" fields.
+ *    inode, and partially initialized, using the RPC_VFS_CREATE DENTRY if required.
  * 2) The inode and its associated mapper are created in cluster identified by <child_cxy>,
- *    and initialised. The new inode and the parent inode can have different FS types.
- * 3) The "child_xp" field in dentry (pointing on the created inode) is updated,
- *    and the refcount is incremented for both the inode and the dentry.
+ *    and partially initialised, using the RPC_VFS_CREATE_INODE if required.
+ *    The new inode and the parent inode can have different FS types.
+ * 3) The pointers between the parent inode, the new dentry, and the child inode 
+ *    are updated, using remote accesses.
  ******************************************************************************************
  * @ child_inode_cxy  : [in]  target cluster for child inode.
@@ -612 +604 @@
 
 /******************************************************************************************
+ * This function is called by the vfs_mkdir() function to create the two special dentries
+ * <.> and <..> in a new directory identified by the <child_xp> argument. The parent
+ * directory inode is defined by the <parent_xp> argument.
+ * The two dentries are introduced in the Inode Tree. They are also introduced in the
+ * in the child directory mapper, and the IOC device is updated.
+ ******************************************************************************************
+ * @ child_xp    : extended pointer on new directory inode.
+ * @ parent_xp   : extended pointer on parent directory inode.
+ * @ return 0 if success / -1 if failure.
+ *****************************************************************************************/
+error_t vfs_add_special_dentries( xptr_t  child_xp,
+                                  xptr_t  parent_xp );
+
+/******************************************************************************************
  * This recursive function diplays a complete inode/dentry sub-tree.
  * Any inode can be selected as the sub-tree root.
- * TODO this function is not protected against a concurrent inode/dentry removal...
+ * WARNING : this function is not protected against a concurrent inode/dentry removal...
  ******************************************************************************************
  * @ inode_xp   : extended pointer on sub-tree root inode.
@@ -809 +815 @@
 
 /****************************************************************************************** 
- * This function returns, in the structure pointed by the <k_dirent> kernel pointer, 
- * various infos on the directory entry currently pointed by the <file_xp> file descriptor.
- * TODO not implemented yet...
- ******************************************************************************************
- * @ file_xp    : extended pointer on the file descriptor of the searched directory .
- * @ k_dirent   : local pointer on the dirent structure in kernel space.
- * @ returns 0 if success / -1 if error.
- *****************************************************************************************/
-error_t vfs_readdir( xptr_t          file_xp,
-                     struct dirent * k_dirent );
-
-/****************************************************************************************** 
  * This function  creates a new directory as defined by the <root_xp> & <path> arguments.
  * TODO not implemented yet...
@@ -880 +874 @@
  * The directory inode descriptor and the dentry descriptor are in the same cluster.
  * Depending on the file system type, it calls the proper, FS specific function.
- * It ulso pdates the dentry descriptor and/or the inode descriptor extensions
+ * It also updates the dentry descriptor and/or the inode descriptor extensions
  * as required by the specific file system type.
  * Finally, it synchronously updates the parent directory on IOC device.
  *
  * It must be executed by a thread running in the cluster containing the parent directory.
- * It can be the RPC_VFS_VS_ADD_DENTRY. This function does NOT take any lock.
+ * It can be the RPC_VFS_FS_ADD_DENTRY. This function does NOT take any lock.
  ******************************************************************************************
  * @ parent  : local pointer on parent (directory) inode.

trunk/kernel/kern/cluster.h

@@ -264 +264 @@
 /******************************************************************************************
  * This function returns a pointer on the local process descriptor from the PID.
- * It uses the RPC
- * to create a local process descriptor copy if it does not exist yet.
  ******************************************************************************************
  * @ pid     : searched process identifier.

trunk/kernel/kern/kernel_init.c

@@ -167 +167 @@
     "PROCESS_FDARRAY",       // 27
     "FATFS_FREE",            // 28
-
-    "PROCESS_THTBL",         // 29
-
-    "MAPPER_STATE",          // 30
-    "VFS_SIZE",              // 31
-    "VFS_FILE",              // 32
-    "VMM_VSL",               // 33
-    "VMM_GPT",               // 34
-    "VFS_MAIN",              // 35
+    "PROCESS_DIR",           // 29
+
+    "PROCESS_THTBL",         // 30
+
+    "MAPPER_STATE",          // 31
+    "VFS_SIZE",              // 32
+    "VFS_FILE",              // 33
+    "VMM_VSL",               // 34
+    "VMM_GPT",               // 35
+    "VFS_MAIN",              // 36
 };        
 

trunk/kernel/kern/process.c

@@ -274 +274 @@
     remote_queuelock_init( XPTR( local_cxy , &process->children_lock ), LOCK_PROCESS_CHILDREN );
 
-    // reset semaphore / mutex / barrier / condvar list roots 
+    // reset semaphore / mutex / barrier / condvar list roots and lock
     xlist_root_init( XPTR( local_cxy , &process->sem_root ) );
     xlist_root_init( XPTR( local_cxy , &process->mutex_root ) );
@@ -280 +280 @@
     xlist_root_init( XPTR( local_cxy , &process->condvar_root ) );
     remote_queuelock_init( XPTR( local_cxy , &process->sync_lock ), LOCK_PROCESS_USERSYNC );
+
+    // reset open directories root and lock 
+    xlist_root_init( XPTR( local_cxy , &process->dir_root ) );
+    remote_queuelock_init( XPTR( local_cxy , &process->dir_lock ), LOCK_PROCESS_DIR );
 
     // register new process in the local cluster manager pref_tbl[]
@@ -546 +550 @@
     thread_block( client_xp , THREAD_BLOCKED_RPC );
 
-    // take the lock protecting process copies
-    remote_queuelock_acquire( lock_xp );
-
     // initialize shared RPC descriptor
     rpc.responses = 0;
@@ -555 +556 @@
     rpc.thread    = client;
     rpc.lid       = client->core->lid;
-    rpc.args[0]   = type;
-    rpc.args[1]   = pid;
+    rpc.args[0]   = pid;
+    rpc.args[1]   = type;
+
+    // take the lock protecting process copies
+    remote_queuelock_acquire( lock_xp );
 
     // scan list of process copies
-    // to send RPCs to remote copies
     XLIST_FOREACH( root_xp , iter_xp )
     {

trunk/kernel/kern/process.h

@@ -60 +60 @@
  ********************************************************************************************/
 
-typedef enum process_sigactions
+typedef enum 
 {
     BLOCK_ALL_THREADS    = 0x11,
     UNBLOCK_ALL_THREADS  = 0x22,
     DELETE_ALL_THREADS   = 0x33, 
-} process_sigactions_t;
+} 
+process_sigactions_t;
 
 /*********************************************************************************************
@@ -145 +146 @@
 
         struct thread_s  * th_tbl[CONFIG_THREADS_MAX_PER_CLUSTER];       /*! local threads       */
+
         uint32_t           th_nr;            /*! number of threads in this cluster               */
     rwlock_t           th_lock;          /*! lock protecting th_tbl[]  i                     */ 
 
-    xlist_entry_t      sem_root;         /*! root of the user definedsemaphore list          */
+    xlist_entry_t      sem_root;         /*! root of the user defined semaphore list         */
     xlist_entry_t      mutex_root;       /*! root of the user defined mutex list             */
     xlist_entry_t      barrier_root;     /*! root of the user defined barrier list           */
     xlist_entry_t      condvar_root;     /*! root of the user defined condvar list           */
     remote_queuelock_t sync_lock;        /*! lock protecting user defined synchro lists      */
+
+    xlist_entry_t      dir_root;         /*! root of the user defined DIR list               */
+    remote_queuelock_t dir_lock;         /*! lock protexting user defined DIR list           */
 
     uint32_t           term_state;       /*! termination status (flags & exit status)        */

trunk/kernel/kern/rpc.c

@@ -77 +77 @@
     &rpc_undefined,                        // 24   unused slot
     &rpc_mapper_handle_miss_server,        // 25
-    &rpc_undefined,                        // 26   unused slot
+    &rpc_vmm_delete_vseg_server,           // 26 
     &rpc_vmm_create_vseg_server,           // 27
     &rpc_vmm_set_cow_server,               // 28
@@ -113 +113 @@
     "undefined",                 // 24
     "MAPPER_HANDLE_MISS",        // 25
-    "undefined",                 // 26
+    "VMM_DELETE_VSEG",           // 26
     "VMM_CREATE_VSEG",           // 27
     "VMM_SET_COW",               // 28
@@ -283 +283 @@
     bool_t          blocking;           // blocking RPC when true
         remote_fifo_t * rpc_fifo;           // local pointer on RPC fifo
+    uint32_t        count;              // current number of expected responses
  
     // makes RPC thread not preemptable
@@ -302 +303 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_SERVER_GENERIC < cycle ) 
-printk("\n[%s] RPC thread %x on core[%d] takes RPC_FIFO ownership / cycle %d\n",
-__FUNCTION__, server_ptr->trdid, server_core_lid, cycle );
+printk("\n[%s] RPC thread[%x,%x] on core[%d] takes RPC_FIFO ownership / cycle %d\n",
+__FUNCTION__, server_ptr->process->pid, server_ptr->trdid, server_core_lid, cycle );
 #endif
                 // try to consume one RPC request  
@@ -326 +327 @@
 uint32_t items = remote_fifo_items( XPTR( local_cxy , rpc_fifo ) );
 if( DEBUG_RPC_SERVER_GENERIC < cycle ) 
-printk("\n[%s] RPC thread %x got rpc %s / client_cxy %x / items %d / cycle %d\n",
-__FUNCTION__, server_ptr->trdid, rpc_str[index], desc_cxy, items, cycle );
+printk("\n[%s] RPC thread[%x,%x] got rpc %s / client_cxy %x / items %d / cycle %d\n",
+__FUNCTION__, server_ptr->process->pid, server_ptr->trdid, rpc_str[index], desc_cxy, items, cycle );
 #endif
                 // register client thread in RPC thread descriptor
@@ -338 +339 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_SERVER_GENERIC < cycle ) 
-printk("\n[%s] RPC thread %x completes rpc %s / client_cxy %x / cycle %d\n",
-__FUNCTION__, server_ptr->trdid, rpc_str[index], desc_cxy, cycle );
-#endif
-                // decrement response counter in RPC descriptor if blocking RPC
-                if( blocking )
+printk("\n[%s] RPC thread[%x,%x] completes rpc %s / client_cxy %x / cycle %d\n",
+__FUNCTION__, server_ptr->process->pid, server_ptr->trdid, rpc_str[index], desc_cxy, cycle );
+#endif
+                // decrement expected responses counter in RPC descriptor
+                count = hal_remote_atomic_add( XPTR( desc_cxy, &desc_ptr->responses ), -1 );
+
+                // decrement response counter in RPC descriptor if last response
+                if( count == 1 ) 
                 {
-                    // decrement responses counter in RPC descriptor
-                    hal_remote_atomic_add( XPTR( desc_cxy, &desc_ptr->responses ), -1 );
-
                     // get client thread pointer and client core lid from RPC descriptor
                     client_ptr      = hal_remote_lpt( XPTR( desc_cxy , &desc_ptr->thread ) );
@@ -359 +360 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_SERVER_GENERIC < cycle ) 
-printk("\n[%s] RPC thread %x unblocked client thread %x / cycle %d\n",
-__FUNCTION__, server_ptr->trdid, client_ptr->trdid, cycle );
+printk("\n[%s] RPC thread[%x,%x] unblocked client thread[%x,%x] / cycle %d\n",
+__FUNCTION__, server_ptr->process->pid, server_ptr->trdid,
+client_ptr->process->pid, client_ptr->trdid, cycle );
 #endif
                     // send IPI to client core
                     dev_pic_send_ipi( desc_cxy , client_core_lid );
-
-                }  // end if blocking RPC
+                }
             }  // end RPC handling if fifo non empty
         }  // end if RPC_fIFO ownership successfully taken and released
@@ -376 +377 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_SERVER_GENERIC < cycle ) 
-printk("\n[%s] RPC thread %x suicides / cycle %d\n",
-__FUNCTION__, server_ptr->trdid, cycle );
+printk("\n[%s] RPC thread[%x,%x] suicides / cycle %d\n",
+__FUNCTION__, server_ptr->process->pid, server_ptr->trdid, cycle );
 #endif
             // update RPC threads counter
@@ -395 +396 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_SERVER_GENERIC < cycle ) 
-printk("\n[%s] RPC thread %x block IDLE & deschedules / cycle %d\n",
-__FUNCTION__, server_ptr->trdid, cycle );
+printk("\n[%s] RPC thread[%x,%x] block IDLE & deschedules / cycle %d\n",
+__FUNCTION__, server_ptr->process->pid, server_ptr->trdid, cycle );
 #endif
             // RPC thread blocks on IDLE 
@@ -425 +426 @@
 #endif
 
-    assert( (cxy != local_cxy) , "target cluster is not remote\n");
+    assert( (cxy != local_cxy) , "server cluster is not remote\n");
 
     // initialise RPC descriptor header 
@@ -498 +499 @@
 #endif
 
-    assert( (cxy != local_cxy) , "target cluster is not remote\n");
+    assert( (cxy != local_cxy) , "server cluster is not remote\n");
 
     // initialise RPC descriptor header 
@@ -576 +577 @@
 #endif
 
-    assert( (cxy != local_cxy) , "target cluster is not remote\n");
+    assert( (cxy != local_cxy) , "server cluster is not remote\n");
 
     // initialise RPC descriptor header 
@@ -677 +678 @@
 #endif
 
-    assert( (cxy != local_cxy) , "target cluster is not remote\n");
+    assert( (cxy != local_cxy) , "server cluster is not remote\n");
 
     // initialise RPC descriptor header 
@@ -784 +785 @@
 #endif
 
-    assert( (cxy != local_cxy) , "target cluster is not remote\n");
+    assert( (cxy != local_cxy) , "server cluster is not remote\n");
 
     // initialise RPC descriptor header 
@@ -862 +863 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [9] Marshaling functions attached to RPC_PROCESS_SIGACTION (multicast / non blocking)
+// [9]   Marshaling functions attached to RPC_PROCESS_SIGACTION (non blocking)
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -869 +870 @@
                                    rpc_desc_t * rpc )
 {
-
 #if DEBUG_RPC_PROCESS_SIGACTION
-uint32_t  cycle  = (uint32_t)hal_get_cycles();
-uint32_t  action = rpc->args[0];
-pid_t     pid    = rpc->args[1];
+uint32_t  cycle = (uint32_t)hal_get_cycles();
 thread_t * this = CURRENT_THREAD;
 if( DEBUG_RPC_PROCESS_SIGACTION < cycle )
-printk("\n[%s] thread[%x,%x] enter to request %s of process %x in cluster %x / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, process_action_str(action), pid, cxy, cycle );
-#endif
-
-    // check some RPC arguments
-    assert( (rpc->blocking == false) , "must be non-blocking\n");
-    assert( (rpc->index == RPC_PROCESS_SIGACTION ) , "bad RPC index\n" );
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
+#endif
+
+// check RPC "index" and "blocking" arguments
+assert( (rpc->blocking == false) , "must be non-blocking\n");
+assert( (rpc->index == RPC_PROCESS_SIGACTION ) , "bad RPC index\n" );
 
     // register RPC request in remote RPC fifo and return
@@ -890 +888 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_PROCESS_SIGACTION < cycle )
-printk("\n[%s] thread[%x,%x] requested %s of process %x in cluster %x / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, process_action_str(action), pid, cxy, cycle );
-#endif
-
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
+#endif
 }  // end rpc_process_sigaction_client() 
 
@@ -899 +896 @@
 void rpc_process_sigaction_server( xptr_t xp )
 {
-    pid_t        pid;             // target process identifier
-    process_t  * process;         // pointer on local target process descriptor
-    uint32_t     action;          // sigaction index
-    thread_t   * client_ptr;      // pointer on client thread in client cluster
-    xptr_t       client_xp;       // extended pointer client thread
-    cxy_t        client_cxy;      // client cluster identifier
-    rpc_desc_t * rpc;             // pointer on rpc descriptor in client cluster
-    xptr_t       count_xp;        // extended pointer on responses counter
-    uint32_t     count_value;     // responses counter value
-    lid_t        client_lid;      // client core local index
+#if DEBUG_RPC_PROCESS_SIGACTION
+uint32_t cycle = (uint32_t)hal_get_cycles();
+thread_t * this = CURRENT_THREAD;
+if( DEBUG_RPC_PROCESS_SIGACTION < cycle )
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
+#endif
 
     // get client cluster identifier and pointer on RPC descriptor
-    client_cxy = GET_CXY( xp );
-    rpc        = GET_PTR( xp );
+    cxy_t        client_cxy = GET_CXY( xp );
+    rpc_desc_t * desc       = GET_PTR( xp );
 
     // get arguments from RPC descriptor
-    action   = (uint32_t)hal_remote_l64( XPTR(client_cxy , &rpc->args[0]) );
-    pid      = (pid_t)   hal_remote_l64( XPTR(client_cxy , &rpc->args[1]) );
-
-#if DEBUG_RPC_PROCESS_SIGACTION
-uint32_t cycle = (uint32_t)hal_get_cycles();
-thread_t * this = CURRENT_THREAD;
-if( DEBUG_RPC_PROCESS_SIGACTION < cycle )
-printk("\n[%s] thread[%x,%x] enter to %s process %x in cluster %x / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid,
-process_action_str( action ), pid, local_cxy, cycle );
-#endif
+    pid_t    pid    = (pid_t)   hal_remote_l64( XPTR(client_cxy , &desc->args[0]) );
+    uint32_t action = (uint32_t)hal_remote_l64( XPTR(client_cxy , &desc->args[1]) );
 
     // get client thread pointers
-    client_ptr = (thread_t *)hal_remote_lpt( XPTR( client_cxy , &rpc->thread ) );
-    client_xp  = XPTR( client_cxy , client_ptr );
+    thread_t * client_ptr = hal_remote_lpt( XPTR( client_cxy , &desc->thread ) );
+    xptr_t     client_xp  = XPTR( client_cxy , client_ptr );
 
     // get local process descriptor
-    process = cluster_get_local_process_from_pid( pid );
+    process_t * process = cluster_get_local_process_from_pid( pid );
 
     // call relevant kernel function
@@ -939 +924 @@
     else if ( action == UNBLOCK_ALL_THREADS ) process_unblock_threads( process );
 
-    // build extended pointer on response counter in RPC
-    count_xp = XPTR( client_cxy , &rpc->responses );
-
-    // decrement the responses counter in RPC descriptor,
-    count_value = hal_remote_atomic_add( count_xp , -1 );
-
-    // unblock the client thread only if it is the last response.
-    if( count_value == 1 )
-    {
-        // get client core lid
-        client_lid    = (lid_t)     hal_remote_l32 ( XPTR( client_cxy , &rpc->lid    ) );
-
-        // unblock client thread
-        thread_unblock( client_xp , THREAD_BLOCKED_RPC );
-
-        // send an IPI to client core
-        // dev_pic_send_ipi( client_cxy , client_lid );
-    }
-
 #if DEBUG_RPC_PROCESS_SIGACTION
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_PROCESS_SIGACTION < cycle )
-printk("\n[%s] thread[%x,%x] exit after %s process %x in cluster %x / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid,
-process_action_str( action ), pid, local_cxy, cycle );
-#endif
-
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
+#endif
 } // end rpc_process_sigaction_server() 
 
@@ -991 +955 @@
 #endif
 
-    assert( (cxy != local_cxy) , "target cluster is not remote\n");
+    assert( (cxy != local_cxy) , "server cluster is not remote\n");
 
     // initialise RPC descriptor header 
@@ -1091 +1055 @@
 #endif
 
-    assert( (cxy != local_cxy) , "target cluster is not remote\n");
+    assert( (cxy != local_cxy) , "server cluster is not remote\n");
 
     // initialise RPC descriptor header 
@@ -1163 +1127 @@
 #endif
 
-    assert( (cxy != local_cxy) , "target cluster is not remote\n");
+    assert( (cxy != local_cxy) , "server cluster is not remote\n");
 
     // initialise RPC descriptor header 
@@ -1251 +1215 @@
 #endif
 
-    assert( (cxy != local_cxy) , "target cluster is not remote\n");
+    assert( (cxy != local_cxy) , "server cluster is not remote\n");
 
     // initialise RPC descriptor header 
@@ -1324 +1288 @@
 #endif
 
-    assert( (cxy != local_cxy) , "target cluster is not remote\n");
+    assert( (cxy != local_cxy) , "server cluster is not remote\n");
 
     // initialise RPC descriptor header 
@@ -1408 +1372 @@
 #endif
 
-    assert( (cxy != local_cxy) , "target cluster is not remote\n");
+    assert( (cxy != local_cxy) , "server cluster is not remote\n");
 
     // initialise RPC descriptor header 
@@ -1480 +1444 @@
 #endif
 
-    assert( (cxy != local_cxy) , "target cluster is not remote\n");
+    assert( (cxy != local_cxy) , "server cluster is not remote\n");
 
     // initialise RPC descriptor header 
@@ -1569 +1533 @@
 #endif
 
-    assert( (cxy != local_cxy) , "target cluster is not remote\n");
+    assert( (cxy != local_cxy) , "server cluster is not remote\n");
 
     // initialise RPC descriptor header 
@@ -1649 +1613 @@
 #endif
 
-    assert( (cxy != local_cxy) , "target cluster is not remote\n");
+    assert( (cxy != local_cxy) , "server cluster is not remote\n");
 
     // initialise RPC descriptor header 
@@ -1729 +1693 @@
 #endif
 
-    assert( (cxy != local_cxy) , "target cluster is not remote\n");
+    assert( (cxy != local_cxy) , "server cluster is not remote\n");
 
     // initialise RPC descriptor header 
@@ -1808 +1772 @@
 #endif
 
-    assert( (cxy != local_cxy) , "target cluster is not remote\n");
+    assert( (cxy != local_cxy) , "server cluster is not remote\n");
 
     // initialise RPC descriptor header 
@@ -1896 +1860 @@
 #endif
 
-    assert( (cxy != local_cxy) , "target cluster is not remote\n");
+    assert( (cxy != local_cxy) , "server cluster is not remote\n");
 
     // initialise RPC descriptor header 
@@ -1975 +1939 @@
 #endif
 
-    assert( (cxy != local_cxy) , "target cluster is not remote\n");
+    assert( (cxy != local_cxy) , "server cluster is not remote\n");
 
     // initialise RPC descriptor header 
@@ -2053 +2017 @@
 #endif
 
-    assert( (cxy != local_cxy) , "target cluster is not remote\n");
+    assert( (cxy != local_cxy) , "server cluster is not remote\n");
 
     // initialise RPC descriptor header 
@@ -2125 +2089 @@
 {
 #if DEBUG_RPC_MAPPER_HANDLE_MISS
+thread_t * this = CURRENT_THREAD;
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_MAPPER_HANDLE_MISS )
@@ -2131 +2096 @@
 #endif
 
-    assert( (cxy != local_cxy) , "target cluster is not remote\n");
+    assert( (cxy != local_cxy) , "server cluster is not remote\n");
 
     // initialise RPC descriptor header 
@@ -2162 +2127 @@
 {
 #if DEBUG_RPC_MAPPER_HANDLE_MISS
+thread_t * this = CURRENT_THREAD;
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_MAPPER_HANDLE_MISS )
@@ -2199 +2165 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [26]         undefined slot
-/////////////////////////////////////////////////////////////////////////////////////////
+// [26]  Marshaling functions attached to RPC_VMM_DELETE_VSEG (parallel / non blocking)
+/////////////////////////////////////////////////////////////////////////////////////////
+
+//////////////////////////////////////////////////
+void rpc_vmm_delete_vseg_client( cxy_t        cxy,
+                                 rpc_desc_t * rpc )
+{
+#if DEBUG_RPC_VMM_DELETE_VSEG
+thread_t * this  = CURRENT_THREAD;
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VMM_DELETE_VSEG )
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
+#endif
+
+// check RPC "index" and "blocking" arguments
+assert( (rpc->blocking == false) , "must be non-blocking\n");
+assert( (rpc->index == RPC_VMM_DELETE_VSEG ) , "bad RPC index\n" );
+
+    // register RPC request in remote RPC fifo
+    rpc_send( cxy , rpc );
+
+#if DEBUG_RPC_VMM_DELETE_VSEG
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VMM_DELETE_VSEG )
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
+#endif
+}
+
+////////////////////////////////////////////
+void rpc_vmm_delete_vseg_server( xptr_t xp )
+{
+#if DEBUG_RPC_VMM_DELETE_VSEG
+uint32_t cycle = (uint32_t)hal_get_cycles();
+thread_t * this = CURRENT_THREAD;
+if( DEBUG_RPC_VMM_DELETE_VSEG < cycle )
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
+#endif
+
+    // get client cluster identifier and pointer on RPC descriptor
+    cxy_t        client_cxy = GET_CXY( xp );
+    rpc_desc_t * desc       = GET_PTR( xp );
+
+    // get arguments from RPC descriptor
+    pid_t    pid   = (pid_t)   hal_remote_l64( XPTR(client_cxy , &desc->args[0]) );
+    intptr_t vaddr = (intptr_t)hal_remote_l64( XPTR(client_cxy , &desc->args[1]) );
+
+    // call relevant kernel function
+    vmm_delete_vseg( pid , vaddr );
+
+#if DEBUG_RPC_VMM_DELETE_VSEG
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_RPC_VMM_DELETE_VSEG < cycle )
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
+#endif
+} 
 
 /////////////////////////////////////////////////////////////////////////////////////////
@@ -2218 +2241 @@
                                  struct vseg_s   ** vseg )
 {
-    assert( (cxy != local_cxy) , "target cluster is not remote\n");
+#if DEBUG_RPC_VMM_CREATE_VSEG
+thread_t * this = CURRENT_THREAD;
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VMM_CREATE_VSEG )
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+
+    assert( (cxy != local_cxy) , "server cluster is not remote\n");
 
     // initialise RPC descriptor header 
@@ -2242 +2273 @@
     *vseg = (vseg_t *)(intptr_t)rpc.args[8];
 
+#if DEBUG_RPC_VMM_CREATE_VSEG
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VMM_CREATE_VSEG )
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
 }
 
@@ -2247 +2284 @@
 void rpc_vmm_create_vseg_server( xptr_t xp )
 {
+#if DEBUG_RPC_VMM_CREATE_VSEG
+thread_t * this = CURRENT_THREAD;
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VMM_CREATE_VSEG )
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+
     // get client cluster identifier and pointer on RPC descriptor
     cxy_t        cxy  = GET_CXY( xp );
@@ -2274 +2319 @@
     hal_remote_s64( XPTR( cxy , &desc->args[8] ) , (uint64_t)(intptr_t)vseg );
 
+#if DEBUG_RPC_VMM_CREATE_VSEG
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VMM_CREATE_VSEG )
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
 }
 
@@ -2284 +2335 @@
                              process_t * process )
 {
-    assert( (cxy != local_cxy) , "target cluster is not remote\n");
+    assert( (cxy != local_cxy) , "server cluster is not remote\n");
 
     // initialise RPC descriptor header 
@@ -2326 +2377 @@
                              bool_t      detailed )
 {
-    assert( (cxy != local_cxy) , "target cluster is not remote\n");
+    assert( (cxy != local_cxy) , "server cluster is not remote\n");
 
     // initialise RPC descriptor header 

trunk/kernel/kern/rpc.h

@@ -54 +54 @@
 /***********************************************************************************
  * This enum defines all RPC indexes.
- * It must be consistent with the rpc_server[] array defined in in the rpc.c file.
+ * It must be consistent with the rpc_server[] arrays defined in in the rpc.c file.
  **********************************************************************************/
 
@@ -68 +68 @@
     RPC_THREAD_KERNEL_CREATE      = 7,
     RPC_UNDEFINED_8               = 8,
-    RPC_PROCESS_SIGACTION         = 9,
+    RPC_PROCESS_SIGACTION         = 9,       // non blocking
 
     RPC_VFS_INODE_CREATE          = 10,
@@ -87 +87 @@
     RPC_UNDEFINED_24              = 24,
     RPC_MAPPER_HANDLE_MISS        = 25,
-    RPC_UNDEFINED_26              = 26,
+    RPC_VMM_DELETE_VSEG           = 26,      // non blocking
     RPC_VMM_CREATE_VSEG           = 27,
     RPC_VMM_SET_COW               = 28,
@@ -281 +281 @@
 
 /***********************************************************************************
- * [9] The RPC_PROCESS_SIGACTION allows a thread running in any cluster 
- * to request a cluster identified by the <cxy> argument (local or remote)
- * to execute a given sigaction for a given cluster. The <action_type> and 
- * the <pid> arguments are defined in the shared RPC descriptor, that must be 
- * initialised by the client thread.
+ * [9] The non blocking RPC_PROCESS_SIGACTION allows any client thread running in
+ * any cluster to send parallel RPC requests to one or several servers (that can be 
+ * local or remote), to execute a given sigaction, defined by the <action_type>
+ * argument[1], for a given process identified by the <pid> argument[0].
  *
- * WARNING : It is implemented as a NON BLOCKING multicast RPC, that can be sent 
- * in parallel to all process copies. The various RPC server threads atomically
- * decrement the <response> field in the shared RPC descriptor.
- * The last server thread unblock the client thread that blocked (after sending 
- * all RPC requests) in the process_sigaction() function.
+ * WARNING : It is implemented as a NON BLOCKING RPC, that can be sent in parallel
+ * to several servers. The RPC descriptor, containing the <action_type> and <pid>
+ * arguments, as well as the RPC <index>, <blocked>, and <response> fields, must
+ * be allocated and initialised by the calling function itself.
+ * Each RPC server thread atomically decrements the <response> field in this 
+ * shared RPC descriptor. The last server thread unblock the client thread,
+ * that blocked only after sending all parallel RPC requests to all servers.
  ***********************************************************************************
  * @ cxy     : server cluster identifier.
- * @ rpc     : pointer on ishared RPC descriptor initialized by the client thread.
+ * @ rpc     : pointer on shared RPC descriptor initialized by the client thread.
  **********************************************************************************/
 void rpc_process_sigaction_client( cxy_t               cxy,
@@ -550 +551 @@
  * On the server side, this RPC call the mapper_handle_miss() function and return
  * an extended pointer on the allocated page descriptor and an error status.
+ ***********************************************************************************
  * @ cxy         : server cluster identifier.
  * @ mapper      : [in]  local pointer on mapper.
@@ -566 +568 @@
 
 /***********************************************************************************
- * [26] undefined slot
- **********************************************************************************/
+ * [26] The non blocking RPC_VMM_DELETE_VSEG allows any client thread running in
+ * any cluster to send parallel RPC requests to one or several clusters (that can be 
+ * local or remote), to delete from a given VMM, identified by the <pid> argument[0]
+ * a given vseg, identified by the <vaddr> argument[1].
+ *
+ * WARNING : It is implemented as a NON BLOCKING RPC, that can be sent in parallel
+ * to several servers. The RPC descriptor, containing the <pid> and <vaddr> 
+ * arguments, as well as the RPC <index>, <blocked>, and <response> fields, must
+ * be allocated and initialised by the calling function itself.
+ * Each RPC server thread atomically decrements the the <response> field in this 
+ * shared RPC descriptor. The last server thread unblock the client thread,
+ * that blocked only after sending all paralle RPC requests to all servers.
+ ***********************************************************************************
+ * @ cxy         : server cluster identifier.
+ * @ rpc     : pointer on shared RPC descriptor initialized by the client thread.
+ **********************************************************************************/
+void rpc_vmm_delete_vseg_client( cxy_t               cxy,
+                                 struct rpc_desc_s * rpc );
+ 
+void rpc_vmm_delete_vseg_server( xptr_t xp );
 
 /***********************************************************************************

trunk/kernel/kern/thread.c

@@ -326 +326 @@
     {
             printk("\n[ERROR] in %s : cannot create new thread\n", __FUNCTION__ );
-        vmm_remove_vseg( vseg );
+        vmm_delete_vseg( process->pid , vseg->min );
         return ENOMEM;
     }
@@ -348 +348 @@
     {
             printk("\n[ERROR] in %s : cannot initialize new thread\n", __FUNCTION__ );
-        vmm_remove_vseg( vseg );
+        vmm_delete_vseg( process->pid , vseg->min );
         thread_release( thread );
         return EINVAL;
@@ -369 +369 @@
     {
             printk("\n[ERROR] in %s : cannot create CPU context\n", __FUNCTION__ );
-        vmm_remove_vseg( vseg );
+        vmm_delete_vseg( process->pid , vseg->min );
         thread_release( thread );
         return ENOMEM;
@@ -379 +379 @@
     {
             printk("\n[ERROR] in %s : cannot create FPU context\n", __FUNCTION__ );
-        vmm_remove_vseg( vseg );
+        vmm_delete_vseg( process->pid , vseg->min );
         thread_release( thread );
         return ENOMEM;
@@ -538 +538 @@
 
     // register STACK vseg in local child VSL
-    vmm_vseg_attach( &child_process->vmm , vseg );
+    vmm_attach_vseg_to_vsl( &child_process->vmm , vseg );
 
 #if (DEBUG_THREAD_USER_FORK & 1)
@@ -560 +560 @@
         if( error )
         {
-            vmm_vseg_detach( &child_process->vmm , vseg );
-            vseg_free( vseg );
+            vmm_detach_vseg_from_vsl( &child_process->vmm , vseg );
             thread_release( child_ptr );
             printk("\n[ERROR] in %s : cannot update child GPT\n", __FUNCTION__ );

trunk/kernel/kernel_config.h

@@ -128 +128 @@
 #define DEBUG_QUEUELOCK_TYPE              0    // lock type (0 is undefined)
 
+#define DEBUG_REMOTE_DIR                  0
+
 #define DEBUG_RPC_CLIENT_GENERIC          0
 #define DEBUG_RPC_SERVER_GENERIC          0
@@ -148 +150 @@
 #define DEBUG_RPC_VFS_FILE_DESTROY        0
 #define DEBUG_RPC_VFS_DEVICE_GET_DENTRY   0
+#define DEBUG_RPC_VMM_CREATE_VSEG         0
 #define DEBUG_RPC_VMM_GET_PTE             0
 #define DEBUG_RPC_VMM_GET_VSEG            0
+#define DEBUG_RPC_VMM_UNMAP_VSEG          0
 
 #define DEBUG_RWLOCK_TYPE                 0    // lock type (0 is undefined) 
@@ -163 +167 @@
 #define DEBUG_SYS_BARRIER                 0
 #define DEBUG_SYS_CLOSE                   0
+#define DEBUG_SYS_CLOSEDIR                0
 #define DEBUG_SYS_CONDVAR                 0
 #define DEBUG_SYS_DISPLAY                 0
@@ -176 +181 @@
 #define DEBUG_SYS_KILL                    0
 #define DEBUG_SYS_OPEN                    0
-#define DEBUG_SYS_MKDIR                   2
+#define DEBUG_SYS_OPENDIR                 0
+#define DEBUG_SYS_MKDIR                   0
 #define DEBUG_SYS_MMAP                    0
 #define DEBUG_SYS_MUNMAP                  0
 #define DEBUG_SYS_MUTEX                   0
 #define DEBUG_SYS_READ                    0
+#define DEBUG_SYS_READDIR                 0
 #define DEBUG_SYS_SEM                     0
 #define DEBUG_SYS_STAT                    0
@@ -207 +214 @@
 
 #define DEBUG_VFS_ADD_CHILD               0
+#define DEBUG_VFS_ADD_SPECIAL             1
+#define DEBUG_VFS_CHDIR                   0
 #define DEBUG_VFS_CLOSE                   0
-#define DEBUG_VFS_CHDIR                   0
 #define DEBUG_VFS_DENTRY_CREATE           0
 #define DEBUG_VFS_FILE_CREATE             0
@@ -215 +223 @@
 #define DEBUG_VFS_INODE_LOAD_ALL          0
 #define DEBUG_VFS_LINK                    0
-#define DEBUG_VFS_LOOKUP                  1
+#define DEBUG_VFS_LOOKUP                  0
 #define DEBUG_VFS_LSEEK                   0
-#define DEBUG_VFS_MKDIR                   1
+#define DEBUG_VFS_MKDIR                   0
 #define DEBUG_VFS_NEW_CHILD_INIT          0
 #define DEBUG_VFS_OPEN                    0
@@ -224 +232 @@
 
 #define DEBUG_VMM_CREATE_VSEG             0
+#define DEBUG_VMM_DELETE_VSEG             0
 #define DEBUG_VMM_DESTROY                 0
 #define DEBUG_VMM_FORK_COPY               0
@@ -233 +242 @@
 #define DEBUG_VMM_PAGE_ALLOCATE           0
 #define DEBUG_VMM_SET_COW                 0
-#define DEBUG_VMM_UNMAP_VSEG              0
 #define DEBUG_VMM_UPDATE_PTE              0
 
@@ -276 +284 @@
 #define LOCK_PROCESS_FDARRAY  27   // remote (Q)  protect array of open files in owner process 
 #define LOCK_FATFS_FREE       28   // remote (Q)  protect the FATFS context (free clusters)
-
-#define LOCK_PROCESS_THTBL    29   // local  (RW) protect local array of threads in a process 
-
-#define LOCK_MAPPER_STATE     30   // remote (RW) protect mapper state
-#define LOCK_VFS_SIZE         31   // remote (RW) protect inode state and associated mapper
-#define LOCK_VFS_FILE         32   // remote (RW) protect file descriptor state
-#define LOCK_VMM_VSL          33   // remote (RW) protect VSL (local list of vsegs)
-#define LOCK_VMM_GPT          34   // remote (RW) protect GPT (local page table)
-#define LOCK_VFS_MAIN         35   // remote (RW) protect vfs traversal (in root inode)
+#define LOCK_PROCESS_DIR      29   // remote (Q)  protect xlist of open directories in process
+
+#define LOCK_PROCESS_THTBL    30   // local  (RW) protect local array of threads in a process 
+
+#define LOCK_MAPPER_STATE     31   // remote (RW) protect mapper state
+#define LOCK_VFS_SIZE         32   // remote (RW) protect inode state and associated mapper
+#define LOCK_VFS_FILE         33   // remote (RW) protect file descriptor state
+#define LOCK_VMM_VSL          34   // remote (RW) protect VSL (local list of vsegs)
+#define LOCK_VMM_GPT          35   // remote (RW) protect GPT (local page table)
+#define LOCK_VFS_MAIN         36   // remote (RW) protect vfs traversal (in root inode)
 
 
@@ -338 +347 @@
 
 #define CONFIG_VFS_MAX_INODES               128        // max number of inodes per cluster
-#define CONFIG_VFS_MAX_NAME_LENGTH          32         // dentry name max length (bytes)
+#define CONFIG_VFS_MAX_NAME_LENGTH          56         // dentry name max length (bytes)
 #define CONFIG_VFS_MAX_PATH_LENGTH          256        // pathname max length (bytes)
 #define CONFIG_VFS_FREE_CLUSTERS_MIN        32         // min number of free clusters
-
+#define CONFIG_VFS_MAX_DENTRIES             63         // max number of dentries in one dir
 
 #define CONFIG_VFS_ROOT_IS_FATFS            1          // root FS is FATFS if non zero
@@ -397 +406 @@
 
 ////////////////////////////////////////////////////////////////////////////////////////////
-//                USER SPACE SEGMENTATION / all values are number of pages
+//                USER SPACE SEGMENTATION / all values are numbers of pages
 ////////////////////////////////////////////////////////////////////////////////////////////
 

trunk/kernel/libk/remote_mutex.c

@@ -137 +137 @@
 #if DEBUG_MUTEX
 thread_t * this = CURRENT_THREAD;
-if( (uint32_t)hal_get_cycles() > DEBUG_QUEUELOCK )
+if( (uint32_t)hal_get_cycles() > DEBUG_MUTEX )
 printk("\n[DBG] %s : thread %x in %x process / mutex(%x,%x)\n",
 __FUNCTION__, this->trdid, this->process->pid, local_cxy, mutex_ptr );

trunk/kernel/libk/remote_mutex.h

@@ -38 +38 @@
  * This user type is implemented as an unsigned long, but the value is not used by the 
  * kernel. ALMOS-MKH uses only the mutex virtual address as an identifier.
- * For each user mutex, ALMOS-MKH creates a kernel "remote_mutex_t" structure,
- * dynamically allocated in the reference cluster by the remote_mutex_create() function, 
- * and destroyed by the remote_mutex_destroy() function, using RPC if the calling thread
+ * For each user mutex, ALMOS-MKH creates a kernel "remote_mutex_t" structure, allocated
+ * in the user process reference cluster by the remote_mutex_create() function, and 
+ * destroyed by the remote_mutex_destroy() function, using RPC if the calling thread
  * is not running in the reference cluster. 
  *

trunk/kernel/libk/string.h

@@ -49 +49 @@
 /********************************************************************************************
  * This function compares lexicographically the strind s1 and s2.
- * characters are considered unsigned.
+ * Characters are considered unsigned.
  * I does not compare characters after the first NUL character.
  ********************************************************************************************
@@ -61 +61 @@
 /********************************************************************************************
  * This function compares lexicographically the strind s1 and s2.
- * I does not compare than <n> characters and stops after the first NUL character.
+ * I does not compare more than <n> characters and stops after the first NUL character.
  ********************************************************************************************
  * @ s1   : pointer on string.

trunk/kernel/libk/xhtab.h

@@ -32 +32 @@
 
 ///////////////////////////////////////////////////////////////////////////////////////////
-// This file define a generic, embedded, remotely accessible hash table.
+// This file define a generic, embedded, remotely accessible, hash table.
 //
 // It can be accessed by any thread, running in any cluster.
@@ -39 +39 @@
 // For this purpose the set of all registered items is split in several subsets.
 // Each subset is organised as an embedded double linked xlists.
-// - an item is uniquely identified by a <key>, that is a single uint32_t value. 
-// - From the <key> value, the hash table uses an item type specific xhtab_index() 
+// - an item is uniquely identified by a <key>, that is a item specific pointer,
+//   that can be a - for example - a char* defining the item "name".
+// - From the <key> value, the hash table uses an item type specific index_from_key() 
 //   function, to compute an <index> value, defining a subset of registered items.
 // - to discriminate between items that have the same <index>, the hash table makes
-//   an associative search on the key in subset.
+//   an associative search on the key in subset, using the item type specific
+//   item_match_key() function.
 // - Each registered item is a structure, that must contain an embedded xlist_entry,
 //   that is part of the xlist implementing the subset. 
 //
 // For all registered items, a total order is defined by the increasing index values, 
-// and for each index value, by the position in the partial xlist. 
+// and for each index value, by the position in the xlist implementing a subset. 
 // This order is used by the two functions xhtab_get_first() and xhtab_get_next(), that
 // are used to scan all registered items. The two "current_index" and "current_xlist_xp"

trunk/kernel/mm/kmem.c

@@ -40 +40 @@
 #include <fatfs.h>
 #include <ramfs.h>
+#include <remote_dir.h>
 #include <remote_sem.h>
 #include <remote_barrier.h>
@@ -100 +101 @@
     else if( type == KMEM_CONDVAR )       return sizeof( remote_condvar_t );
     else if( type == KMEM_MUTEX )         return sizeof( remote_mutex_t );
+    else if( type == KMEM_DIR )           return sizeof( remote_dir_t );
+
         else if( type == KMEM_512_BYTES )     return 512;
 
@@ -128 +131 @@
     else if( type == KMEM_CONDVAR )       return "KMEM_CONDVAR";
     else if( type == KMEM_MUTEX )         return "KMEM_MUTEX";
+    else if( type == KMEM_DIR )           return "KMEM_DIR";
+
         else if( type == KMEM_512_BYTES )     return "KMEM_512_BYTES";
 
@@ -144 +149 @@
 
 #if DEBUG_KMEM
+thread_t * this = CURRENT_THREAD;
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_KMEM < cycle )
-printk("\n[DBG] %s : thread %x enter / KCM type %s missing in cluster %x / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, kmem_type_str( type ), local_cxy, cycle );
+printk("\n[%s] thread[%x,%x] enter / KCM type %s missing in cluster %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, kmem_type_str( type ), local_cxy, cycle );
 #endif
 
@@ -174 +180 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_KMEM < cycle )
-printk("\n[DBG] %s : thread %x exit / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, cycle );
+printk("\n[%s] thread[%x,%x] exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, cycle );
 #endif
 
@@ -198 +204 @@
 
 #if DEBUG_KMEM
+thread_t * this = CURRENT_THREAD;
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_KMEM < cycle )
-printk("\n[DBG] %s : thread %x enter / type %s / cluster %x / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, kmem_type_str( type ), local_cxy, cycle );
+printk("\n[%s] thread [%x,%x] enter / %s / size %d / cluster %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, 
+kmem_type_str( type ), size, local_cxy, cycle );
 #endif
 
@@ -222 +230 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_KMEM < cycle )
-printk("\n[DBG] %s : thread %x exit / %d page(s) allocated / ppn %x / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, 1<<size, ppm_page2ppn(XPTR(local_cxy,ptr)), cycle );
+printk("\n[%s] thread[%x,%x] exit / %d page(s) allocated / ppn %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid,
+1<<size, ppm_page2ppn(XPTR(local_cxy,ptr)), cycle );
 #endif
 
@@ -244 +253 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_KMEM < cycle )
-printk("\n[DBG] %s : thread %x exit / type %s allocated / base %x / size %d / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, kmem_type_str( type ), (intptr_t)ptr, size, cycle );
+printk("\n[%s] thread[%x,%x] exit / type %s allocated / base %x / size %d / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, 
+kmem_type_str( type ), (intptr_t)ptr, size, cycle );
 #endif
 
@@ -286 +296 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_KMEM < cycle )
-printk("\n[DBG] %s : thread %x exit / type %s allocated / base %x / size %d / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, kmem_type_str(type), (intptr_t)ptr, 
+printk("\n[%s] thread [%x,%x] exit / type %s allocated / base %x / size %d / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, kmem_type_str(type), (intptr_t)ptr, 
 kmem_type_size(type), cycle );
 #endif

trunk/kernel/mm/kmem.h

@@ -36 +36 @@
 enum
 {
-  KMEM_PAGE             = 0,   /*! reserved for PPM allocator                       */
-  KMEM_GENERIC          = 1,   /*! reserved for KHM allocator                       */
-  KMEM_KCM              = 2,   /*! kcm_t                                            */
-  KMEM_VSEG             = 3,   /*! vseg_t                                           */
-  KMEM_DEVICE           = 4,   /*! device_t                                         */
-  KMEM_MAPPER           = 5,   /*! mapper_t                                         */
-  KMEM_PROCESS          = 6,   /*! process_t                                        */
-  KMEM_CPU_CTX          = 7,   /*! hal_cpu_context_t                                */
-  KMEM_FPU_CTX          = 8,   /*! hal_fpu_context_t                                */
-  KMEM_BARRIER          = 9,   /*! remote_barrier_t                                 */
+    KMEM_PAGE             = 0,   /*! reserved for PPM allocator                     */
+    KMEM_GENERIC          = 1,   /*! reserved for KHM allocator                     */
+    KMEM_KCM              = 2,   /*! kcm_t                                          */
+    KMEM_VSEG             = 3,   /*! vseg_t                                         */
+    KMEM_DEVICE           = 4,   /*! device_t                                       */
+    KMEM_MAPPER           = 5,   /*! mapper_t                                       */
+    KMEM_PROCESS          = 6,   /*! process_t                                      */
+    KMEM_CPU_CTX          = 7,   /*! hal_cpu_context_t                              */
+    KMEM_FPU_CTX          = 8,   /*! hal_fpu_context_t                              */
+    KMEM_BARRIER          = 9,   /*! remote_barrier_t                               */
 
-  KMEM_DEVFS_CTX        = 10,  /*! fatfs_inode_t                                    */
-  KMEM_FATFS_CTX        = 11,  /*! fatfs_ctx_t                                      */
-  KMEM_VFS_CTX          = 12,  /*! vfs_context_t                                    */
-  KMEM_VFS_INODE        = 13,  /*! vfs_inode_t                                      */
-  KMEM_VFS_DENTRY       = 14,  /*! vfs_dentry_t                                     */
-  KMEM_VFS_FILE         = 15,  /*! vfs_file_t                                       */
-  KMEM_SEM              = 16,  /*! remote_sem_t                                     */
-  KMEM_CONDVAR          = 17,  /*! remote_condvar_t                                 */
-  KMEM_MUTEX            = 18,  /*! remote_mutex_t                                   */
-  KMEM_512_BYTES        = 19,  /*! 512 bytes aligned                                */
+    KMEM_DEVFS_CTX        = 10,  /*! fatfs_inode_t                                  */
+    KMEM_FATFS_CTX        = 11,  /*! fatfs_ctx_t                                    */
+    KMEM_VFS_CTX          = 12,  /*! vfs_context_t                                  */
+    KMEM_VFS_INODE        = 13,  /*! vfs_inode_t                                    */
+    KMEM_VFS_DENTRY       = 14,  /*! vfs_dentry_t                                   */
+    KMEM_VFS_FILE         = 15,  /*! vfs_file_t                                     */
+    KMEM_SEM              = 16,  /*! remote_sem_t                                   */
+    KMEM_CONDVAR          = 17,  /*! remote_condvar_t                               */
+    KMEM_MUTEX            = 18,  /*! remote_mutex_t                                 */
+    KMEM_DIR              = 19,  /*! remote_dir_t                                   */
 
-  KMEM_TYPES_NR         = 21,
+    KMEM_512_BYTES        = 20,  /*! 512 bytes aligned                              */
+
+    KMEM_TYPES_NR         = 21,
 };
 

trunk/kernel/mm/mapper.c

@@ -644 +644 @@
 }  // end mapper_remote_set_32()
 
-
+//////////////////////////////////////////////////
+error_t mapper_display_page( xptr_t     mapper_xp,
+                             uint32_t   page_id,
+                             uint32_t   nbytes,
+                             char     * string )
+{
+    xptr_t     page_xp;        // extended pointer on page descriptor
+    xptr_t     base_xp;        // extended pointer on page base
+    char       buffer[4096];   // local buffer
+    uint32_t * tab;            // pointer on uint32_t to scan the buffer
+    uint32_t   line;           // line index
+    uint32_t   word;           // word index
+
+    if( nbytes > 4096)
+    {
+        printk("\n[ERROR] in %s : nbytes (%d) cannot be larger than 4096\n",
+        __FUNCTION__, nbytes );
+        return -1;
+    }
+    
+    // get extended pointer on page descriptor
+    page_xp = mapper_remote_get_page( mapper_xp , page_id );
+
+    if( page_xp == XPTR_NULL)
+    {
+        printk("\n[ERROR] in %s : cannot access page %d in mapper\n",
+        __FUNCTION__, page_id );
+        return -1;
+    }
+
+    // get extended pointer on page base
+    base_xp = ppm_page2base( page_xp );
+   
+    // copy remote page to local buffer
+    hal_remote_memcpy( XPTR( local_cxy , buffer ) , base_xp , nbytes );
+
+    // display 8 words per line
+    tab = (uint32_t *)buffer;
+    printk("\n***** %s : first %d bytes of page %d *****\n", string, nbytes, page_id );
+    for( line = 0 ; line < (nbytes >> 5) ; line++ )
+    {
+        printk("%X : ", line );
+        for( word = 0 ; word < 8 ; word++ ) printk("%X ", tab[(line<<3) + word] );
+        printk("\n");
+    }
+
+    return 0;
+
+}  // end mapper_display_page
+
+

trunk/kernel/mm/mapper.h

@@ -1 +1 @@
 /*
- * mapper.h - Kernel cache for FS files or directories definition.
+ * mapper.h - Kernel cache for VFS files/directories definition.
  *
  * Authors   Mohamed Lamine Karaoui (2015)
@@ -195 +195 @@
 
 /*******************************************************************************************
- * This function returns an extended pointer on a mapper page, identified by <page_id>,
- * index in the file. The - possibly remote - mapper is identified by the <mapper_xp>
- * argument.  It can be executed by a thread running in any cluster, as it uses remote
+ * This function returns an extended pointer on a page descriptor.
+ * The - possibly remote - mapper is identified by the <mapper_xp> argument.
+ * The page is identified by <page_id> argument (page index in the file).
+ * It can be executed by a thread running in any cluster, as it uses remote
  * access primitives to scan the mapper.
  * In case of miss, this function takes the mapper lock in WRITE_MODE, and call the 
@@ -205 +206 @@
  * @ mapper_xp  : extended pointer on the mapper.
  * @ page_id    : page index in file
- * @ returns extended pointer on page base if success / return XPTR_NULL if error.
+ * @ returns extended pointer on page descriptor if success / return XPTR_NULL if error.
  ******************************************************************************************/
 xptr_t mapper_remote_get_page( xptr_t    mapper_xp,
@@ -212 +213 @@
 /*******************************************************************************************
  * This function allows to read a single word in a mapper seen as and array of uint32_t.
- * It has bee designed to support remote access tho the FAT mapper of the FATFS. 
+ * It has bee designed to support remote access to the FAT mapper of the FATFS. 
  * It can be called by any thread running in any cluster.
  * In case of miss, it takes the mapper lock in WRITE_MODE, load the missing
@@ -218 +219 @@
  *******************************************************************************************
  * @ mapper_xp  : [in]  extended pointer on the mapper.
- * @ index          : [in]  32 bits word index in file.
+ * @ word_id    : [in]  32 bits word index in file.
  * @ p_value    : [out] local pointer on destination buffer.
  * @ returns 0 if success / return -1 if error.
@@ -234 +235 @@
  *******************************************************************************************
  * @ mapper_xp  : [in]  extended pointer on the mapper.
- * @ index          : [in]  32 bits word index in file.
- * @ p_value    : [in]  value to be written.
+ * @ word_id    : [in]  32 bits word index in file.
+ * @ value      : [in]  value to be written.
  * @ returns 0 if success / return -1 if error.
  ******************************************************************************************/
@@ -242 +243 @@
                               uint32_t   value );
 
+/*******************************************************************************************
+ * This debug function displays the content of a given page of a given mapper.
+ * - the mapper is identified by the <mapper_xp> argument.
+ * - the page is identified by the <page_id> argument.
+ * - the number of bytes to display in page is defined by the <nbytes> argument.
+ * The format is eigth (32 bits) words per line in hexadecimal.
+ * It can be called by any thread running in any cluster.
+ * In case of miss in mapper, it load the missing page from device to mapper.
+ *******************************************************************************************
+ * @ mapper_xp  : [in]  extended pointer on the mapper.
+ * @ page_id    : [in]  page index in file.
+ * @ nbytes     : [in]  value to be written.
+ * @ string     : [in]  string printed in header.
+ * @ returns 0 if success / return -1 if error.
+ ******************************************************************************************/
+error_t mapper_display_page( xptr_t     mapper_xp,
+                             uint32_t   page_id,
+                             uint32_t   nbytes,
+                             char     * string );
+
+
 #endif /* _MAPPER_H_ */

trunk/kernel/mm/ppm.c

@@ -210 +210 @@
 
 #if DEBUG_PPM_ALLOC_PAGES
+thread_t * this = CURRENT_THREAD;
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PPM_ALLOC_PAGES < cycle )
-printk("\n[DBG] in %s : thread %x in process %x enter for %d page(s) / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, 1<<order, cycle );
+printk("\n[%s] thread[%x,%x] enter for %d page(s) / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, 1<<order, cycle );
 #endif
 
 #if(DEBUG_PPM_ALLOC_PAGES & 0x1)
 if( DEBUG_PPM_ALLOC_PAGES < cycle )
-ppm_print();
+ppm_print("enter ppm_alloc_pages");
 #endif
 
         ppm_t    * ppm = &LOCAL_CLUSTER->ppm;
 
-        assert( (order < CONFIG_PPM_MAX_ORDER) ,
-    "illegal order argument = %x\n" , order );
+// check order
+assert( (order < CONFIG_PPM_MAX_ORDER) , "illegal order argument = %d\n" , order );
 
         page_t * block = NULL;  
@@ -250 +251 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PPM_ALLOC_PAGES < cycle )
-printk("\n[DBG] in %s : thread %x in process %x cannot allocate %d page(s) / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, 1<<order, cycle );
+printk("\n[%s] thread[%x,%x] cannot allocate %d page(s) / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, 1<<order, cycle );
 #endif
 
@@ -289 +290 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PPM_ALLOC_PAGES < cycle )
-printk("\n[DBG] in %s : thread %x in process %x exit for %d page(s) / ppn = %x / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, 
+printk("\n[%s] thread[%x,%x] exit for %d page(s) / ppn = %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, 
 1<<order, ppm_page2ppn(XPTR( local_cxy , block )), cycle );
+#endif
+
+#if(DEBUG_PPM_ALLOC_PAGES & 0x1)
+if( DEBUG_PPM_ALLOC_PAGES < cycle )
+ppm_print("exit ppm_alloc_pages");
 #endif
 
@@ -307 +313 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PPM_FREE_PAGES < cycle )
-printk("\n[DBG] in %s : thread %x in process %x enter for %d page(s) / ppn %x / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, 
+printk("\n[%s] thread[%x,%x] enter for %d page(s) / ppn %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, 
 1<<page->order, ppm_page2ppn(XPTR(local_cxy , page)), cycle );
 #endif
@@ -314 +320 @@
 #if(DEBUG_PPM_FREE_PAGES & 0x1)
 if( DEBUG_PPM_FREE_PAGES < cycle )
-ppm_print();
+ppm_print("enter ppm_free_pages");
 #endif
 
@@ -331 +337 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PPM_FREE_PAGES < cycle )
-printk("\n[DBG] in %s : thread %x in process %x exit for %d page(s) / ppn %x / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, 
+printk("\n[%s] thread[%x,%x] exit for %d page(s) / ppn %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, 
 1<<page->order, ppm_page2ppn(XPTR(local_cxy , page)), cycle );
 #endif
 
+#if(DEBUG_PPM_FREE_PAGES & 0x1)
+if( DEBUG_PPM_FREE_PAGES < cycle )
+ppm_print("exit ppm_free_pages");
+#endif
+
 }  // end ppm_free_pages()
 
-//////////////////////
-void ppm_print( void )
+///////////////////////////////
+void ppm_print( char * string )
 {
         uint32_t       order;
@@ -350 +361 @@
         busylock_acquire( &ppm->free_lock );
 
-        printk("\n***  PPM in cluster %x : %d pages ***\n", local_cxy , ppm->pages_nr );
+        printk("\n***  PPM in cluster %x / %s / %d pages ***\n",
+    local_cxy , string, ppm->pages_nr );
 
         for( order = 0 ; order < CONFIG_PPM_MAX_ORDER ; order++ )
@@ -413 +425 @@
     xptr_t dirty_lock_xp = XPTR( page_cxy , &ppm->dirty_lock );
            
-// printk("\n@@@ %s : before dirty_list lock aquire\n", __FUNCTION__ );
-
         // lock the remote PPM dirty_list
         remote_queuelock_acquire( dirty_lock_xp );
 
-// printk("\n@@@ %s : after dirty_list lock aquire\n", __FUNCTION__ );
-
     // lock the remote page
     remote_busylock_acquire( page_lock_xp );
-
-// printk("\n@@@ %s : after page lock aquire\n", __FUNCTION__ );
 
     // get remote page flags
@@ -466 +472 @@
         }
 
-// printk("\n@@@ %s : before page lock release\n", __FUNCTION__ );
-
     // unlock the remote page
     remote_busylock_release( page_lock_xp );
 
-// printk("\n@@@ %s : after page lock release\n", __FUNCTION__ );
-
         // unlock the remote PPM dirty_list
         remote_queuelock_release( dirty_lock_xp );
-
-// printk("\n@@@ %s : after page lock aquire\n", __FUNCTION__ );
 
         return done;

trunk/kernel/mm/ppm.h

@@ -83 +83 @@
  * This is the low-level physical pages allocation function.
  * It allocates N contiguous physical pages. N is a power of 2.
- * In normal use, you don't need to call it directly, as the recommended way to get
+ * In normal use, it should not be called directly, as the recommended way to get
  * physical pages is to call the generic allocator defined in kmem.h.
  *****************************************************************************************
  * @ order        : ln2( number of 4 Kbytes pages)
  * @ returns a pointer on the page descriptor if success / NULL otherwise
- **************************************************************************************à))**/
+ ****************************************************************************************/
 page_t * ppm_alloc_pages( uint32_t order );
 
@@ -174 +174 @@
 /*****************************************************************************************
  * This function prints the PPM allocator status in the calling thread cluster.
- ****************************************************************************************/
-void ppm_print( void );
+ *****************************************************************************************
+ * string   : character string printed in header
+ ****************************************************************************************/
+void ppm_print( char * string );
 
 /*****************************************************************************************

trunk/kernel/mm/vmm.c

@@ -1 +1 @@
 /*
- * vmm.c - virtual memory manager related operations interface.
+ * vmm.c - virtual memory manager related operations definition.
  *
  * Authors   Ghassan Almaless (2008,2009,2010,2011, 2012)
@@ -254 +254 @@
 }  // vmm_display()
 
-///////////////////////////////////
-void vmm_vseg_attach( vmm_t  * vmm,
-                      vseg_t * vseg )
+//////////////////////////////////////////
+void vmm_attach_vseg_to_vsl( vmm_t  * vmm,
+                             vseg_t * vseg )
 {
     // build extended pointer on rwlock protecting VSL
@@ -275 +275 @@
 }
 
-///////////////////////////////////
-void vmm_vseg_detach( vmm_t  * vmm,
-                      vseg_t * vseg )
+////////////////////////////////////////////
+void vmm_detach_vseg_from_vsl( vmm_t  * vmm,
+                               vseg_t * vseg )
 {
+    // get vseg type
+    uint32_t type = vseg->type;
+
     // build extended pointer on rwlock protecting VSL
     xptr_t lock_xp = XPTR( local_cxy , &vmm->vsegs_lock );
@@ -288 +291 @@
     vseg->vmm = NULL;
 
-    // remove vseg from vmm list
+    // remove vseg from VSL
     xlist_unlink( XPTR( local_cxy , &vseg->xlist ) );
 
     // release rwlock in write mode
     remote_rwlock_wr_release( lock_xp );
-}
+
+    // release the stack slot to VMM stack allocator if STACK type
+    if( type == VSEG_TYPE_STACK )
+    {
+        // get pointer on stack allocator
+        stack_mgr_t * mgr = &vmm->stack_mgr;
+
+        // compute slot index
+        uint32_t index = ((vseg->vpn_base - mgr->vpn_base - 1) / CONFIG_VMM_STACK_SIZE);
+
+        // update stacks_bitmap
+        busylock_acquire( &mgr->lock );
+        bitmap_clear( &mgr->bitmap , index );
+        busylock_release( &mgr->lock );
+    }
+
+    // release the vseg to VMM mmap allocator if MMAP type
+    if( (type == VSEG_TYPE_ANON) || (type == VSEG_TYPE_FILE) || (type == VSEG_TYPE_REMOTE) )
+    {
+        // get pointer on mmap allocator
+        mmap_mgr_t * mgr = &vmm->mmap_mgr;
+
+        // compute zombi_list index
+        uint32_t index = bits_log2( vseg->vpn_size );
+
+        // update zombi_list
+        busylock_acquire( &mgr->lock );
+        list_add_first( &mgr->zombi_list[index] , &vseg->zlist );
+        busylock_release( &mgr->lock );
+    }
+
+    // release physical memory allocated for vseg descriptor if no MMAP type
+    if( (type != VSEG_TYPE_ANON) && (type != VSEG_TYPE_FILE) && (type != VSEG_TYPE_REMOTE) )
+    {
+        vseg_free( vseg );
+    }
+
+}  // end vmm_remove_vseg_from_vsl()
 
 ////////////////////////////////////////////////
@@ -616 +656 @@
 
             // register child vseg in child VSL
-            vmm_vseg_attach( child_vmm , child_vseg );
+            vmm_attach_vseg_to_vsl( child_vmm , child_vseg );
 
 #if DEBUG_VMM_FORK_COPY
@@ -759 +799 @@
     xptr_t   root_xp = XPTR( local_cxy , &vmm->vsegs_root );
 
-    // remove all user vsegs registered in VSL
+    // scan the VSL to delete all registered vsegs
+    // (don't use a FOREACH for item deletion in xlist)
         while( !xlist_is_empty( root_xp ) )
         {
@@ -766 +807 @@
         vseg    = GET_PTR( vseg_xp );
 
-        // unmap and release physical pages 
-        vmm_unmap_vseg( process , vseg );
-
-        // remove vseg from VSL
-                vmm_vseg_detach( vmm , vseg );
-
-        // release memory allocated to vseg descriptor
-        vseg_free( vseg );
+        // delete vseg and release physical pages 
+        vmm_delete_vseg( process->pid , vseg->min );
 
 #if( DEBUG_VMM_DESTROY & 1 )
 if( DEBUG_VMM_DESTROY < cycle )
-printk("\n[%s] %s vseg released / vpn_base %x / vpn_size %d\n",
+printk("\n[%s] %s vseg deleted / vpn_base %x / vpn_size %d\n",
 __FUNCTION__ , vseg_type_str( vseg->type ), vseg->vpn_base, vseg->vpn_size );
 #endif
@@ -796 +831 @@
 __FUNCTION__ , vseg_type_str( vseg->type ), vseg->vpn_base, vseg->vpn_size );
 #endif
-                    vmm_vseg_detach( vmm , vseg );
+            // clean vseg descriptor
+            vseg->vmm = NULL;
+
+            // remove vseg from  xlist
+            xlist_unlink( XPTR( local_cxy , &vseg->xlist ) );
+
+                    // release vseg descriptor
             vseg_free( vseg );
 
@@ -1079 +1120 @@
 
     // attach vseg to VSL
-        vmm_vseg_attach( vmm , vseg );
+        vmm_attach_vseg_to_vsl( vmm , vseg );
 
 #if DEBUG_VMM_CREATE_VSEG
@@ -1092 +1133 @@
 }  // vmm_create_vseg()
 
-/////////////////////////////////////
-void vmm_remove_vseg( vseg_t * vseg )
+///////////////////////////////////
+void vmm_delete_vseg( pid_t    pid,
+                      intptr_t vaddr )
 {
-    // get pointers on calling process and VMM
-    thread_t   * this    = CURRENT_THREAD;
-    vmm_t      * vmm     = &this->process->vmm;
-    uint32_t     type    = vseg->type;
-
-    // detach vseg from VSL
-        vmm_vseg_detach( vmm , vseg );
-
-    // release the stack slot to VMM stack allocator if STACK type
-    if( type == VSEG_TYPE_STACK )
-    {
-        // get pointer on stack allocator
-        stack_mgr_t * mgr = &vmm->stack_mgr;
-
-        // compute slot index
-        uint32_t index = ((vseg->vpn_base - mgr->vpn_base - 1) / CONFIG_VMM_STACK_SIZE);
-
-        // update stacks_bitmap
-        busylock_acquire( &mgr->lock );
-        bitmap_clear( &mgr->bitmap , index );
-        busylock_release( &mgr->lock );
-    }
-
-    // release the vseg to VMM mmap allocator if MMAP type
-    if( (type == VSEG_TYPE_ANON) || (type == VSEG_TYPE_FILE) || (type == VSEG_TYPE_REMOTE) )
-    {
-        // get pointer on mmap allocator
-        mmap_mgr_t * mgr = &vmm->mmap_mgr;
-
-        // compute zombi_list index
-        uint32_t index = bits_log2( vseg->vpn_size );
-
-        // update zombi_list
-        busylock_acquire( &mgr->lock );
-        list_add_first( &mgr->zombi_list[index] , &vseg->zlist );
-        busylock_release( &mgr->lock );
-    }
-
-    // release physical memory allocated for vseg descriptor if no MMAP type
-    if( (type != VSEG_TYPE_ANON) && (type != VSEG_TYPE_FILE) && (type != VSEG_TYPE_REMOTE) )
-    {
-        vseg_free( vseg );
-    }
-}  // end vmm_remove_vseg()
-
-/////////////////////////////////////////
-void vmm_unmap_vseg( process_t * process,
-                     vseg_t    * vseg )
-{
+    process_t * process;    // local pointer on local process 
+    vmm_t     * vmm;        // local pointer on local process VMM
+    vseg_t    * vseg;       // local pointer on local vseg containing vaddr
+    gpt_t     * gpt;        // local pointer on local process GPT
     vpn_t       vpn;        // VPN of current PTE
     vpn_t       vpn_min;    // VPN of first PTE
@@ -1157 +1154 @@
     uint32_t    forks;      // actual number of pendinf forks
 
-#if DEBUG_VMM_UNMAP_VSEG
+#if DEBUG_VMM_DELETE_VSEG
 uint32_t   cycle = (uint32_t)hal_get_cycles();
 thread_t * this  = CURRENT_THREAD;
-if( DEBUG_VMM_UNMAP_VSEG < cycle )
-printk("\n[%s] thread[%x,%x] enter / process %x / vseg %s / base %x / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, process->pid,
-vseg_type_str( vseg->type ), vseg->vpn_base, cycle );
-#endif
-
-    // get pointer on local GPT
-    gpt_t     * gpt = &process->vmm.gpt;
-
-    // loop on pages in vseg
+if( DEBUG_VMM_DELETE_VSEG < cycle )
+printk("\n[%s] thread[%x,%x] enter / process %x / vaddr %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, vaddr, cycle );
+#endif
+
+    // get local pointer on local process descriptor
+    process = cluster_get_local_process_from_pid( pid );
+
+    if( process == NULL ) return;
+
+    // get pointers on local process VMM an GPT
+    vmm = &process->vmm;
+    gpt = &process->vmm.gpt;
+
+    // get local pointer on vseg containing vaddr
+    vseg = vmm_vseg_from_vaddr( vmm , vaddr );
+
+    if( vseg == NULL ) return;
+
+    // loop to invalidate all vseg PTEs in GPT
     vpn_min = vseg->vpn_base;
     vpn_max = vpn_min + vseg->vpn_size;
@@ -1180 +1187 @@
         { 
 
-#if( DEBUG_VMM_UNMAP_VSEG & 1 )
-if( DEBUG_VMM_UNMAP_VSEG < cycle )
-printk("- vpn %x / ppn %x\n" , vpn , ppn );
+#if( DEBUG_VMM_DELETE_VSEG & 1 )
+if( DEBUG_VMM_DELETE_VSEG < cycle )
+printk("- unmap vpn %x / ppn %x / vseg %s \n" , vpn , ppn, vseg_type_str(vseg->type) );
 #endif
 
@@ -1225 +1232 @@
                         rpc_pmem_release_pages_client( page_cxy , page_ptr );
                     }
+
+#if( DEBUG_VMM_DELETE_VSEG & 1 )
+if( DEBUG_VMM_DELETE_VSEG < cycle )
+printk("- release ppn %x\n", ppn );
+#endif
                 }
             }
@@ -1230 +1242 @@
     }
 
-#if DEBUG_VMM_UNMAP_VSEG
+    // remove vseg from VSL and release vseg descriptor (if not MMAP)
+    vmm_detach_vseg_from_vsl( vmm , vseg );
+
+#if DEBUG_VMM_DELETE_VSEG
 cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_VMM_UNMAP_VSEG < cycle )
+if( DEBUG_VMM_DELETE_VSEG < cycle )
 printk("\n[%s] thread[%x,%x] exit / process %x / vseg %s / base %x / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, process->pid, 
-vseg_type_str( vseg->type ), vseg->vpn_base, cycle );
-#endif
-
-}  // end vmm_unmap_vseg()
-
-//////////////////////////////////////////////////////////////////////////////////////////
-// This low-level static function is called by the vmm_get_vseg(), vmm_get_pte(),
-// and vmm_resize_vseg() functions.  It scan the local VSL to find the unique vseg 
-// containing a given virtual address.
-//////////////////////////////////////////////////////////////////////////////////////////
-// @ vmm     : pointer on the process VMM.
-// @ vaddr   : virtual address.
-// @ return vseg pointer if success / return NULL if not found.
-//////////////////////////////////////////////////////////////////////////////////////////
-static vseg_t * vmm_vseg_from_vaddr( vmm_t    * vmm,
-                                     intptr_t   vaddr )
+__FUNCTION__, this->process->pid, this->trdid, pid, vseg_type_str(vseg->type), vaddr, cycle );
+#endif
+
+}  // end vmm_delete_vseg()
+
+/////////////////////////////////////////////
+vseg_t * vmm_vseg_from_vaddr( vmm_t    * vmm,
+                              intptr_t   vaddr )
 {
     xptr_t   iter_xp;
@@ -1310 +1316 @@
         remote_rwlock_wr_acquire( lock_xp );
 
-        if( (vseg->min > addr_min) || (vseg->max < addr_max) )   // region not included in vseg
-    {
-        error = EINVAL;
-    }
-        else if( (vseg->min == addr_min) && (vseg->max == addr_max) ) // vseg must be removed
-    {
-        vmm_remove_vseg( vseg );
+        if( (vseg->min > addr_min) || (vseg->max < addr_max) )        // not included in vseg
+    {
+        error = -1;
+    }
+        else if( (vseg->min == addr_min) && (vseg->max == addr_max) )  // vseg must be deleted
+    {
+        vmm_delete_vseg( process->pid , vseg->min );
         error = 0;
     }
-        else if( vseg->min == addr_min )                         // vseg must be resized
+        else if( vseg->min == addr_min )                               // vseg must be resized
     {
         // update vseg base address
@@ -1331 +1337 @@
         error = 0;
     }
-        else if( vseg->max == addr_max )                          // vseg must be resized
+        else if( vseg->max == addr_max )                              // vseg must be resized
     {
         // update vseg max address
@@ -1343 +1349 @@
         error = 0;
     }
-    else                                                      // vseg cut in three regions 
+    else                                                          // vseg cut in three regions 
     {
         // resize existing vseg
@@ -1415 +1421 @@
         vseg_init_from_ref( vseg , vseg_xp );
 
-        // register local vseg in local VMM
-        vmm_vseg_attach( vmm , vseg );
+        // register local vseg in local VSL
+        vmm_attach_vseg_to_vsl( vmm , vseg );
     }   
 

trunk/kernel/mm/vmm.h

@@ -38 +38 @@
 
 struct process_s;
+struct vseg_s;
 
 /*********************************************************************************************
  * This structure defines the STACK allocator used by the VMM to dynamically handle
- * a STACK vseg requested or released by an user process.
- * This allocator handles a fixed size array of fixed size slots in the STACK zone.
+ * vseg allocation or release requests for an user thread.
+ * This allocator handles a fixed size array of fixed size slots in STACK zone of user space.
  * The stack size and the number of slots are defined by the CONFIG_VMM_STACK_SIZE, and
  * CONFIG_VMM_STACK_BASE parameters.
- * Each slot can contain one user stack vseg. The first page in the slot is not allocated
- * to detect stack overflow.
+ * Each slot can contain one user stack vseg. The first 4 Kbytes page in the slot is not
+ * mapped to detect stack overflow.
  * The slot index can be computed form the slot base address, and reversely.
  * All allocation / release operations are registered in the stack_bitmap, that completely
- * define the STACK zone state.
+ * define the STACK zone status.
  ********************************************************************************************/
 
@@ -159 +160 @@
 
 /*********************************************************************************************
- * This function adds a vseg descriptor in the VSL of a given VMM,
- * and updates the vmm field in the vseg descriptor.
- * It takes the lock protecting VSL.
- *********************************************************************************************
- * @ vmm       : pointer on the VMM
- * @ vseg      : pointer on the vseg descriptor
- ********************************************************************************************/
-void vmm_vseg_attach( struct vmm_s  * vmm,
-                      vseg_t        * vseg );
-
-/*********************************************************************************************
- * This function removes a vseg descriptor from the set of vsegs controlled by a given VMM,
- * and updates the vmm field in the vseg descriptor. No memory is released.
- * It takes the lock protecting VSL.
- *********************************************************************************************
- * @ vmm       : pointer on the VMM
- * @ vseg      : pointer on the vseg descriptor
- ********************************************************************************************/
-void vmm_vseg_detach( struct vmm_s  * vmm,
-                      vseg_t        * vseg );
-
-/*********************************************************************************************
  * This function is called by the process_make_fork() function. It partially copies
  * the content of a remote parent process VMM to the local child process VMM:
@@ -235 +214 @@
 
 /*********************************************************************************************
- * This function unmaps from the local GPT all mapped PTEs of a vseg identified by the
- * <process> and <vseg> arguments. It can be used for any type of vseg.
- * If this function is executed in the reference cluster, it handles for each referenced 
- * physical pages the pending forks counter :
- * - if counter is non-zero, it decrements it.
- * - if counter is zero, it releases the physical page to local kmem allocator.
- *********************************************************************************************
- * @ process  : pointer on process descriptor.
- * @ vseg     : pointer on the vseg to be unmapped.
- ********************************************************************************************/
-void vmm_unmap_vseg( struct process_s * process,
-                     vseg_t           * vseg );
-
-/*********************************************************************************************
  * This function deletes, in the local cluster, all vsegs registered in the VSL
  * of the process identified by the <process> argument. For each vseg:
@@ -254 +219 @@
  * - it removes the vseg from the local VSL.
  * - it releases the memory allocated to the local vseg descriptors.
- * Finally, it releases the memory allocated to the GPT itself.
+ * - it releases the memory allocated to the GPT itself.
  *********************************************************************************************
  * @ process   : pointer on process descriptor.
@@ -304 +269 @@
 
 /*********************************************************************************************
- * This function removes a vseg identified by it's pointer from the VMM of the calling process.
- * - If the vseg has not the STACK or MMAP type, it is removed from the vsegs list,
- *   and the physical memory allocated to vseg descriptor is released to KMEM.
- * - If the vseg has the STACK type, it is removed from the vsegs list, the physical memory
- *   allocated to vseg descriptor is released to KMEM, and the stack slot is returned to the
- *   VMM STACK allocator.
- * - If the vseg has the MMAP type, it is removed from the vsegs list and is registered
- *   in the zombi_list of the VMM MMAP allocator for future reuse. The physical memory
- *   allocated to vseg descriptor is NOT released to KMEM.
- *********************************************************************************************
- * @ vseg      : pointer on vseg to be removed.
- ********************************************************************************************/
-void vmm_remove_vseg( vseg_t * vseg );
+ * This function removes from the local VMM of a process descriptor identified by the <pid>
+ * argument a local vseg identified by its base address <vaddr> in user space.
+ * It can be used for any type of vseg, but must be called by a local thread.
+ * Use the RPC_VMM_DELETE_VSEG if the client thread is not local.
+ * It does nothing if the process is not registered in the local cluster.
+ * It does nothing if the vseg is not registered in the local process VSL.
+ * - It removes from the local GPT all registered PTEs. If it is executed in the reference
+ *   cluster, it releases the referenced physical pages, to the relevant kmem allocator,
+ *   depending on vseg type and the pending forks counter.
+ * - It removes the vseg from the local VSL, and release the vseg descriptor if not MMAP.
+ *********************************************************************************************
+ * @ process  : process identifier.
+ * @ vaddr    : vseg base address in user space.
+ ********************************************************************************************/
+void vmm_delete_vseg( pid_t    pid,
+                      intptr_t vaddr );
+
+/*********************************************************************************************
+ * This function insert a new <vseg> descriptor in the VSL identifed by the <vmm> argument.
+ * and updates the vmm field in the vseg descriptor.
+ * It takes the lock protecting VSL.
+ *********************************************************************************************
+ * @ vmm       : local pointer on local VMM.
+ * @ vseg      : local pointer on local vseg descriptor.
+ ********************************************************************************************/
+void vmm_attach_vseg_to_vsl( vmm_t  * vmm,
+                             vseg_t * vseg );
+
+/*********************************************************************************************
+ * This function removes a vseg identified by the <vseg> argument from the local VSL
+ * identified by the <vmm> argument and release the memory allocated to vseg descriptor,
+ * for all vseg types, BUT the MMAP type (i.e. ANON or REMOTE).
+ * - If the vseg has not the STACK or MMAP type, it is simply removed from the VSL,
+ *   and vseg descriptor is released.
+ * - If the vseg has the STACK type, it is removed from VSL, vseg descriptor is released,
+ *   and the stack slot is returned to the local VMM_STACK allocator.
+ * - If the vseg has the MMAP type, it is removed from VSL and is registered in zombi_list
+ *   of the VMM_MMAP allocator for future reuse. The vseg descriptor is NOT released.
+ *********************************************************************************************
+ * @ vmm       : local pointer on local VMM.
+ * @ vseg      : local pointer on local vseg to be removed.
+ ********************************************************************************************/
+void vmm_detach_vseg_from_vsl( vmm_t  * vmm,
+                               vseg_t * vseg );
 
 /*********************************************************************************************
@@ -338 +334 @@
 
 /*********************************************************************************************
+ * This low-level function scan the local VSL in <vmm> to find the unique vseg containing 
+ * a given virtual address <vaddr>.
+ * It is called by the vmm_get_vseg(), vmm_get_pte(), and vmm_resize_vseg() functions. 
+ *********************************************************************************************
+ * @ vmm     : pointer on the process VMM.
+ * @ vaddr   : virtual address.
+ * @ return vseg pointer if success / return NULL if not found.
+ ********************************************************************************************/
+struct vseg_s * vmm_vseg_from_vaddr( vmm_t    * vmm,
+                                     intptr_t   vaddr );
+
+/*********************************************************************************************
  * This function checks that a given virtual address is contained in a registered vseg.
  * It can be called by any thread running in any cluster:
@@ -344 +352 @@
  *   register it in local VMM and returns the local vseg pointer, if success.
  * - it returns an user error if the vseg is missing in the reference VMM, or if there is 
- *   not enough memory for a new vseg descriptor in cluster containing the calling thread.
+ *   not enough memory for a new vseg descriptor in the calling thread cluster.
  *********************************************************************************************
  * @ process   : [in] pointer on process descriptor
@@ -350 +358 @@
  * @ vseg      : [out] local pointer on local vseg
  * @ returns 0 if success / returns -1 if user error (out of segment).
- *********************************************************************************************/
+ ********************************************************************************************/
 error_t vmm_get_vseg( struct process_s  * process,
                       intptr_t            vaddr,

trunk/kernel/mm/vseg.h

@@ -71 +71 @@
 typedef struct vseg_s
 {
-    xlist_entry_t     xlist;        /*! all vsegs in same VSL (or same zombi list)        */
+    xlist_entry_t     xlist;        /*! all vsegs in same VSL                             */
     list_entry_t      zlist;        /*! all vsegs in same zombi list                      */
     struct vmm_s    * vmm;          /*! pointer on associated VM manager                  */

trunk/kernel/syscalls/shared_include/shared_almos.h

@@ -52 +52 @@
     DISPLAY_DQDT              = 7,
     DISPLAY_BUSYLOCKS         = 8,
+    DISPLAY_MAPPER            = 9,
 }
 display_type_t;

trunk/kernel/syscalls/shared_include/shared_dirent.h

@@ -26 +26 @@
 
 /*******************************************************************************************
- * These two structure defines the informations returned to user by the opendir()
- * function, used by the readdir() function, and released by the closedir() function.
- * - "DIR" describes the complete directory.
- * - "dirent" describes one directory entry.
+ * This enum defines the possible types for a dirent inode in a dirent structure.
+ *
+ * WARNING : these types must be kept consistent with inode types in <vfs.h> file.
+ *           and with types in <shared_stat.h> file.
  ******************************************************************************************/
 
-#define DIRENT_NAME_MAX_LENGTH  56
-#define DIRENT_MAX_NUMBER       63
+typedef enum 
+{
+    DT_REG     = 0,                     /*! regular file                                  */
+    DT_DIR     = 1,                     /*! directory                                     */
+    DT_FIFO    = 2,                     /*! named pipe (FIFO)                             */
+    DT_PIPE    = 3,                     /*! anonymous pipe                                */
+    DT_SOCK    = 4,                     /*! socket                                        */
+    DT_CHR     = 5,                     /*! character device                              */
+    DT_BLK     = 6,                     /*! block device                                  */
+    DT_LNK     = 7,                     /*! symbolic link                                 */
+    DT_UNKNOWN = 8,                     /*! undetermined type                             */
+}
+dirent_type_t;
+
+/*******************************************************************************************
+ * This defines the actual ALMOS-MKH implementation of the DIR user type.
+ ******************************************************************************************/
+
+typedef unsigned int   DIR;
+
+/*******************************************************************************************
+ * This structure defines the informations returned to user by the readdir() syscall.
+ * 
+ * WARNING: sizeof(dirent) must be 64 bytes.
+ ******************************************************************************************/
 
 struct dirent
 {
-    unsigned int   inum;                                /*! inode identifier              */
-    unsigned int   type;                                /*! inode type                    */
-    char           name[DIRENT_NAME_MAX_LENGTH];        /*! directory entry name          */
+    int           d_ino;                                  /*! inode identifier            */
+    int           d_type;                                 /*! inode type                  */
+    char          d_name[48];                             /*! dentry name                 */
+    char          padding[64 - 48 - (2*sizeof(int))];
 };
 
-typedef struct user_directory
-{
-    struct dirent   entry[DIRENT_MAX_NUMBER];
-    unsigned int    current;
-}
-DIR;
-
 #endif

trunk/kernel/syscalls/shared_include/shared_stat.h

@@ -30 +30 @@
  *****************************************************************************************/
 
-typedef struct stat 
+struct stat 
 {
         unsigned int    st_dev;     /*! ID of device containing file                         */
@@ -42 +42 @@
         unsigned int    st_blksize; /*! blocksize for file system I/O                        */
         unsigned int    st_blocks;  /*! number of allocated blocks                           */
-}
-stat_t;
+};
 
 /******************************************************************************************
@@ -52 +51 @@
  *
  * WARNING : these macros must be kept consistent with inode types in <vfs.h> file.
+ *           and with types in <dirent.h> file.
  *****************************************************************************************/
 
@@ -60 +60 @@
 #define  S_ISSOCK(x)  ((((x)>>16) & 0xF) == 4)    /*! it is a socket                     */
 #define  S_ISCHR(x)   ((((x)>>16) & 0xF) == 5)    /*! it is a character device           */
-#define  S_ISLNK(x)   ((((x)>>16) & 0xF) == 6)    /*! it is a symbolic link              */
+#define  S_ISBLK(x)   ((((x)>>16) & 0xF) == 6)    /*! it is a block device               */
+#define  S_ISLNK(x)   ((((x)>>16) & 0xF) == 7)    /*! it is a symbolic link              */
 
 #endif /* _STAT_H_ */

trunk/kernel/syscalls/sys_closedir.c

@@ -1 +1 @@
 /*
- * sys_closedir.c - Close an open directory.
+ * sys_closedir.c - Close an open VFS directory.
  * 
- * Author    Alain Greiner  (2016, 2017)
+ * Author    Alain Greiner  (2016,2017,2018)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -22 +22 @@
  */
 
+#include <kernel_config.h>
 #include <hal_kernel_types.h>
 #include <vfs.h>
@@ -27 +28 @@
 #include <thread.h>
 #include <process.h>
+#include <remote_dir.h>
 #include <errno.h>
 #include <syscalls.h>
@@ -34 +36 @@
 int sys_closedir ( DIR * dirp )
 {
-    printk("\n[ERROR] in %s : not implemented yet\n", __FUNCTION__, dirp );
-    return -1;
+    xptr_t         dir_xp;       // extended pointer on remote_dir_t structure
+
+        thread_t  * this    = CURRENT_THREAD;  // client thread
+        process_t * process = this->process;   // client process
+
+#if (DEBUG_SYS_CLOSEDIR || CONFIG_INSTRUMENTATION_SYSCALLS)
+uint64_t     tm_start = hal_get_cycles();
+#endif
+
+#if DEBUG_SYS_CLOSEDIR
+if( DEBUG_SYS_CLOSEDIR < tm_start )
+printk("\n[%s] thread[%x,%x] enter for DIR <%x> / cycle %d\n",
+__FUNCTION__, process->pid, this->trdid, dirp, (uint32_t)tm_start );
+#endif
+ 
+    // get extended pointer on kernel remote_dir_t structure from dirp
+    dir_xp  = remote_dir_from_ident( (intptr_t)dirp );
+
+    if( dir_xp == XPTR_NULL )
+        {
+
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s / thread[%x,%x] : DIR pointer %x not registered\n",
+__FUNCTION__ , process->pid , this->trdid, dirp );
+#endif
+                this->errno = EINVAL;
+                return -1;
+        }       
+
+    // delete kernel remote_dir_t structure
+    remote_dir_destroy( dir_xp );
+
+    hal_fence();
+
+#if (DEBUG_SYS_CLOSEDIR || CONFIG_INSTRUMENTATION_SYSCALLS)
+uint64_t     tm_end = hal_get_cycles();
+#endif
+
+#if DEBUG_SYS_CLOSEDIR
+if( DEBUG_SYS_CLOSEDIR < tm_end )
+printk("\n[%s] thread[%x,%x] exit for DIR <%x> / cycle %d\n",
+__FUNCTION__, process->pid, this->trdid, dirp, (uint32_t)tm_end );
+#endif
+ 
+#if CONFIG_INSTRUMENTATION_SYSCALLS
+hal_atomic_add( &syscalls_cumul_cost[SYS_CLOSEDIR] , tm_end - tm_start );
+hal_atomic_add( &syscalls_occurences[SYS_CLOSEDIR] , 1 );
+#endif
+
+    return 0;
+
 }  // end sys_closedir()

trunk/kernel/syscalls/sys_display.c

@@ -31 +31 @@
 #include <string.h>
 #include <shared_syscalls.h>
+#include <vfs.h>
+#include <mapper.h>
 
 #include <syscalls.h>
@@ -56 +58 @@
 int sys_display( reg_t  type,
                  reg_t  arg0,
-                 reg_t  arg1 )
+                 reg_t  arg1,
+                 reg_t  arg2 )
 {
 
@@ -278 +281 @@
         thread_display_busylocks( thread_xp );
     }
+    /////////////////////////////////
+    else if( type == DISPLAY_MAPPER )
+    {
+        xptr_t        root_inode_xp;
+        xptr_t        inode_xp;
+        cxy_t         inode_cxy;
+        vfs_inode_t * inode_ptr;
+        xptr_t        mapper_xp;
+        mapper_t    * mapper_ptr;
+
+        char          kbuf[CONFIG_VFS_MAX_PATH_LENGTH];
+
+        char     * path    = (char *)arg0;
+        uint32_t   page_id = (uint32_t)arg1;
+        uint32_t   nbytes  = (uint32_t)arg2;
+
+        // check pathname length
+        if( hal_strlen_from_uspace( path ) >= CONFIG_VFS_MAX_PATH_LENGTH )
+        {
+
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for MAPPER : pathname too long\n",
+ __FUNCTION__ );
+#endif
+            this->errno = ENFILE;
+            return -1;
+        }
+
+        // copy pathname in kernel space
+        hal_strcpy_from_uspace( kbuf , path , CONFIG_VFS_MAX_PATH_LENGTH );
+
+        // compute root inode for pathname 
+        if( kbuf[0] == '/' )                        // absolute path
+        {
+            // use extended pointer on VFS root inode
+            root_inode_xp = process->vfs_root_xp;
+        }
+        else                                        // relative path
+        {
+            // get cluster and local pointer on reference process
+            xptr_t      ref_xp  = process->ref_xp;
+            process_t * ref_ptr = (process_t *)GET_PTR( ref_xp );
+            cxy_t       ref_cxy = GET_CXY( ref_xp );
+
+            // use extended pointer on CWD inode
+            root_inode_xp = hal_remote_l64( XPTR( ref_cxy , &ref_ptr->cwd_xp ) );
+        }
+
+        // get extended pointer on target inode
+        error = vfs_lookup( root_inode_xp,
+                            kbuf,
+                            0,
+                            &inode_xp,
+                            NULL );
+        if( error )
+            {
+
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for MAPPER : cannot found inode <%s>\n",
+__FUNCTION__ , kbuf );
+#endif
+                    this->errno = ENFILE;
+                    return -1;
+            }
+   
+        // get target inode cluster and local pointer
+        inode_cxy = GET_CXY( inode_xp );
+        inode_ptr = GET_PTR( inode_xp );
+
+        // get extended pointer on target mapper
+        mapper_ptr = hal_remote_lpt( XPTR( inode_cxy , &inode_ptr->mapper ) );
+        mapper_xp  = XPTR( inode_cxy , mapper_ptr );
+
+        // display mapper
+        error = mapper_display_page( mapper_xp , page_id , nbytes , kbuf );
+
+        if( error )
+            {
+
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for MAPPER : cannot display page %d\n",
+__FUNCTION__ , page_id );
+#endif
+                    this->errno = ENFILE;
+                    return -1;
+            }
+    }
     ////
     else 

trunk/kernel/syscalls/sys_mmap.c

@@ -119 +119 @@
     // test mmap type : can be FILE / ANON / REMOTE
 
-    if( (map_anon == false) && (map_remote == false) )   // FILE
+    /////////////////////////////////////////////////////////// MAP_FILE
+    if( (map_anon == false) && (map_remote == false) )   
     {
 
@@ -217 +218 @@
         vseg_cxy  = file_cxy;
     }
-    else if ( map_anon )                                 // MAP_ANON
+    ///////////////////////////////////////////////////////// MAP_ANON
+    else if ( map_anon )                                 
     {
         mapper_xp = XPTR_NULL;
@@ -230 +232 @@
 
     } 
-    else                                                 // MAP_REMOTE
+    /////////////////////////////////////////////////////// MAP_REMOTE
+    else                                                 
     {
         mapper_xp = XPTR_NULL;

trunk/kernel/syscalls/sys_opendir.c

@@ -1 +1 @@
 /*
- * sys_opendir.c - open a directory.
+ * sys_opendir.c - Open a VFS directory.
  * 
  * Author        Alain Greiner (2016,2017,2018)
@@ -22 +22 @@
  */
 
+#include <kernel_config.h>
 #include <hal_kernel_types.h>
 #include <hal_uspace.h>
 #include <thread.h>
 #include <process.h>
+#include <remote_dir.h>
 #include <printk.h>
 #include <errno.h>
+#include <vseg.h>
 #include <vfs.h>
 #include <syscalls.h>
@@ -36 +39 @@
                   DIR  ** dirp )
 {
-    error_t       error;
-    vseg_t      * vseg;                   // for user space checking
-    xptr_t        root_inode_xp;          // extended pointer on path root inode
-
+    error_t        error;
+    xptr_t         root_inode_xp;          // extended pointer on path root inode
+    xptr_t         inode_xp;               // extended pointer on directory inode
+    vfs_inode_t  * inode_ptr;              // local pointer on directory inode
+    cxy_t          inode_cxy;              // directory inode cluster
+    uint32_t       inode_type;             // to check directory inode type
+    xptr_t         dir_xp;                 // extended pointer on remote_dir_t
+    remote_dir_t * dir_ptr;                // local pointer on remote_dir_t
+    cxy_t          dir_cxy;                // remote_dir_t cluster identifier
+    vseg_t       * vseg;                   // for user space checking
+    intptr_t       ident;                  // dirent array pointer in user space                  
     char          kbuf[CONFIG_VFS_MAX_PATH_LENGTH];
         
-        thread_t  * this    = CURRENT_THREAD;
-        process_t * process = this->process;
+        thread_t     * this    = CURRENT_THREAD;  // client thread
+        process_t    * process = this->process;   // client process
 
 #if (DEBUG_SYS_OPENDIR || CONFIG_INSTRUMENTATION_SYSCALLS)
@@ -85 +95 @@
 #endif
 
-    // compute root inode for path 
+    // compute root inode for pathname 
     if( kbuf[0] == '/' )                        // absolute path
     {
@@ -102 +112 @@
     }
 
-/*
-    // call the relevant VFS function ???
-    error = vfs_opendir( root_inode_xp,
-                         kbuf );
+    // get extended pointer on directory inode
+    error = vfs_lookup( root_inode_xp,
+                        kbuf,
+                        0,
+                        &inode_xp,
+                        NULL );
     if( error )
         {
 
 #if DEBUG_SYSCALLS_ERROR
-printk("\n[ERROR] in %s / thread[%x,%x] : cannot open directory <%s>\n",
-__FUNCTION__ , process->pid , this->trdid , pathname );
+printk("\n[ERROR] in %s / thread[%x,%x] : cannot found directory <%s>\n",
+__FUNCTION__ , process->pid , this->trdid , kbuf );
 #endif
                 this->errno = ENFILE;
@@ -117 +129 @@
         }
    
-    // copy to user space ???
-*/
+    // check inode type 
+    inode_ptr  = GET_PTR( inode_xp );
+    inode_cxy  = GET_CXY( inode_xp );
+    inode_type = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->type ) );
+
+    if( inode_type != INODE_TYPE_DIR )
+        {
+
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s / thread[%x,%x] : cannot found directory <%s>\n",
+__FUNCTION__ , process->pid , this->trdid , kbuf );
+#endif
+                this->errno = ENFILE;
+                return -1;
+        }
+   
+    // allocate, initialize, and register a new remote_dir_t structure
+    // in the calling process reference cluster
+    dir_xp  = remote_dir_create( inode_xp );
+    dir_ptr = GET_PTR( dir_xp );
+    dir_cxy = GET_CXY( dir_xp );
+
+    if( dir_xp == XPTR_NULL )
+        {
+
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s / thread[%x,%x] : cannot create remote_dir for <%s>\n",
+__FUNCTION__ , process->pid , this->trdid , kbuf );
+#endif
+                this->errno = ENFILE;
+                return -1;
+        }
+   
+    // get ident from remote_dir structure
+    ident = (intptr_t)hal_remote_lpt( XPTR( dir_cxy , &dir_ptr->ident ) );
+
+    // set ident value in user buffer
+    hal_copy_to_uspace( dirp , &ident , sizeof(intptr_t) );
 
     hal_fence();

trunk/kernel/syscalls/sys_readdir.c

@@ -1 +1 @@
 /*
- * sys_readdir.c - Read one entry from an open directory.
+ * sys_readdir.c - Copy one entry from an open VFS directory to an user buffer.
  *
- * Author    Alain Greiner (2016,2017)
+ * Author    Alain Greiner (2016,2017,2018)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -30 +30 @@
 #include <vfs.h>
 #include <process.h>
+#include <remote_dir.h>
 #include <syscalls.h>
 #include <shared_syscalls.h>
@@ -35 +36 @@
 ///////////////////////////////////////
 int sys_readdir( DIR            * dirp,
-                 struct dirent ** dentp )
+                 struct dirent ** buffer )
 {
-    printk("\n[ERROR] in %s : not implemented yet\n", __FUNCTION__, dirp, dentp );
-    return -1;
+    error_t         error;
+    vseg_t        * vseg;               // for user space checking of buffer
+    xptr_t          dir_xp;             // extended pointer on remote_dir_t structure
+    remote_dir_t  * dir_ptr;            // local pointer on remote_dir_t structure
+    cxy_t           dir_cxy;            // remote_dir_t stucture cluster identifier
+    struct dirent * direntp;            // dirent pointer in user space  
+    uint32_t        entries;            // total number of dirent entries
+    uint32_t        current;            // current dirent index
+
+        thread_t  * this    = CURRENT_THREAD;  // client thread
+        process_t * process = this->process;   // client process
+
+#if (DEBUG_SYS_READDIR || CONFIG_INSTRUMENTATION_SYSCALLS)
+uint64_t     tm_start = hal_get_cycles();
+#endif
+
+#if DEBUG_SYS_READDIR
+if( DEBUG_SYS_READDIR < tm_start )
+printk("\n[%s] thread[%x,%x] enter / dirp %x / cycle %d\n",
+__FUNCTION__, process->pid, this->trdid, dirp, (uint32_t)tm_start );
+#endif
+ 
+    // check buffer in user space
+    error = vmm_get_vseg( process , (intptr_t)buffer, &vseg );
+
+        if( error )
+        {
+
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s / thread[%x,%x] : user buffer %x unmapped\n",
+__FUNCTION__ , process->pid , this->trdid, buffer );
+vmm_display( process , false );
+#endif
+                this->errno = EINVAL;
+                return -1;
+        }       
+
+    // get pointers on remote_dir_t structure from dirp
+    dir_xp  = remote_dir_from_ident( (intptr_t)dirp );
+    dir_ptr = GET_PTR( dir_xp );
+    dir_cxy = GET_CXY( dir_xp );
+
+    if( dir_xp == XPTR_NULL )
+        {
+
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s / thread[%x,%x] : dirp %x not registered\n",
+__FUNCTION__ , process->pid , this->trdid, dirp );
+#endif
+                this->errno = EBADF;
+                return -1;
+        }       
+
+    // get "current" and "entries_nr" values from remote_dir_t structure
+    current = hal_remote_l32( XPTR( dir_cxy , &dir_ptr->current ) );
+    entries = hal_remote_l32( XPTR( dir_cxy , &dir_ptr->entries ) );
+
+    // check "current" index
+    if( current >= entries )
+    {
+        this->errno = 0;
+        return -1;
+    }
+
+    // compute dirent pointer in user space
+    direntp = (struct dirent *)dirp + current;
+
+#if (DEBUG_SYS_READDIR & 1)
+if( DEBUG_SYS_READDIR < tm_start )
+printk("\n[%s] entries = %d / current = %d / direntp = %x\n",
+__FUNCTION__, entries, current, direntp );
+#endif
+
+    // copy dirent pointer to user buffer 
+    hal_copy_to_uspace( buffer, &direntp , sizeof(void *) );
+
+    // update current index in "remote_dir_t" structure
+    hal_remote_atomic_add( XPTR( dir_cxy , &dir_ptr->current ) , 1 );
+
+    hal_fence();
+
+#if (DEBUG_SYS_READDIR || CONFIG_INSTRUMENTATION_SYSCALLS)
+uint64_t     tm_end = hal_get_cycles();
+#endif
+
+#if DEBUG_SYS_READDIR
+if( DEBUG_SYS_READDIR < tm_end )
+printk("\n[%s] thread[%x,%x] exit / cycle %d\n",
+__FUNCTION__, process->pid, this->trdid, (uint32_t)tm_end );
+#endif
+ 
+#if CONFIG_INSTRUMENTATION_SYSCALLS
+hal_atomic_add( &syscalls_cumul_cost[SYS_READDIR] , tm_end - tm_start );
+hal_atomic_add( &syscalls_occurences[SYS_READDIR] , 1 );
+#endif
+
+        return 0;
+
 }  // end sys_readdir()

trunk/kernel/syscalls/syscalls.h

@@ -328 +328 @@
 /****************************************************************************************** 
  * [23] This function open a directory, that must exist in the file system, returning 
- * a DIR pointer on the directory in user space.
- ******************************************************************************************
- * @ pathname   : pathname (can be relative or absolute).
+ * a DIR pointer on the dirent array in user space.
+ ******************************************************************************************
+ * @ pathname   : [in]  pathname (can be relative or absolute).
  * @ dirp       : [out] buffer for pointer on user directory (DIR).
  * @ return 0 if success / returns -1 if failure.
@@ -341 +341 @@
  * next directory entry in the directory identified by the <dirp> argument.
  ******************************************************************************************
- * @ dirp     : user pointer identifying the searched directory.
- * @ dentp    : [out] buffer for pointer on user direntory entry (dirent).
+ * @ dirp     : [in]  user pointer on dirent array identifying the open directory.
+ * @ buffer   : [out] pointer on user buffer for a pointer on dirent in user space.
  * @ return O if success / returns -1 if failure.
  *****************************************************************************************/
 int sys_readdir( DIR            * dirp,
-                 struct dirent ** dentp );
+                 struct dirent ** buffer );
 
 /****************************************************************************************** 
@@ -352 +352 @@
  * all structures associated with the <dirp> pointer.
  ******************************************************************************************
- * @ dirp     : user pointer identifying the directory.
+ * @ dirp     : [in] user pointer on dirent array identifying the open directory.
  * @ return 0 if success / returns -1 if failure.
  *****************************************************************************************/
@@ -575 +575 @@
  * [43] This debug function displays on the kernel terminal TXT0 an user defined string,
  * or the current state of a kernel structure, identified by the <type> argument.
- * The <arg0> and <arg1> arguments depends on the structure type:
+ * The <arg0>, <arg1>, and <arg2> arguments depends on the structure type:
  * - DISPLAY_STRING          : an user defined string
  * - DISPLAY_VMM             : VSL and GPT for a process identified by <pid>.
@@ -583 +583 @@
  * - DISPLAY_VFS             : all files registered in the VFS cache. 
  * - DISPLAY_CHDEV           : all registered channel devices.
- * - DISPLAY_DQDT            : all DQDT nodes.
+ * - DISPLAY_DQDT            : all DQDT nodes curren values.
+ * - DISPLAY_BUSYLOCKS       : all busylocks taken by one thread.
+ * - DISPLAY_MAPPER          : one page of a given mapper.
  ******************************************************************************************
  * type      : [in] type of display 
  * arg0      : [in] type dependant argument.
  * arg1      : [in] type dependant argument.
+ * arg2      : [in] type dependant argument.
  * @ return 0 if success / return -1 if illegal arguments
  *****************************************************************************************/
 int sys_display( reg_t  type,
                  reg_t  arg0,
-                 reg_t  arg1 );
+                 reg_t  arg1,
+                 reg_t  arg2 );
 
 /******************************************************************************************