Changeset 614 for trunk

Timestamp:

Jan 15, 2019, 1:59:32 PM (6 years ago)

Author:

alain

Message:

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

to improve the DEVFS synchronous update.

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

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

Location:

trunk/kernel

Files:

• devices/dev_ioc.c (modified) (6 diffs)
• devices/dev_ioc.h (modified) (8 diffs)
• fs/devfs.c (modified) (14 diffs)
• fs/fatfs.c (modified) (21 diffs)
• fs/fatfs.h (modified) (3 diffs)
• fs/vfs.c (modified) (4 diffs)
• fs/vfs.h (modified) (5 diffs)
• kern/kernel_init.c (modified) (3 diffs)
• kern/rpc.c (modified) (11 diffs)
• kern/rpc.h (modified) (2 diffs)
• kern/scheduler.c (modified) (1 diff)
• kernel_config.h (modified) (8 diffs)
• libk/user_dir.c (modified) (15 diffs)
• libk/user_dir.h (modified) (2 diffs)
• libk/xhtab.c (modified) (3 diffs)
• libk/xhtab.h (modified) (1 diff)
• mm/mapper.c (modified) (6 diffs)
• mm/mapper.h (modified) (5 diffs)
• mm/vmm.c (modified) (12 diffs)
• mm/vmm.h (modified) (1 diff)
• syscalls/sys_closedir.c (modified) (1 diff)
• syscalls/sys_display.c (modified) (1 diff)
• syscalls/sys_opendir.c (modified) (2 diffs)

trunk/kernel/devices/dev_ioc.c

@@ -91 +91 @@
 // This static function is called by dev_ioc_read() & dev_ioc_write() functions.
 // It builds and registers the command in the calling thread descriptor.
-// Then, it registers the calling thead in IOCchdev waiting queue.
+// Then, it registers the calling thead in IOC chdev waiting queue.
 // Finally it blocks on the THREAD_BLOCKED_IO condition and deschedule.
 ////////////////////////////////////i/////////////////////////////////////////////
@@ -108 +108 @@
     if( chdev_dir.iob )
     {
-        if ( cmd_type == IOC_READ ) dev_mmc_inval( XPTR( local_cxy , buffer ) , count<<9 );
-        else                        dev_mmc_sync ( XPTR( local_cxy , buffer ) , count<<9 );
+        if (cmd_type == IOC_READ) dev_mmc_inval( XPTR( local_cxy , buffer ) , count<<9 );
+        else                      dev_mmc_sync ( XPTR( local_cxy , buffer ) , count<<9 );
     }
 
@@ -162 +162 @@
 
     return dev_ioc_access( IOC_READ , buffer , lba , count );
-
-#if DEBUG_DEV_IOC_RX
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_DEV_IOC_RX < cycle )
-printk("\n[%s] thread[%x,%x] exit / lba  %x / buffer %x / cycle %d\n",
-__FUNCTION__ , this->process->pid, this->trdid, lba, buffer, cycle );
-#endif
-
 }
 
@@ -187 +179 @@
 
     return dev_ioc_access( IOC_WRITE , buffer , lba , count );
-
-#if DEBUG_DEV_IOC_TX
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_DEV_IOC_TX < cycle )
-printk("\n[%s] thread[%x,%x] exit / lba  %x / buffer %x / cycle %d\n",
-__FUNCTION__ , this->process->pid, this->trdid, lba, buffer, cycle );
-#endif
-
 }
+
+
+
+
+
+//////////////////////////////////////////////////////////////////////////////////
+// This static function is called by dev_ioc_sync_read() & dev_ioc_sync_write().
+// It builds and registers the command in the calling thread descriptor, and
+// calls directly the blocking IOC driver command, that returns only when the
+// IO operation is completed.
+////////////////////////////////////i/////////////////////////////////////////////
+error_t dev_ioc_sync_access( uint32_t   cmd_type,
+                             uint8_t  * buffer,
+                             uint32_t   lba,
+                             uint32_t   count )
+{
+    // get pointer on calling thread
+    thread_t * this = CURRENT_THREAD;
+
+    // software L2/L3 cache coherence for memory buffer
+    if( chdev_dir.iob )
+    {
+        if (cmd_type == IOC_SYNC_READ) dev_mmc_inval( XPTR(local_cxy,buffer) , count<<9 );
+        else                           dev_mmc_sync ( XPTR(local_cxy,buffer) , count<<9 );
+    }
+
+    // get extended pointer on IOC[0] chdev
+    xptr_t  ioc_xp = chdev_dir.ioc[0];
+
+// check ioc_xp
+assert( (ioc_xp != XPTR_NULL) , "undefined IOC chdev descriptor" );
+
+    // register command in calling thread descriptor
+    this->ioc_cmd.dev_xp    = ioc_xp;
+    this->ioc_cmd.type      = cmd_type;
+    this->ioc_cmd.buf_xp    = XPTR( local_cxy , buffer );
+    this->ioc_cmd.lba       = lba;
+    this->ioc_cmd.count     = count;
+
+    // get driver command function
+    cxy_t       ioc_cxy = GET_CXY( ioc_xp );
+    chdev_t   * ioc_ptr = GET_PTR( ioc_xp );
+    dev_cmd_t * cmd = (dev_cmd_t *)hal_remote_lpt( XPTR( ioc_cxy , &ioc_ptr->cmd ) );
+
+    // get core local index for the core handling the IOC IRQ
+    thread_t * server = (thread_t *)hal_remote_lpt( XPTR( ioc_cxy , &ioc_ptr->server ) );
+    core_t   * core   = (core_t *)hal_remote_lpt( XPTR( ioc_cxy , &server->core ) );
+    lid_t      lid    = (lid_t)hal_remote_l32( XPTR( ioc_cxy , &core->lid ) );
+
+    // mask the IRQ
+    dev_pic_disable_irq( lid , ioc_xp );
+
+    // call driver function
+    cmd( XPTR( local_cxy , this ) );
+
+    // unmask the IRQ
+    dev_pic_enable_irq( lid , ioc_xp );
+
+    // return I/O operation status from calling thread descriptor
+    return this->ioc_cmd.error;
+
+}  // end ioc_sync_access()
 
 /////////////////////////////////////////////
@@ -202 +248 @@
                            uint32_t   count )
 {
-    // get pointer on calling thread
-    thread_t * this = CURRENT_THREAD;
 
 #if DEBUG_DEV_IOC_RX
-uint32_t cycle = (uint32_t)hal_get_cycles();
+thread_t * this  = CURRENT_THREAD;
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEV_IOC_RX < cycle )
+printk("\n[%s] thread[%x,%x] : lba  %x / buffer %x / cycle %d\n",
+__FUNCTION__ , this->process->pid, this->trdid, lba, buffer, cycle );
+#endif
+
+    return dev_ioc_sync_access( IOC_SYNC_READ , buffer , lba , count );
+} 
+
+//////////////////////////////////////////////
+error_t dev_ioc_sync_write( uint8_t  * buffer,
+                            uint32_t   lba,
+                            uint32_t   count )
+{
+
+#if DEBUG_DEV_IOC_RX
+thread_t * this  = CURRENT_THREAD;
+uint32_t   cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_DEV_IOC_RX < cycle )
 printk("\n[%s] thread[%x,%x] enters / lba  %x / buffer %x / cycle %d\n",
@@ -212 +274 @@
 #endif
 
-    // software L2/L3 cache coherence for memory buffer
-    if( chdev_dir.iob ) dev_mmc_inval( XPTR( local_cxy , buffer ) , count<<9 );
-
-    // get extended pointer on IOC[0] chdev
-    xptr_t  ioc_xp = chdev_dir.ioc[0];
-
-    assert( (ioc_xp != XPTR_NULL) , "undefined IOC chdev descriptor" );
-
-    // register command in calling thread descriptor
-    this->ioc_cmd.dev_xp    = ioc_xp;
-    this->ioc_cmd.type      = IOC_SYNC_READ;
-    this->ioc_cmd.buf_xp    = XPTR( local_cxy , buffer );
-    this->ioc_cmd.lba       = lba;
-    this->ioc_cmd.count     = count;
-
-    // get driver command function
-    cxy_t       ioc_cxy = GET_CXY( ioc_xp );
-    chdev_t   * ioc_ptr = (chdev_t *)GET_PTR( ioc_xp );
-    dev_cmd_t * cmd = (dev_cmd_t *)hal_remote_lpt( XPTR( ioc_cxy , &ioc_ptr->cmd ) );
-
-    // get core local index for the core handling the IOC IRQ
-    thread_t * server = (thread_t *)hal_remote_lpt( XPTR( ioc_cxy , &ioc_ptr->server ) );
-    core_t   * core   = (core_t *)hal_remote_lpt( XPTR( ioc_cxy , &server->core ) );
-    lid_t      lid    = (lid_t)hal_remote_l32( XPTR( ioc_cxy , &core->lid ) );
-
-    // mask the IRQ
-    dev_pic_disable_irq( lid , ioc_xp );
-
-    // call driver function
-    cmd( XPTR( local_cxy , this ) );
-
-    // unmask the IRQ
-    dev_pic_enable_irq( lid , ioc_xp );
-
-#if DEBUG_DEV_IOC_RX
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_DEV_IOC_RX < cycle )
-printk("\n[%s] thread[%x,%x] exit / lba  %x / buffer %x / cycle %d\n",
-__FUNCTION__ , this->process->pid, this->trdid, lba, buffer, cycle );
-#endif
-
-    // return I/O operation status from calling thread descriptor
-    return this->ioc_cmd.error;
-
-}  // end ioc_sync_read()
-
+    return dev_ioc_sync_access( IOC_SYNC_WRITE , buffer , lba , count );
+} 
+

trunk/kernel/devices/dev_ioc.h

@@ -38 +38 @@
  * magnetic hard disk or a SD card, that can store blocks of data in a linear array
  * of sectors indexed by a simple lba (logic block address).
- * It supports three command types:
- * - READ      : move blocks from device to memory, with a descheduling policy.
- * - WRITE     : move blocks from memory to device, with a descheduling policy.
- * - SYNC_READ : move blocks from device to memory, with a busy waiting policy.
+ * It supports four command types:
+ * - READ       : move blocks from device to memory, with a descheduling policy.
+ * - WRITE      : move blocks from memory to device, with a descheduling policy.
+ * - SYNC_READ  : move blocks from device to memory, with a busy waiting policy.
+ * - SYNC_WRITE : move blocks from memory to device, with a busy waiting policy.
 
  * A READ or WRITE operation requires dynamic ressource allocation. The calling thread
@@ -64 +65 @@
  *    3) release the WTI mailbox to the client cluster WTI allocator.
  *
- * The SYNC_READ operation is used by the kernel in the initialisation phase. It does
- * not uses the IOC device waiting queue and server thread, and does not use the IOC IRQ,
- * but implement a busy-waiting policy for the calling thread.
+ * The SYNC_READ and SYNC_WRITE operations are used by the kernel in the initialisation
+ * phase. These operations do not not use the IOC device waiting queue, the server thread,
+ * and the IOC IRQ, but implement a busy-waiting policy for the calling thread.
  *****************************************************************************************/
 
@@ -85 +86 @@
  *****************************************************************************************/
 
-enum ioc_impl_e
+typedef enum
 {
     IMPL_IOC_BDV =   0,     
@@ -99 +100 @@
  *****************************************************************************************/
 
-enum
+typedef enum
 {
     IOC_READ       = 0,
     IOC_WRITE      = 1,
     IOC_SYNC_READ  = 2,
-};
+    IOC_SYNC_WRITE = 3,
+}
+cmd_type_t;
 
 typedef struct ioc_command_s
@@ -131 +134 @@
 
 /******************************************************************************************
- * This blocking function try to tranfer one or several contiguous blocks of data
+ * This blocking function moves one or several contiguous blocks of data
  * from the block device to a local memory buffer. The corresponding request is actually
  * registered in the device pending request queue, and the calling thread is descheduled,
@@ -147 +150 @@
 
 /******************************************************************************************
- * This blocking function try to tranfer one or several contiguous blocks of data
+ * This blocking function moves one or several contiguous blocks of data
  * from a local memory buffer to the block device. The corresponding request is actually
  * registered in the device pending request queue, and the calling thread is descheduled,
@@ -163 +166 @@
 
 /******************************************************************************************
- * This blocking function try to tranfer one or several contiguous blocks of data
- * from the block device to a memory buffer.
+ * This blocking function moves one or several contiguous blocks of data
+ * from the block device to a local memory buffer.
  * It does  not uses the IOC device waiting queue and server thread, and does not use 
  * the IOC IRQ, but call directly the relevant IOC driver, implementing a busy-waiting
@@ -179 +182 @@
                            uint32_t       count );
 
+/******************************************************************************************
+ * This blocking function moves one or several contiguous blocks of data
+ * from a local memory buffer to the block device.
+ * It does  not uses the IOC device waiting queue and server thread, and does not use 
+ * the IOC IRQ, but call directly the relevant IOC driver, implementing a busy-waiting
+ * policy for the calling thread.
+ * It must be called in the client cluster.
+ ******************************************************************************************
+ * @ buffer    : local pointer on source buffer in memory (must be block aligned).
+ * @ lba       : first block index on device.
+ * @ count     : number of blocks to transfer.
+ * @ returns 0 if success / returns EINVAL if error.
+ *****************************************************************************************/
+error_t dev_ioc_sync_write( uint8_t      * buffer,
+                            uint32_t       lba,
+                            uint32_t       count );
+
 #endif  /* _DEV_IOC_H */

trunk/kernel/fs/devfs.c

@@ -110 +110 @@
 assert( (error == 0) , "cannot create <dev>\n" );
 
-#if DEBUG_DEVFS_INIT
+#if DEBUG_DEVFS_GLOBAL_INIT
 uint32_t   cycle = (uint32_t)hal_get_cycles();
 thread_t * this  = CURRENT_THREAD;
-if( DEBUG_DEVFS_INIT < cycle )
+if( DEBUG_DEVFS_GLOBAL_INIT < cycle )
 printk("\n[%s] thread[%x,%x] created <dev> inode / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, cycle );
@@ -134 +134 @@
 assert( (error == 0) , "cannot create <external>\n" );
 
-#if DEBUG_DEVFS_INIT
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_DEVFS_INIT < cycle )
+#if DEBUG_DEVFS_GLOBAL_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEVFS_GLOBAL_INIT < cycle )
 printk("\n[%s] thread[%x,%x] created <external> inode / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, cycle );
@@ -159 +159 @@
     error_t       error;
 
+#if DEBUG_DEVFS_LOCAL_INIT 
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+thread_t * this  = CURRENT_THREAD;
+if( DEBUG_DEVFS_LOCAL_INIT < cycle )
+printk("\n[%s] thread[%x,%x] enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, cycle );
+#endif
+
     // create "internal" directory 
     snprintf( node_name , 16 , "internal_%x" , local_cxy );
@@ -177 +185 @@
 assert( (error == 0) , "cannot create <external>\n" );
 
-#if DEBUG_DEVFS_INIT 
-uint32_t   cycle = (uint32_t)hal_get_cycles();
-thread_t * this  = CURRENT_THREAD;
-if( DEBUG_DEVFS_INIT < cycle )
+#if DEBUG_DEVFS_LOCAL_INIT 
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEVFS_LOCAL_INIT < cycle )
 printk("\n[%s] thread[%x,%x] created <%s> inode in cluster %x / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, node_name, local_cxy, cycle );
@@ -209 +216 @@
         hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
         
-#if DEBUG_DEVFS_INIT
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_DEVFS_INIT < cycle )
+#if DEBUG_DEVFS_LOCAL_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEVFS_LOCAL_INIT < cycle )
 printk("\n[%s] thread[%x,%x] created <mmc> inode in cluster %x\n",
 __FUNCTION__, this->process->pid, this->trdid, local_cxy, cycle );
@@ -244 +251 @@
             hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
         
-#if DEBUG_DEVFS_INIT
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_DEVFS_INIT < cycle )
+#if DEBUG_DEVFS_LOCAL_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEVFS_LOCAL_INIT < cycle )
 printk("\n[%s] thread [%x,%x] created <dma[%d]> inode in cluster %x\n",
 __FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
@@ -277 +284 @@
             hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
         
-#if DEBUG_DEVFS_INIT
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_DEVFS_INIT < cycle )
+#if DEBUG_DEVFS_LOCAL_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEVFS_LOCAL_INIT < cycle )
 printk("\n[%s] thread[%x,%x] created <iob> inode in cluster %x\n",
 __FUNCTION__, this->process->pid, this->trdid, local_cxy, cycle );
@@ -310 +317 @@
             hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
         
-#if DEBUG_DEVFS_INIT
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_DEVFS_INIT < cycle )
+#if DEBUG_DEVFS_LOCAL_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEVFS_LOCAL_INIT < cycle )
 printk("\n[%s] thread[%x,%x] created <pic> inode in cluster %x\n",
 __FUNCTION__, this->process->pid, this->trdid, local_cxy, cycle );
@@ -345 +352 @@
                 hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
         
-#if DEBUG_DEVFS_INIT
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_DEVFS_INIT < cycle )
+#if DEBUG_DEVFS_LOCAL_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEVFS_LOCAL_INIT < cycle )
 printk("\n[%s] thread[%x,%x] created <txt_rx[%d]> inode in cluster %x\n",
 __FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
@@ -381 +388 @@
                 hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
         
-#if DEBUG_DEVFS_INIT 
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_DEVFS_INIT < cycle )
+#if DEBUG_DEVFS_LOCAL_INIT 
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEVFS_LOCAL_INIT < cycle )
 printk("\n[%s] thread[%x,%x] created <txt_tx[%d]> inode in cluster %x\n",
 __FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
@@ -417 +424 @@
                 hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
         
-#if DEBUG_DEVFS_INIT
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_DEVFS_INIT < cycle )
+#if DEBUG_DEVFS_LOCAL_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEVFS_LOCAL_INIT < cycle )
 printk("\n[%s] thread[%x,%x] created <ioc[%d]> inode in cluster %x\n",
 __FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
@@ -453 +460 @@
                 hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
         
-#if DEBUG_DEVFS_INIT
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_DEVFS_INIT < cycle )
+#if DEBUG_DEVFS_LOCAL_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEVFS_LOCAL_INIT < cycle )
 printk("\n[%s] thread[%x,%x] created <fbf[%d]> inode in cluster %x\n",
 __FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
@@ -489 +496 @@
                 hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
  
-#if DEBUG_DEVFS_INIT
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_DEVFS_INIT < cycle )
+#if DEBUG_DEVFS_LOCAL_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEVFS_LOCAL_INIT < cycle )
 printk("\n[%s] thread[%x,%x] created <nic_rx[%d]> inode in cluster %x\n",
 __FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
@@ -525 +532 @@
                 hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
         
-#if DEBUG_DEVFS_INIT
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_DEVFS_INIT < cycle )
+#if DEBUG_DEVFS_LOCAL_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEVFS_LOCAL_INIT < cycle )
 printk("\n[%s] thread[%x,%x] created <nic_tx[%d]> inode in cluster %x\n",
 __FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );

trunk/kernel/fs/fatfs.c

@@ -1064 +1064 @@
         {
             // copy the modified page to IOC device
-            fatfs_move_page( page_xp , false );   
+            fatfs_move_page( page_xp , IOC_SYNC_WRITE );   
 
             // get the next page in FAT mapper
@@ -1217 +1217 @@
 
     // copy the modified page to the IOC device
-    fatfs_move_page( page_xp , false );   
+    fatfs_move_page( page_xp , IOC_SYNC_WRITE );   
 
 #if DEBUG_FATFS_ADD_DENTRY
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_FATFS_ADD_DENTRY < cycle )
-printk("\n[%s]  thread[%x,%x] exit / parent %s / child %s / cycle %d\n",
+printk("\n[%s]  thread[%x,%x] exit / parent <%s> / child <%s> / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, dir_name, dentry->name, cycle );
 #endif
@@ -1313 +1313 @@
 
             // copy the modified page to the IOC device
-            fatfs_move_page( page_xp , false );   
+            fatfs_move_page( page_xp , IOC_SYNC_WRITE );   
 
             // get extended pointer on page descriptor from parent directory mapper
@@ -1345 +1345 @@
 
     // copy the modified page to the IOC device
-    fatfs_move_page( page_xp , false );   
+    fatfs_move_page( page_xp , IOC_SYNC_WRITE );   
     
 
@@ -1396 +1396 @@
     xptr_t     base_xp;          // extended pointer on page base
     uint8_t  * base;             // local pointer on page base
-    uint32_t   attr;             // directory entry ATTR field
-    uint32_t   ord;              // directory entry ORD field
+    uint8_t    attr;             // directory entry ATTR field
+    uint8_t    ord;              // directory entry ORD field
     uint32_t   seq;              // sequence index
     uint32_t   lfn       = 0;    // LFN entries number
@@ -1422 +1422 @@
 #if (DEBUG_FATFS_GET_DENTRY & 0x1)
 if( DEBUG_FATFS_GET_DENTRY < cycle )
-mapper_display_page( mapper_xp , page_id , 256 , parent_name );
+mapper_display_page( mapper_xp , page_id , 256 );
 #endif
         // scan this page until end of directory, end of page, or name found
@@ -1435 +1435 @@
             }
             else if ( ord == FREE_ENTRY )             // free entry => skip
+            {
+                offset = offset + 32;
+            }
+            else if ( attr == 0x28 )                  // volune_id => skip
             {
                 offset = offset + 32;
@@ -1577 +1581 @@
 assert( (detailed == false), "detailed argument not supported/n");
 
-    char       cname[CONFIG_VFS_MAX_NAME_LENGTH];  // name extracter from each directory entry
+    char       cname[CONFIG_VFS_MAX_NAME_LENGTH];  // name extracted from each dentry
 
     char       lfn1[16];           // buffer for one partial cname
@@ -1585 +1589 @@
     xptr_t     base_xp;            // extended pointer on page base
     uint8_t  * base;               // local pointer on page base
-    uint32_t   attr;               // directory entry ATTR field
-    uint32_t   ord;                // directory entry ORD field
+    uint8_t    attr;               // directory entry ATTR field
+    uint8_t    ord;                // directory entry ORD field
     uint32_t   seq;                // sequence index
     uint32_t   lfn       = 0;      // LFN entries number
@@ -1609 +1613 @@
 #if (DEBUG_FATFS_GET_USER_DIR & 0x1)
 if( DEBUG_FATFS_GET_USER_DIR < cycle )
-mapper_display_page( mapper_xp , page_id , 256 , inode_name );
+mapper_display_page( mapper_xp , page_id , 256 );
 #endif 
         // loop on NORMAL/LFN (32 bytes) directory entries in this page
@@ -1625 +1629 @@
             }
             else if ( ord == FREE_ENTRY )             // free entry => skip
+            {
+                offset = offset + 32;
+            }
+            else if ( attr == 0x28 )                  // volune_id => skip
             {
                 offset = offset + 32;
@@ -1693 +1701 @@
 if( DEBUG_FATFS_GET_USER_DIR < cycle )
 printk("\n[%s]  thread[%x,%x] exit for inode <%s> / %d entries / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, inode_name, entries, cycle );
+__FUNCTION__, this->process->pid, this->trdid, inode_name, dirent_id, cycle );
 #endif
 
@@ -1756 +1764 @@
 
                 // move page from mapper to device
-                error = fatfs_move_page( page_xp , false );
+                error = fatfs_move_page( page_xp , IOC_WRITE );
 
                 if ( error )  return -1;
@@ -1827 +1835 @@
 #endif
                 // move page from mapper to device
-                error = fatfs_move_page( page_xp , false );
+                error = fatfs_move_page( page_xp , IOC_SYNC_WRITE );
 
                 if ( error )  return -1;
@@ -2132 +2140 @@
 }  // end fatfs_release_inode()
 
-/////////////////////////////////////////
-error_t fatfs_move_page( xptr_t  page_xp,
-                         bool_t  to_mapper )
+////////////////////////////////////////////
+error_t fatfs_move_page( xptr_t     page_xp,
+                         cmd_type_t cmd_type )
 {
     error_t       error;
@@ -2172 +2180 @@
  
         // access device
-        if( to_mapper ) error = dev_ioc_sync_read ( buffer , lba , 8 );
-        else            error = dev_ioc_write( buffer , lba , 8 );     
+        if     ( cmd_type == IOC_SYNC_READ  ) error = dev_ioc_sync_read ( buffer , lba , 8 );
+        else if( cmd_type == IOC_SYNC_WRITE ) error = dev_ioc_sync_write( buffer , lba , 8 );
+        else if( cmd_type == IOC_READ       ) error = dev_ioc_read      ( buffer , lba , 8 );
+        else if( cmd_type == IOC_WRITE      ) error = dev_ioc_write     ( buffer , lba , 8 );
+        else                                  error = -1;
 
         if( error ) return EIO;
@@ -2179 +2190 @@
 #if (DEBUG_FATFS_MOVE_PAGE & 0x1)
 if( DEBUG_FATFS_MOVE_PAGE < cycle )
-mapper_display_page( XPTR(page_cxy , mapper_ptr) , page_id , "FAT" );
+mapper_display_page( XPTR(page_cxy , mapper_ptr) , page_id );
 #endif
 
@@ -2186 +2197 @@
 if( DEBUG_FATFS_MOVE_PAGE < cycle )
 {
-    if (to_mapper)
+    if ( (cmd_type == IOC_READ) || (cmd_type == IOC_SYNC_READ) )
          printk("\n[%s] thread[%x,%x] load page %d of FAT / cycle %d\n",
          __FUNCTION__, this->process->pid, this->trdid, page_id, cycle );
@@ -2230 +2241 @@
 
         // access device
-        if( to_mapper ) error = dev_ioc_sync_read ( buffer , lba , 8 );
-        else            error = dev_ioc_write( buffer , lba , 8 );     
+        if     ( cmd_type == IOC_SYNC_READ  ) error = dev_ioc_sync_read ( buffer , lba , 8 );
+        else if( cmd_type == IOC_SYNC_WRITE ) error = dev_ioc_sync_write( buffer , lba , 8 );
+        else if( cmd_type == IOC_READ       ) error = dev_ioc_read      ( buffer , lba , 8 );
+        else if( cmd_type == IOC_WRITE      ) error = dev_ioc_write     ( buffer , lba , 8 );
+        else                                  error = -1;
 
         if( error ) return EIO;
@@ -2237 +2251 @@
 #if (DEBUG_FATFS_MOVE_PAGE & 0x1)
 if( DEBUG_FATFS_MOVE_PAGE < cycle )
-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 );
+mapper_display_page( XPTR(page_cxy , mapper_ptr) , page_id );
 #endif
 
@@ -2246 +2258 @@
 if(DEBUG_FATFS_MOVE_PAGE < cycle)
 {
-    if(to_mapper)
+    if ( (cmd_type == IOC_READ) || (cmd_type == IOC_SYNC_READ) )
         printk("\n[%s] thread[%x,%x] load page %d of <%s> inode / cycle %d\n",
         __FUNCTION__, this->process->pid, this->trdid, page_id, name, cycle );

trunk/kernel/fs/fatfs.h

@@ -29 +29 @@
 #include <remote_queuelock.h>
 #include <vfs.h>
+#include <dev_ioc.h>
 
 
@@ -365 +366 @@
  * and copies from mapper to device each page marked as dirty.
  * WARNING : The target <inode> cannot be a directory, because all modifications in a 
- * directory * are synchronously done on the IOC device by the two fatfs_add_dentry() 
+ * directory are synchronously done on the IOC device by the two fatfs_add_dentry() 
  * and fatfs_remove_dentry() functions.
  *****************************************************************************************
@@ -451 +452 @@
  *****************************************************************************************
  * @ page_xp   : extended pointer on page descriptor.
- * @ to_mapper : true for device->mapper / false for mapper->device
+ * @ cmd_type  : IOC_READ / IOC_WRITE / IOC_SYNC_READ / IOC_SYNC_WRITE
  * @ return 0 if success / return EIO if error during device access. 
  ****************************************************************************************/
-error_t fatfs_move_page( xptr_t  page_xp,
-                         bool_t  to_mapper );
+error_t fatfs_move_page( xptr_t      page_xp,
+                         cmd_type_t  cmd_type );
 
 

trunk/kernel/fs/vfs.c

@@ -424 +424 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_VFS_DENTRY_CREATE < cycle )
-printk("\n[%s] thread[%x,%x] enter for <%s> / parent_inode %x / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, name, parent, cycle );
+printk("\n[%s] thread[%x,%x] enter for <%s> / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, name, cycle );
 #endif
 
@@ -1946 +1946 @@
 
     // display inode
-    nolock_printk("%s%s <%s> : inum %d / %d bytes / dirty %d / cxy %x (inode %x / mapper %x)\n",
-                  indent_str[indent], vfs_inode_type_str( inode_type ), name,
+    nolock_printk("%s<%s> : %s / inum %d / %d bytes / dirty %d / cxy %x / inode %x / mapper %x\n",
+                  indent_str[indent], name, vfs_inode_type_str( inode_type ),
                   inode_inum, inode_size, inode_dirty, inode_cxy, inode_ptr, mapper_ptr );
 
@@ -3191 +3191 @@
 //////////////////////////////////////////////////////////////////////////////////////////
 
-///////////////////////////////////////////
-error_t vfs_fs_move_page( xptr_t   page_xp,
-                          bool_t   to_mapper )
+//////////////////////////////////////////////
+error_t vfs_fs_move_page( xptr_t      page_xp,
+                          cmd_type_t  cmd_type )
 {
     error_t error = 0;
@@ -3213 +3213 @@
     if( fs_type == FS_TYPE_FATFS )
     {
-        error = fatfs_move_page( page_xp , to_mapper ); 
+        error = fatfs_move_page( page_xp , cmd_type ); 
     }
     else if( fs_type == FS_TYPE_RAMFS )

trunk/kernel/fs/vfs.h

@@ -41 +41 @@
 #include <ramfs.h>
 #include <devfs.h>
+#include <dev_ioc.h>
 
 /****  Forward declarations  ***/
@@ -408 +409 @@
  * It must called by a local thread. Use the RPC_DENTRY_CREATE if client thread is remote.
  ******************************************************************************************
- * @ fs_type    : file system type.
- * @ name       : directory entry file/dir name.
+ * @ fs_type    : [in]  file system type.
+ * @ name       : [in]  directory entry file/dir name.
  * @ dentry_xp  : [out] buffer for extended pointer on created dentry.
  * @ return 0 if success / return ENOMEM or EINVAL if error.
@@ -421 +422 @@
  * allocated to the dentry descriptor.
  * It must be executed by a thread running in the cluster containing the dentry.
- * Use the rpc_vfs_dentry_destroy_client() function if required.
+ * Use the RPC_DENTRY_DESTROY if required.
  ****************************************************************************************** 
- * @ dentry  : local pointer on dentry descriptor.
+ * @ dentry  : [in] local pointer on dentry descriptor.
  *****************************************************************************************/
 void vfs_dentry_destroy( vfs_dentry_t *  dentry );  
@@ -875 +876 @@
 
 /******************************************************************************************
+ * This function makes the I/O operation to move one page identified by the <page_xp>
+ * argument to/from the IOC device from/to the mapper, as defined by <cmd_type>.
+ * Depending on the file system type, it calls the proper, FS specific function.
+ * It is used in case of MISS on the mapper, or when a dirty page in the mapper must
+ * be updated in the File System.
+ * The mapper pointer is obtained from the page descriptor.
+ * It can be executed by any thread running in any cluster.
+ * This function does NOT take any lock.
+ ******************************************************************************************
+ * @ page_xp   : extended pointer on page descriptor (for mapper and page_id).
+ * @ cmd_type  : IOC_READ / IOC_WRITE / IOC_SYNC_READ / IOC_SYNC_WRITE
+ * @ returns 0 if success / return -1 if device access failure.
+ *****************************************************************************************/
+error_t vfs_fs_move_page( xptr_t      page_xp,
+                          cmd_type_t  cmd_type );
+
+/******************************************************************************************
  * This function updates the mapper associated to a directory inode identified by the 
  * <parent> argument, to add a new entry identified by the <dentry> argument. 
@@ -1032 +1050 @@
 error_t vfs_fs_release_inode( xptr_t  inode_xp ); 
 
-/******************************************************************************************
- * This function makes the I/O operation to move one page identified by the <page_xp>
- * argument to/from the IOC device from/to the mapper, as defined by <to_mapper>.
- * Depending on the file system type, it calls the proper, FS specific function.
- * It is used in case of MISS on the mapper, or when a dirty page in the mapper must
- * be updated in the File System.
- * The mapper pointer is obtained from the page descriptor.
- * It can be executed by any thread running in any cluster.
- * This function does NOT take any lock.
- ******************************************************************************************
- * @ page_xp   : extended pointer on the page descriptor.
- * @ to_mapper : transfer direction.
- * @ returns 0 if success / return -1 if device access failure.
- *****************************************************************************************/
-error_t vfs_fs_move_page( xptr_t  page_xp,
-                          bool_t  to_mapper );
-
 
 #endif  /* _VFS_H_ */

trunk/kernel/kern/kernel_init.c

@@ -1113 +1113 @@
         vfs_root_inode_xp = XPTR_NULL;
 
-        // File System must be FATFS in this implementation,
-        // but other File System can be introduced here
+        // Only FATFS is supported yet,
+        // other File System can be introduced here
         if( CONFIG_VFS_ROOT_IS_FATFS )
         {
@@ -1172 +1172 @@
         }
 
+        // create the <.> and <..> dentries in VFS root directory
+        // the VFS root parent inode is the VFS root inode itself 
+        vfs_add_special_dentries( vfs_root_inode_xp,
+                                  vfs_root_inode_xp );
+
         // register VFS root inode in process_zero descriptor of cluster 0
         process_zero.vfs_root_xp = vfs_root_inode_xp;
@@ -1255 +1260 @@
 #if DEBUG_KERNEL_INIT
 if( (core_lid ==  0) & (local_cxy == 1) ) 
-printk("\n[%s] : exit barrier 4 : VFS root (%x,%x) in cluster 1 / cycle %d\n",
+printk("\n[%s] : exit barrier 5 : VFS root (%x,%x) in cluster 1 / cycle %d\n",
 __FUNCTION__, GET_CXY(process_zero.vfs_root_xp),
 GET_PTR(process_zero.vfs_root_xp), (uint32_t)hal_get_cycles() );

trunk/kernel/kern/rpc.c

@@ -54 +54 @@
     &rpc_undefined,                        // 2    unused slot
     &rpc_process_make_fork_server,         // 3
-    &rpc_undefined,                        // 4    unused slot
-    &rpc_undefined,                        // 5    unused slot
+    &rpc_user_dir_create_server,           // 4
+    &rpc_user_dir_destroy_server,          // 5
     &rpc_thread_user_create_server,        // 6
     &rpc_thread_kernel_create_server,      // 7
@@ -90 +90 @@
     "undefined",                 // 2
     "PROCESS_MAKE_FORK",         // 3
-    "undefined",                 // 4
-    "undefined",                 // 5
+    "USER_DIR_CREATE",           // 4
+    "USER_DIR_DESTROY",          // 5
     "THREAD_USER_CREATE",        // 6
     "THREAD_KERNEL_CREATE",      // 7
@@ -657 +657 @@
 void rpc_user_dir_create_client( cxy_t          cxy,
                                  vfs_inode_t *  inode,
+                                 xptr_t         ref_xp,
                                  user_dir_t  ** dir )
 {
@@ -677 +678 @@
     // set input arguments in RPC descriptor 
     rpc.args[0] = (uint64_t)(intptr_t)inode;
+    rpc.args[1] = (uint64_t)ref_xp;
 
     // register RPC request in remote RPC fifo
@@ -682 +684 @@
 
     // get output argument from RPC descriptor
-    *dir = (user_dir_t *)(intptr_t)rpc.args[1];
+    *dir = (user_dir_t *)(intptr_t)rpc.args[2];
 
 #if DEBUG_RPC_USER_DIR_CREATE
@@ -704 +706 @@
 
     vfs_inode_t * inode;          // pointer on inode in server cluster
+    xptr_t        ref_xp;         // extended pointer on reference user process
     user_dir_t  * dir;            // pointer on user_dir structure in server cluster 
 
@@ -711 +714 @@
 
     // get input argument from RPC descriptor
-    inode = (vfs_inode_t *)(intptr_t)hal_remote_l64(XPTR(client_cxy , &desc->args[0]));
+    inode  = (vfs_inode_t *)(intptr_t)hal_remote_l64(XPTR(client_cxy , &desc->args[0]));
+    ref_xp = (xptr_t)                 hal_remote_l64(XPTR(client_cxy , &desc->args[1]));
 
     // call kernel function
-    dir = user_dir_create( inode );
+    dir = user_dir_create( inode , ref_xp );
 
     // set output argument into RPC descriptor
-    hal_remote_s64( XPTR( client_cxy , &desc->args[1] ) , (intptr_t)dir );
+    hal_remote_s64( XPTR( client_cxy , &desc->args[2] ) , (intptr_t)dir );
 
 #if DEBUG_RPC_USER_DIR_CREATE
@@ -733 +737 @@
 ////////////////////////////////////////////////////
 void rpc_user_dir_destroy_client( cxy_t         cxy,
-                                  user_dir_t  * dir )
+                                  user_dir_t  * dir,
+                                  xptr_t        ref_xp )
 {
 #if DEBUG_RPC_USER_DIR_DESTROY
@@ -753 +758 @@
     // set input arguments in RPC descriptor 
     rpc.args[0] = (uint64_t)(intptr_t)dir;
+    rpc.args[1] = (uint64_t)ref_xp;
 
     // register RPC request in remote RPC fifo
@@ -777 +783 @@
 
     user_dir_t * dir;            // pointer on user_dir structure in server cluster 
+    xptr_t       ref_xp;         // extended pointer on reference process
 
     // get client cluster identifier and pointer on RPC descriptor
@@ -783 +790 @@
 
     // get input argument from RPC descriptor
-    dir = (user_dir_t *)(intptr_t)hal_remote_l64(XPTR(client_cxy , &desc->args[0]));
+    dir    = (user_dir_t *)(intptr_t)hal_remote_l64(XPTR(client_cxy , &desc->args[0]));
+    ref_xp = (xptr_t)                hal_remote_l64(XPTR(client_cxy , &desc->args[1]));
 
     // call kernel function
-    user_dir_destroy( dir );
+    user_dir_destroy( dir , ref_xp );
 
 #if DEBUG_RPC_USER_DIR_DESTROY

trunk/kernel/kern/rpc.h

@@ -229 +229 @@
  * [4] The RPC_USER_DIR_CREATE allows a client thread to create an user_dir_t
  * structure and the associated array of dirents in a remote cluster containing
- * the target directory inode. It is called by the sys_opendir() function.
+ * the target directory <inode>. It creates an ANON vseg in the user reference 
+ * process VMM identified by the <ref_xp>. This reference cluster cluster can be
+ * different from both the client and server clusters.
+ * It is called by the sys_opendir() function.
  ***********************************************************************************
  * @ cxy        : server cluster identifier.
  * @ inode      : [in]   local pointer on inode in server cluster.
+ * @ ref_xp     : [in]   extended pointer on user reference process descriptor.
  * @ dir        : [out]  local pointer on created user_dir structure.
  **********************************************************************************/
 void rpc_user_dir_create_client( cxy_t                 cxy,
                                  struct vfs_inode_s  * inode,
+                                 xptr_t                ref_xp,
                                  struct user_dir_s  ** dir );
 
@@ -248 +253 @@
  * @ cxy        : server cluster identifier.
  * @ dir        : [in]  local pointer on created user_dir structure.
+ * @ ref_xp     : [in]   extended pointer on user reference process descriptor.
  **********************************************************************************/
 void rpc_user_dir_destroy_client( cxy_t               cxy,
-                                  struct user_dir_s * dir );
+                                  struct user_dir_s * dir,
+                                  xptr_t              ref_xp );
 
 void rpc_user_dir_destroy_server( xptr_t xp );

trunk/kernel/kern/scheduler.c

@@ -487 +487 @@
  
 #if (DEBUG_SCHED_YIELD & 0x1)
-if( sched->trace ) sched_display( lid );
+if( sched->trace )
+sched_display( lid );
 #endif
 
-// This assert should never be false, as this check must be
-// done before by any function that can possibly deschedule...
+// This assert should never be false, as this check has been
+// done before, by any function that can possibly deschedule...
 assert( (current->busylocks == 0),
 "unexpected descheduling of thread holding %d busylocks = %d\n", current->busylocks ); 

trunk/kernel/kernel_config.h

@@ -3 +3 @@
  * 
  * Authors  Mohamed Lamine Karaoui (2015)
- *          Alain Greiner (2016,2017,2018)
+ *          Alain Greiner (2016,2017,2018,2019)
  *
  * Copyright (c)  UPMC Sorbonne Universites
@@ -62 +62 @@
 #define DEBUG_DEV_PIC                     0
 
-#define DEBUG_DEVFS_INIT                  1
+#define DEBUG_DEVFS_GLOBAL_INIT           0
+#define DEBUG_DEVFS_LOCAL_INIT            0
 #define DEBUG_DEVFS_MOVE                  0
 
@@ -78 +79 @@
 #define DEBUG_FATFS_FREE_CLUSTERS         0
 #define DEBUG_FATFS_GET_CLUSTER           0
-#define DEBUG_FATFS_GET_DIRENT            1
-#define DEBUG_FATFS_GET_USER_DIR          1
+#define DEBUG_FATFS_GET_DENTRY            0
+#define DEBUG_FATFS_GET_USER_DIR          0
 #define DEBUG_FATFS_MOVE_PAGE             0
 #define DEBUG_FATFS_RELEASE_INODE         0
@@ -212 +213 @@
 #define DEBUG_THREAD_USER_EXEC            0
 
-#define DEBUG_USER_DIR                    1
+#define DEBUG_USER_DIR                    0
 
 #define DEBUG_VFS_ADD_CHILD               0
-#define DEBUG_VFS_ADD_SPECIAL             1
+#define DEBUG_VFS_ADD_SPECIAL             0
 #define DEBUG_VFS_CHDIR                   0
 #define DEBUG_VFS_CLOSE                   0
@@ -229 +230 @@
 #define DEBUG_VFS_NEW_CHILD_INIT          0
 #define DEBUG_VFS_OPEN                    0
+#define DEBUG_VFS_OPENDIR                 0
 #define DEBUG_VFS_STAT                    0
 #define DEBUG_VFS_UNLINK                  0
@@ -241 +243 @@
 #define DEBUG_VMM_HANDLE_COW              0
 #define DEBUG_VMM_INIT                    0
+#define DEBUG_VMM_MMAP_ALLOC              0
 #define DEBUG_VMM_PAGE_ALLOCATE           0
 #define DEBUG_VMM_SET_COW                 0
@@ -356 +359 @@
 #define CONFIG_VFS_ROOT_IS_EX2FS            0          // root FS is EX2FS if non zero
 
+#define CONFIG_MAPPER_GRDXT_W1              7      // number of bits for RADIX_TREE_IX1
+#define CONFIG_MAPPER_GRDXT_W2              7      // number of bits for RADIX_TREE_IX2
+#define CONFIG_MAPPER_GRDXT_W3              6      // number of bits for RADIX_TREE_IX3
+
 ////////////////////////////////////////////////////////////////////////////////////////////
 //                                  DQDT        
@@ -394 +401 @@
 #define CONFIG_REMOTE_FIFO_MAX_ITERATIONS   1024
 #define CONFIG_RPC_THREADS_MAX              4      // max number of RPC threads per core
-
-////////////////////////////////////////////////////////////////////////////////////////////
-//                                  MAPPER
-////////////////////////////////////////////////////////////////////////////////////////////
-
-#define CONFIG_MAPPER_MAX_FRAGMENTS         10     // max number of fragments moved 
-#define CONFIG_MAPPER_MIN                   CONFIG_VFS_INODE_MIN
-#define CONFIG_MAPPER_MAX                   CONFIG_VFS_INODE_MAX
-#define CONFIG_MAPPER_GRDXT_W1              7      // number of bits for RADIX_TREE_IX1
-#define CONFIG_MAPPER_GRDXT_W2              7      // number of bits for RADIX_TREE_IX2
-#define CONFIG_MAPPER_GRDXT_W3              6      // number of bits for RADIX_TREE_IX3
 
 ////////////////////////////////////////////////////////////////////////////////////////////

trunk/kernel/libk/user_dir.c

@@ -80 +80 @@
 }  // end user_dir_from_ident()
 
-///////////////////////////////////////////////////
-user_dir_t * user_dir_create( vfs_inode_t * inode )
+//////////////////////////////////////////////////
+user_dir_t * user_dir_create( vfs_inode_t * inode,
+                              xptr_t        ref_xp )
 { 
     user_dir_t    * dir;               // local pointer on created user_dir_t 
     vseg_t        * vseg;              // local pointer on dirent array vseg
     uint32_t        vseg_size;         // size of vseg in bytes
-    process_t     * process;           // local pointer on calling process
-    xptr_t          ref_xp;            // extended pointer on reference process
     process_t     * ref_ptr;           // local pointer on reference process
     cxy_t           ref_cxy;           // reference process cluster identifier
+    pid_t           ref_pid;           // reference process PID
     xptr_t          gpt_xp;            // extended pointer on reference process GPT
     uint32_t        gpt_attributes;    // attributes for all mapped gpt entries
@@ -109 +109 @@
     error_t         error;
 
-    // get pointer on local process descriptor
-    process = CURRENT_THREAD->process;
+    // get cluster, local pointer, and pid of reference user process
+    ref_cxy = GET_CXY( ref_xp );
+    ref_ptr = GET_PTR( ref_xp );
+    ref_pid = hal_remote_l32( XPTR( ref_cxy , &ref_ptr->pid ) );
 
 #if DEBUG_USER_DIR
@@ -116 +118 @@
 thread_t * this = CURRENT_THREAD;
 if( cycle > DEBUG_USER_DIR )
-printk("\n[%s] thread[%x,%x] enter for inode (%x,%x) / cycle %d\n",
-__FUNCTION__, process->pid, this->trdid, local_cxy, inode, cycle );
+printk("\n[%s] thread[%x,%x] enter for inode (%x,%x) and process %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, local_cxy, inode, ref_pid, cycle );
 #endif
 
@@ -128 +130 @@
     // initialise temporary list of pages
     list_root_init( &root );
-
-    // get pointers on reference process
-    ref_xp  = process->ref_xp;
-    ref_cxy = GET_CXY( ref_xp );
-    ref_ptr = GET_PTR( ref_xp );
 
     // allocate memory for a local user_dir descriptor
@@ -207 +204 @@
     } // end while
         
+#if DEBUG_USER_DIR
+if( cycle > DEBUG_USER_DIR )
+printk("\n[%s] thread[%x,%x] initialised dirent array / %d entries\n",
+__FUNCTION__, this->process->pid, this->trdid, total_dirents, cycle );
+#endif
+
     // compute required vseg size for a 64 bytes dirent
     vseg_size = total_dirents << 6;
@@ -213 +216 @@
     if( local_cxy == ref_cxy )
     {
-        vseg = vmm_create_vseg( process,
+        vseg = vmm_create_vseg( ref_ptr,
                                 VSEG_TYPE_ANON,
                                 0,                      // vseg base (unused)
@@ -220 +223 @@
                                 0,                      // file_size (unused)
                                 XPTR_NULL,              // mapper (unused)
-                                ref_cxy );
+                                local_cxy );
     }
     else
@@ -232 +235 @@
                                     0,                     // file size (unused)
                                     XPTR_NULL,             // mapper (unused)
-                                    ref_cxy,
+                                    local_cxy,
                                     &vseg ); 
     }
+
     if( vseg == NULL )
     {
-        printk("\n[ERROR] in %s : cannot create vseg for DIR in cluster %x\n",
+        printk("\n[ERROR] in %s : cannot create vseg for user_dir in cluster %x\n",
         __FUNCTION__, ref_cxy);
         goto user_dir_create_failure;
     }
 
-#if (DEBUG_USER_DIR & 1)
+#if DEBUG_USER_DIR
 if( cycle > DEBUG_USER_DIR )
 printk("\n[%s] thread[%x,%x] allocated vseg ANON / base %x / size %x\n",
-__FUNCTION__, process->pid, this->trdid, vseg->min, vseg->max - vseg->min );
+__FUNCTION__, this->process->pid, this->trdid, vseg->min, vseg->max - vseg->min );
 #endif
 
@@ -289 +293 @@
             desc.lid       = CURRENT_THREAD->core->lid;
             desc.blocking  = true;
-            desc.args[0]   = process->pid;
+            desc.args[0]   = ref_pid;
             desc.args[1]   = vpn << CONFIG_PPM_PAGE_SHIFT;
             rpc_vmm_delete_vseg_client( ref_cxy , &desc );
@@ -299 +303 @@
         }
 
-#if (DEBUG_USER_DIR & 1)
+#if DEBUG_USER_DIR 
 if( cycle > DEBUG_USER_DIR )
 printk("\n[%s] thread[%x,%x] mapped vpn %x to ppn %x\n",
-__FUNCTION__, process->pid, this->trdid, vpn + page_id, ppn );
+__FUNCTION__, this->process->pid, this->trdid, vpn + page_id, ppn );
 #endif
 
@@ -340 +344 @@
 if( cycle > DEBUG_USER_DIR )
 printk("\n[%s] thread[%x,%x] created user_dir (%x,%x) / %d entries / cycle %d\n",
-__FUNCTION__, process->pid, this->trdid, local_cxy, dir, total_dirents, cycle );
+__FUNCTION__, this->process->pid, this->trdid, local_cxy, dir, total_dirents, cycle );
 #endif
 
@@ -365 +369 @@
 }  // end user_dir_create()
 
-/////////////////////////////////////////
-void user_dir_destroy( user_dir_t * dir )
+////////////////////////////////////////
+void user_dir_destroy( user_dir_t * dir,
+                       xptr_t       ref_xp )
 {
-    process_t    * process;    // local pointer on client process
-    thread_t     * this;       // local pointer on client thread
+    thread_t     * this;       // local pointer on calling thread
+    process_t    * process;    // local pointer on calling process
     cluster_t    * cluster;    // local pointer on local cluster
     intptr_t       ident;      // user pointer on dirent array
-    xptr_t         ref_xp;     // extended pointer on reference process
+    xptr_t         ref_pid;    // reference process PID
     cxy_t          ref_cxy;    // reference process cluster identifier
     process_t    * ref_ptr;    // local pointer on reference process
@@ -379 +384 @@
     xptr_t         iter_xp;    // iteratot in xlist 
     reg_t          save_sr;    // for critical section
-    pid_t          pid;        // process descriptor
     cxy_t          owner_cxy;  // owner process cluster
     lpid_t         lpid;       // process local index
     rpc_desc_t     rpc;        // rpc descriptor
      
-    // get pointers on client process & thread
+    // get pointers on calling process & thread
     this    = CURRENT_THREAD;
     process = this->process;
     cluster = LOCAL_CLUSTER;
 
+    // get cluster, local pointer, and PID of reference user process
+    ref_cxy = GET_CXY( ref_xp );
+    ref_ptr = GET_PTR( ref_xp );
+    ref_pid = hal_remote_l32( XPTR( ref_cxy , &ref_ptr->pid ) );
+
 #if DEBUG_USER_DIR
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_USER_DIR )
-printk("\n[%s] thread[%x,%x] enter for user_dir (%x,%x) / cycle %d\n",
-__FUNCTION__, process->pid, this->trdid, local_cxy, dir, cycle );
+printk("\n[%s] thread[%x,%x] enter for user_dir (%x,%x) and process %x / cycle %d\n",
+__FUNCTION__, process->pid, this->trdid, local_cxy, dir, ref_pid, cycle );
 #endif
 
     // get user pointer on dirent array
     ident = dir->ident;
-
-    // get pointers on reference process
-    ref_xp  = process->ref_xp;
-    ref_cxy = GET_CXY( ref_xp );
-    ref_ptr = GET_PTR( ref_xp );
 
     // build extended pointer on lock protecting open directories list
@@ -424 +428 @@
 
     // get owner cluster identifier and process lpid
-    pid       = process->pid;
-    owner_cxy = CXY_FROM_PID( pid );
-    lpid      = LPID_FROM_PID( pid );
+    owner_cxy = CXY_FROM_PID( ref_pid );
+    lpid      = LPID_FROM_PID( ref_pid );
 
     // get root of list of copies and lock from owner cluster
@@ -444 +447 @@
     rpc.thread    = this;
     rpc.lid       = this->core->lid;
-    rpc.args[0]   = process->pid;
+    rpc.args[0]   = ref_pid;
     rpc.args[1]   = ident;
 

trunk/kernel/libk/user_dir.h

@@ -70 +70 @@
  * in the reference process descriptor.
  *****************************************************************************************
- * @ ident    : DIR virtual address, used as identifier.
+ * @ ident    : [in] DIR virtual address, used as identifier.
  * @ returns extended pointer on user_dir_t if success / returns XPTR_NULL if not found. 
  ****************************************************************************************/
@@ -77 +77 @@
 /*****************************************************************************************
  * This function allocates memory and initializes a user_dir_t structure in the cluster
- * containing the directory inode identified by the <inode> argument. 
+ * containing the directory inode identified by the <inode> argument and map the
+ * user accessible dirent array in the reference user process VMM, identified by the
+ * <ref_xp> argument. 
  * It must be executed by a thread running in the cluster containing the target inode.
  * Use the RPC_USER_DIR_CREATE when the client thread is remote.
  * It makes the following actions:
- * - the allocation of one user_dir_t descriptor in reference cluster.
+ * - the allocation of one user_dir_t descriptor in the directory inode cluster.
  * - the allocation of one or several physical pages in reference cluster to store 
  *   all directory entries in an array of 64 bytes dirent structures,
  * - the initialisation of this array from informations found in the Inode Tree.
- * - the creation of an user accessible vseg containing this dirent array, and the
- *   mapping of all relevant physical pages in this vseg. 
+ * - the creation of an ANON vseg containing this dirent array in reference process VMM,
+ *   and the mapping of the relevant physical pages in this vseg. 
  * - the registration of the created user_dir_t structure in the xlist rooted 
  *   in the reference process,
  * It returns a local pointer on the created user_dir_t structure.
  *****************************************************************************************
- * @ inode    : local pointer on the directory inode.
+ * @ inode    : [in] local pointer on the directory inode.
+ * @ ref_xp   : [in] extended pointer on the reference user process descriptor. 
  * @ return local pointer on user_dir_t if success / return XPTR_NULL if failure.
  ****************************************************************************************/
-user_dir_t * user_dir_create( struct vfs_inode_s * inode );
+user_dir_t * user_dir_create( struct vfs_inode_s * inode,
+                              xptr_t               ref_xp );
 
 /*****************************************************************************************
  * This function removes a user_dir_t structure from the xlist of user_dir_t
- * structures rooted in the reference process descriptor, and release all memory
- * allocated for the user_dir_t struct in the directory inode cluster,
- * including the dirent array.
+ * structures rooted in the reference process descriptor, release all memory
+ * allocated for the user_dir_t struct in the directory inode cluster, including 
+ * the dirent array, and delete all ANON vseg copies in all process VMM copies,
+ * using parallel RPCs.
  * It must be executed by a thread running in the cluster containing the target inode.
  * Use the RPC_USER_DIR_DESTROY when the client thread is remote.
  *****************************************************************************************
- * @ dir  : local pointer on user_dir_t structure.
+ * @ dir      : [in] local pointer on user_dir_t structure.
+ * @ ref_xp   : [in] extended pointer on the reference user process descriptor. 
  ****************************************************************************************/
-void user_dir_destroy( struct user_dir_s * dir );
+void user_dir_destroy( struct user_dir_s * dir,
+                       xptr_t              ref_xp );
 
 

trunk/kernel/libk/xhtab.c

@@ -42 +42 @@
 // XHTAB_DENTRY_TYPE
 // This functions compute the hash index from the key, that is the directory entry name.
+// In this implementation, the index value is simply the ASCII code of the first
+// character, to provide an approximate lexicographic order. 
 ///////////////////////////////////////////////////////////////////////////////////////////
 // @ key      : local pointer on name.
@@ -49 +51 @@
 {
         char     * name  = key;
-        uint32_t   index = 0;
+
+        return (name[0] % XHASHTAB_SIZE);
+/*
+    uint32_t   index = 0;
         while( *name )
     {
@@ -55 +60 @@
     }
         return index % XHASHTAB_SIZE;
+*/
+
 } 
 

trunk/kernel/libk/xhtab.h

@@ -61 +61 @@
 ///////////////////////////////////////////////////////////////////////////////////////////
 
-#define XHASHTAB_SIZE    8   // number of subsets
+#define XHASHTAB_SIZE    128   // number of subsets
 
 /******************************************************************************************

trunk/kernel/mm/mapper.c

@@ -28 +28 @@
 #include <hal_uspace.h>
 #include <grdxt.h>
+#include <string.h>
 #include <rwlock.h>
 #include <printk.h>
@@ -41 +42 @@
 #include <vfs.h>
 #include <mapper.h>
+#include <dev_ioc.h>
 
 
@@ -302 +304 @@
 
     // launch I/O operation to load page from device to mapper
-    error = vfs_fs_move_page( XPTR( local_cxy , page ) , true );
+    error = vfs_fs_move_page( XPTR( local_cxy , page ) , IOC_SYNC_READ );
 
     if( error )
@@ -647 +649 @@
 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
+                             uint32_t   nbytes )
+{
+    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    * tabi;           // pointer on uint32_t to scan buffer
+    char        * tabc;           // pointer on char to scan buffer
+    uint32_t      line;           // line index
+    uint32_t      word;           // word index
+    uint32_t      n;              // char index
+    cxy_t         mapper_cxy;     // mapper cluster identifier
+    mapper_t    * mapper_ptr;     // mapper local pointer
+    vfs_inode_t * inode_ptr;      // inode local pointer
+ 
+    char       name[CONFIG_VFS_MAX_NAME_LENGTH];
 
     if( nbytes > 4096)
@@ -674 +682 @@
     }
 
+    // get cluster and local pointer
+    mapper_cxy = GET_CXY( mapper_xp );
+    mapper_ptr = GET_PTR( mapper_xp );
+
+    // get inode
+    inode_ptr = hal_remote_lpt( XPTR( mapper_cxy , &mapper_ptr->inode ) );
+
+    // get inode name
+    if( inode_ptr == NULL ) strcpy( name , "fat" );
+    else  vfs_inode_get_name( XPTR( mapper_cxy , inode_ptr ) , name );
+    
     // get extended pointer on page base
     base_xp = ppm_page2base( page_xp );
@@ -681 +700 @@
 
     // display 8 words per line
-    tab = (uint32_t *)buffer;
-    printk("\n***** %s : first %d bytes of page %d *****\n", string, nbytes, page_id );
+    tabi = (uint32_t *)buffer;
+    tabc = (char *)buffer;
+    printk("\n***** <%s> first %d bytes of page %d *****\n", name, 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] );
+        for( word = 0 ; word < 8 ; word++ ) printk("%X ", tabi[(line<<3) + word] );
+        printk(" | ");
+        for( n = 0 ; n < 32 ; n++ ) printk("%c", tabc[(line<<5) + n] );
         printk("\n");
     }

trunk/kernel/mm/mapper.h

@@ -38 +38 @@
 
 /*******************************************************************************************
- * The mapper implements the kernel cache for a given VFS file or directory.
+ * This mapper_t object implements the kernel cache for a given VFS file or directory.
  * There is one mapper per file/dir. It is implemented as a three levels radix tree,
  * entirely stored in the same cluster as the inode representing the file/dir.
@@ -63 +63 @@
  *
  * TODO : the mapper being only used to implement the VFS cache(s), the mapper.c
- *        and mapper.h file should beerro trandfered to the vfs directory.
+ *        and mapper.h file should be trandfered to the vfs directory.
  ******************************************************************************************/
 
@@ -85 +85 @@
 
 /*******************************************************************************************
- * This structure defines a "fragment". It is used to move data between the kernel mapper,
- * and an user buffer, that can be split in several distributed physical pages located
- * in different clusters. A fragment is a set of contiguous bytes in the file.
- * - It can be stored in one single physical page in the user buffer.
- * - It can spread two successive physical pages in the kernel mapper.
- ******************************************************************************************/
-
-typedef struct fragment_s
-{
-    uint32_t    file_offset;         /*! offset of fragment in file (i.e. in mapper)      */
-    uint32_t    size;                /*! number of bytes in fragment                      */
-    cxy_t       buf_cxy;             /*! user buffer cluster identifier                   */
-    void      * buf_ptr;             /*! local pointer on first byte in user buffer       */
-}
-fragment_t;
-
-/*******************************************************************************************
  * This function allocates physical memory for a mapper descriptor, and initializes it
  * (refcount <= 0) / inode <= NULL).
@@ -158 +141 @@
  * returns O if success / returns -1 if error.
  ******************************************************************************************/
-error_t mapper_move_user( xptr_t     mappe_xp,
+error_t mapper_move_user( xptr_t     mapper_xp,
                           bool_t     to_buffer,
                           uint32_t   file_offset,
@@ -258 +241 @@
  * @ 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 );
+                             uint32_t   nbytes );
 
 

trunk/kernel/mm/vmm.c

@@ -64 +64 @@
     intptr_t  base;
     intptr_t  size;
+    uint32_t  i;
 
 #if DEBUG_VMM_INIT
@@ -69 +70 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_VMM_INIT )
-printk("\n[%s] thread[%x,%x] enter for process %x / cycle %d\n", 
-__FUNCTION__ , this->process->pid, this->trdid, process->pid , cycle );
+printk("\n[%s] thread[%x,%x] enter for process %x in cluster %x / cycle %d\n", 
+__FUNCTION__ , this->process->pid, this->trdid, process->pid, local_cxy, cycle );
 #endif
 
@@ -183 +184 @@
     vmm->mmap_mgr.first_free_vpn  = CONFIG_VMM_HEAP_BASE;
     busylock_init( &vmm->mmap_mgr.lock , LOCK_VMM_MMAP );
-
-    uint32_t i;
     for( i = 0 ; i < 32 ; i++ ) list_root_init( &vmm->mmap_mgr.zombi_list[i] );
 
@@ -195 +194 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_VMM_INIT )
-printk("\n[%s] thread[%x,%x] exit / process %x / entry_point %x / cycle %d\n", 
-__FUNCTION__, this->process->pid, this->trdid, process->pid, process->vmm.entry_point, cycle );
+printk("\n[%s] thread[%x,%x] exit for process %x in cluster %x / cycle %d\n", 
+__FUNCTION__, this->process->pid, this->trdid, process->pid, local_cxy, cycle );
 #endif
 
@@ -944 +943 @@
     vpn_t      free;
 
-    // mmap vseg size must be power of 2
+#if DEBUG_VMM_MMAP_ALLOC
+thread_t * this = CURRENT_THREAD;
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_VMM_MMAP_ALLOC < cycle )
+printk("\n[%s] thread[%x,%x] enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, cycle );
+#endif
+
+    // vseg size must be power of 2
     // compute actual size and index in zombi_list array
     size  = POW2_ROUNDUP( npages );
@@ -952 +959 @@
     mmap_mgr_t * mgr = &vmm->mmap_mgr;
 
+printk("\n@@@ in %s : size = %d / index = %d / first = %d / empty = %d\n",
+__FUNCTION__, size, index, mgr->vpn_size, list_is_empty(&mgr->zombi_list[index]) );
+
     // get lock on mmap allocator
     busylock_acquire( &mgr->lock );
@@ -958 +968 @@
     if( list_is_empty( &mgr->zombi_list[index] ) )     // from mmap zone
     {
+
+printk("\n@@@ from mmap zone\n" );
+
         // check overflow
         free = mgr->first_free_vpn;
-        if( (free + size) > mgr->vpn_size ) return ENOMEM;
-
-        // update STACK allocator
+        if( (free + size) > mgr->vpn_size ) return -1;
+
+        // update MMAP allocator
         mgr->first_free_vpn += size;
 
@@ -970 +983 @@
     else                                             // from zombi_list
     {
+
+printk("\n@@@ from zombi_list\n" );
+
         // get pointer on zombi vseg from zombi_list
         vseg = LIST_FIRST( &mgr->zombi_list[index] , vseg_t , zlist );
@@ -982 +998 @@
     // release lock on mmap allocator
     busylock_release( &mgr->lock );
+
+#if DEBUG_VMM_MMAP_ALLOC
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_VMM_DESTROY < cycle )
+printk("\n[%s] thread[%x,%x] exit / vpn_base %x / vpn_size %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, base, size, cycle );
+#endif
 
     // returns vpn_base, vpn_size
@@ -1009 +1032 @@
 uint32_t   cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_VMM_CREATE_VSEG < cycle )
-printk("\n[%s] thread[%x,%x] enter / %s / cxy %x / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, vseg_type_str(type), cxy, cycle );
+printk("\n[%s] thread[%x,%x] enter for process %x / %s / cxy %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, process->pid, vseg_type_str(type), cxy, cycle );
 #endif
 
@@ -1092 +1115 @@
     if( vseg != NULL )
     {
-        printk("\n[ERROR] in %s for process %x : new vseg [vpn_base = %x / vpn_size = %x]\n"
-               "  overlap existing vseg [vpn_base = %x / vpn_size = %x]\n",
+        printk("\n[ERROR] in %s for process %x : new vseg [vpn_base %x / vpn_size %x]\n"
+               "  overlap existing vseg [vpn_base %x / vpn_size %x]\n",
         __FUNCTION__ , process->pid, vpn_base, vpn_size, vseg->vpn_base, vseg->vpn_size );
         return NULL;
@@ -1106 +1129 @@
         return NULL;
         }
+
+#if DEBUG_VMM_CREATE_VSEG
+if( DEBUG_VMM_CREATE_VSEG < cycle )
+printk("\n[%s] thread[%x,%x] : base %x / size %x / vpn_base %x / vpn_size %x\n",
+__FUNCTION__, this->process->pid, this->trdid, base, size, vpn_base, vpn_size );
+#endif
 
     // initialize vseg descriptor

trunk/kernel/mm/vmm.h

@@ -138 +138 @@
  * - It initializes the generic page table, calling the HAL specific hal_gpt_init() function.
  * - For TSAR it map all pages for the "kentry" vseg, that must be identity mapping.
- * Note:
+ ******************************************************a**************************************
+ * Implementation notes:
  * - The "code" and "data" vsegs are registered by the elf_load_process() function.
  * - The "stack" vsegs are dynamically created by the thread_user_create() function.

trunk/kernel/syscalls/sys_closedir.c

@@ -74 +74 @@
     if( dir_cxy == local_cxy )
     {
-        user_dir_destroy( dir_ptr );
+        user_dir_destroy( dir_ptr,
+                          process->ref_xp );
     }
     else
     {
         rpc_user_dir_destroy_client( dir_cxy,
-                                     dir_ptr );
+                                     dir_ptr,
+                                     process->ref_xp );
     }
 

trunk/kernel/syscalls/sys_display.c

@@ -357 +357 @@
 
         // display mapper
-        error = mapper_display_page( mapper_xp , page_id , nbytes , kbuf );
+        error = mapper_display_page( mapper_xp , page_id , nbytes );
 
         if( error )

trunk/kernel/syscalls/sys_opendir.c

@@ -143 +143 @@
         }
    
-    // create a new user_dir_t structure in inode cluster 
-    // and get the user space pointer on dirent array
+    // create a new user_dir_t structure in target directory inode cluster 
+    // map it in the reference user process VMM (in a new ANON vseg)
+    // an get the local pointer on the created user_dir_t structure 
     if( inode_cxy == local_cxy )
     {
-        dir_ptr = user_dir_create( inode_ptr );
+        dir_ptr = user_dir_create( inode_ptr,
+                                   process->ref_xp );
     }
     else
@@ -153 +155 @@
         rpc_user_dir_create_client( inode_cxy,
                                     inode_ptr,
+                                    process->ref_xp,
                                     &dir_ptr );
     }