Changeset 23 for trunk/kernel

trunk/kernel/devices/dev_dma.c

-                      r3
+                      r23
 void dev_dma_init( chdev_t * chdev )
+{
+    // get implementation index from DMA chdev descriptor
+    uint32_t impl = chdev->impl;
+    // get implementation & channel from DMA chdev descriptor
+    uint32_t impl    = chdev->impl;
+    uint32_t channel = chdev->channel;
+    // set chdev name
+    snprintf( chdev->name , 16 , "dma_%d_%x" , channel , local_cxy );
     // set field "cmd", "isr", and call the relevant driver init function
 …
         assert( false , __FUNCTION__ , "undefined DMA implementation" );
+    }
-    // get DMA channel index
-    uint32_t channel = chdev->channel;
     // get DMA HWI IRQ index

trunk/kernel/devices/dev_fbf.c

-                      r14
+                      r23
     uint32_t  impl = chdev->impl;
+    // set chdev name
+    strcpy( chdev->name, "fbf" );
     // call driver init function
     if( impl == IMPL_FBF_SCL )
 …
     error_t     error;
     paddr_t     buf_paddr;
-    bool_t      ident = CONFIG_KERNEL_IDENTITY;
     thread_t * this = CURRENT_THREAD;              // pointer on client thread
     // Get buffer physical address
     error = vmm_v2p_translate( ident , buffer , &buf_paddr );
+    error = vmm_v2p_translate( CONFIG_KERNEL_IDENTITY_MAP , buffer , &buf_paddr );
     if( error )

trunk/kernel/devices/dev_icu.c

-                      r14
+                      r23
                    uint32_t  pti_nr )
+{
+    // set chdev name
+    snprintf( icu->name , 16 , "icu_%x" , local_cxy );
     // set ICU chdev extension fields
     icu->ext.icu.hwi_nr     = hwi_nr;

trunk/kernel/devices/dev_iob.c

-                      r14
+                      r23
     // get implementation
     uint32_t  impl = chdev->impl;
+    // set chdev name
+    strcpy( chdev->name , "iob" );
     // call driver init function

trunk/kernel/devices/dev_ioc.c

-                      r14
+                      r23
     uint32_t  channel = chdev->channel;
+    // set chdev name
+    strcpy( chdev->name , "ioc" );
     // set driver specific fields in chdev descriptor and call driver init function
     if( impl == IMPL_IOC_BDV )
 …
     else if( impl == IMPL_IOC_HBA )
+    {
         chdev->cmd = &soclib_hba_command;
+        chdev->cmd = &soclib_hba_cmd;
         chdev->isr = &soclib_hba_isr;
         soclib_hba_init( chdev );
 …
 //////////////////////////////////////////////////////////////////////////////////
 // This static function is called by dev_ioc_read() & dev_ioc_write() functions.
+// It builds and registers the command in the calling thread descriptor, after
+// translation of buffer virtual address to physical address.
+// It builds and registers the command in the calling thread descriptor.
 // Then, it registers the calling thead in chdev waiting queue.
 // Finally it blocks on the THREAD_BLOCKED_DEV condition and deschedule.
 ////////////////////////////////////i/////////////////////////////////////////////
 static error_t dev_ioc_access( bool_t    to_mem,
                                char    * buffer,
                                uint32_t  lba,
                                uint32_t  count )
+static error_t dev_ioc_access( uint32_t   cmd_type,
+                               uint8_t  * buffer,
+                               uint32_t   lba,
+                               uint32_t   count )
+{
     thread_t * this = CURRENT_THREAD;              // pointer on client thread
-    error_t     error;
-    paddr_t     buf_paddr;
-    // Get buffer physical address
-    error = vmm_v2p_translate( CONFIG_KERNEL_IDENTITY , buffer , &buf_paddr );
-    if( error )  return EINVAL;
     ioc_dmsg("\n[INFO] in %s : thread %x in process %x"
              " for lba = %x / vaddr = %x / paddr = %l / at cycle %d\n",
+             " for lba = %x / buffer = %x / at cycle %d\n",
              __FUNCTION__ , this->trdid , this->process->pid ,
              lba , (uint32_t)buffer , buf_paddr , hal_time_stamp() );
+             lba , (intptr_t)buffer , hal_time_stamp() );
 #if USE_IOB    // software L2/L3 cache coherence for memory buffer
     if ( to_mem )  dev_mmc_inval( buf_paddr, count<<9 );
     else           dev_mmc_sync( buf_paddr, count<<9 );
+    if ( type == IOC_READ )  dev_mmc_inval( XPTR( local_cxy , buffer ) , count<<9 );
+    else                     dev_mmc_sync ( XPTR( local_cxy , buffer ) , count<<9 );
 #endif     // end software L2/L3 cache coherence
 …
     // register command in calling thread descriptor
     this->command.ioc.dev_xp    = dev_xp;
     this->command.ioc.to_mem    = to_mem;
+    this->command.ioc.type      = cmd_type;
     this->command.ioc.buf_xp    = XPTR( local_cxy , buffer );
     this->command.ioc.lba       = lba;
 …
 ////////////////////////////////////////////
 error_t dev_ioc_read( char         * buffer,
+error_t dev_ioc_read( uint8_t      * buffer,
                       uint32_t       lba,
                       uint32_t       count )
+{
     return dev_ioc_access( true , buffer , lba , count );
+    return dev_ioc_access( IOC_READ , buffer , lba , count );
+}
 ////////////////////////////////////////////
 error_t dev_ioc_write( char         * buffer,
                        uint32_t       lba,
                        uint32_t       count )
+{
     return dev_ioc_access( false , buffer , lba , count );
+error_t dev_ioc_write( uint8_t     * buffer,
+                       uint32_t      lba,
+                       uint32_t      count )
+{
+    return dev_ioc_access( IOC_WRITE , buffer , lba , count );
+}
+/////////////////////////////////////////////
+error_t dev_ioc_sync_read( uint8_t  * buffer,
+                           uint32_t   lba,
+                           uint32_t   count )
+{
+    // get pointer on calling thread
+    thread_t * this = CURRENT_THREAD;
+#if USE_IOB    // software L2/L3 cache coherence for memory buffer
+    dev_mmc_inval( XPTR( local_cxy , buffer ) , count<<9 );
+#endif         // end software L2/L3 cache coherence
+    // get extended pointer on IOC[0] chdev
+    xptr_t  dev_xp = chdev_dir.ioc[0];
+    assert( (dev_xp != XPTR_NULL) , __FUNCTION__ , "undefined IOC chdev descriptor" );
+    // register command in calling thread descriptor
+    this->command.ioc.dev_xp    = dev_xp;
+    this->command.ioc.type      = IOC_SYNC_READ;
+    this->command.ioc.buf_xp    = XPTR( local_cxy , buffer );
+    this->command.ioc.lba       = lba;
+    this->command.ioc.count     = count;
+    // get driver command function
+    cxy_t       dev_cxy = GET_CXY( dev_xp );
+    chdev_t   * dev_ptr = (chdev_t *)GET_PTR( dev_xp );
+    dev_cmd_t * cmd = (dev_cmd_t *)hal_remote_lpt( XPTR( dev_cxy , &dev_ptr->cmd ) );
+    // call directly driver command
+    cmd( XPTR( local_cxy , this ) );
+    // return I/O operation status from calling thread descriptor
+    return this->command.ioc.error;
+}

trunk/kernel/devices/dev_ioc.h

-                      r14
+                      r23
  * 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 two command types:
+ * - READ  : move a given number of contiguous blocks from device to a memory buffer.
+ * - WRITE : move a given number of contiguous blocks from a memory buffer to device.
+ *
+ * An I/O operation requires dynamic ressource allocation, and is always blocking for
+ * the client thread. The general scenario is detailed below.
+ * 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.
+ * A READ or WRITE operation requires dynamic ressource allocation. The calling thread
+ * is descheduled, and the work is done by the server thread associated to IOC device.
+ * The general scenario is detailed below.
  * A) the client thread start the I/O operation, by calling the dev_ioc_read()
  *    or the dev_ioc_write() kernel functions that perform the following actions:
 …
  *    3) it access the PIC to link the WTI mailbox to the IOC IRQ.
  *    4) it builds the command descriptor.
  *    5) it registers in the IOCdevice waiting queue.
+ *    5) it registers in the IOC device waiting queue.
  *    6) itblock on the THREAD_BLOCKED_IO condition and deschedule.
  * B) The server thread attached to the IOC device descriptor handles the commands
 …
  *    2) disable the WTI IRQ in the client cluster ICU and update interrupt vector.
  *    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.
  *****************************************************************************************/
 …
  *****************************************************************************************/
+enum
+{
+    IOC_READ       = 0,
+    IOC_WRITE      = 1,
+    IOC_SYNC_READ  = 2,
+};
 typedef struct ioc_command_s
+{
     xptr_t      dev_xp;      /*! extended pointer on device descriptor                    */
     uint32_t    to_mem;     /*! requested operation (WRITE if zero / READ if non-zero)   */
+    xptr_t      dev_xp;     /*! extended pointer on device descriptor                    */
+    uint32_t    type;       /*! IOC_READ / IOC_WRITE / IOC_SYNC_READ                     */
     uint32_t    lba;        /*! first block index                                        */
     uint32_t    count;      /*! number of blocks                                         */
 …
 /******************************************************************************************
  * This blocking function try to tranfer one or several contiguous blocks of data
  * from the block device to a memory buffer. The corresponding request is actually
+ * 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,
  * waiting on transfer completion. It will be resumed by the IRQ signaling completion.
  * It must be called in the client cluster.
  ******************************************************************************************
  * @ buffer    : local pointer on target buffer in memory.
+ * @ buffer    : local pointer on target 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_read( char         * buffer,
+error_t dev_ioc_read( uint8_t      * buffer,
                       uint32_t       lba,
                       uint32_t       count );
 …
 /******************************************************************************************
  * This blocking function try to tranfer one or several contiguous blocks of data
  * from a memory buffer to the block device. The corresponding request is actually
+ * 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,
  * waiting on transfer completion. It will be resumed by the IRQ signaling completion.
  * It must be called in the client cluster.
  ******************************************************************************************
  * @ buffer    : local pointer on source buffer in memory.
+ * @ 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_write( char         * buffer,
+error_t dev_ioc_write( uint8_t      * buffer,
                        uint32_t       lba,
                        uint32_t       count );
+/******************************************************************************************
+ * This blocking function try to tranfer one or several contiguous blocks of data
+ * from the block device to a 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 OIC driver, implementing a busy-waiting
+ * policy for the calling thread.
+ * It must be called in the client cluster.
+ ******************************************************************************************
+ * @ buffer    : local pointer on target 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_read( uint8_t      * buffer,
+                           uint32_t       lba,
+                           uint32_t       count );
 #endif  /* _DEV_IOC_H */

trunk/kernel/devices/dev_mmc.c

-                      r14
+                      r23
     // get implementation from device descriptor
     uint32_t  impl = chdev->impl;
+    // set chdev name
+    snprintf( chdev->name , 16 , "mmc_%x" , local_cxy );
     // set driver specific fields in device descriptor and call driver init function
 …
 /////////////////////////////////////////////////////////////////////////////
+// This static function makes some checking, takes the lock granting
+// exclusive access to MMC peripheral, call the driver to execute the command
+// This static function is called by all MMC device functions.
+// It makes some checking, takes the lock granting exclusive
+// access to MMC peripheral, call the driver to execute the command
 // registered in the calling thread descriptor, and releases the lock.
 /////////////////////////////////////////////////////////////////////////////
+static void dev_mmc_access( thread_t * this )
+{
+    mmc_dmsg("\n[INFO] %s enters for thread %x in process %x : command = %d\n",
+                 __FUNCTION__ , this->trdid , this->process->pid , this->command.mmc.type );
+    // get extended pointer on MMC device
+    xptr_t  dev_xp  = this->command.mmc.dev_xp;
+    assert( (dev_xp != XPTR_NULL) , __FUNCTION__ , "undefined MMC device descriptor" );
+static error_t dev_mmc_access( thread_t * this )
+{
+    // get extended pointer on MMC device descriptor
+    xptr_t  dev_xp = this->command.mmc.dev_xp;
+    assert( (dev_xp != XPTR_NULL) , __FUNCTION__ , "target MMC device undefined" );
     // get MMC device cluster identifier & local pointer
 …
     remote_spinlock_unlock( XPTR( dev_cxy , &dev_ptr->wait_lock ) );
     mmc_dmsg("\n[INFO] %s completes for thread %x in process %x / error = %d\n",
                  __FUNCTION__ , this->trdid , this->process->pid , this->dev.ioc.error );
+    // return operation status
+    return this->command.mmc.error;
 }  // end dev_mmc_access()
 ////////////////////////////////////////////
 error_t dev_mmc_inval( paddr_t    buf_paddr,
+/////////////////////////////////////////
+error_t dev_mmc_inval( xptr_t     buf_xp,
                        uint32_t   buf_size )
+{
+    // get calling thread local pointer
+    thread_t * this = CURRENT_THREAD;
+    // get target cluster from paddr
+    cxy_t cxy = CXY_FROM_PADDR( buf_paddr );
+    assert( ((buf_paddr & (CONFIG_CACHE_LINE_SIZE -1)) == 0) , __FUNCTION__ ,
+    error_t error;
+    // get calling thread local pointer
+    thread_t * this = CURRENT_THREAD;
+    mmc_dmsg("\n[INFO] %s enters for thread %x in process %x / buf_xp = %l\n",
+                 __FUNCTION__ , this->trdid , this->process->pid , buf_xp );
+    // get buffer cluster and local pointer
+    cxy_t  buf_cxy = GET_CXY( buf_xp );
+    void * buf_ptr = GET_PTR( buf_xp );
+    assert( (((intptr_t)buf_ptr & (CONFIG_CACHE_LINE_SIZE -1)) == 0) , __FUNCTION__ ,
              "buffer not aligned on cache line" );
+    // get extended pointer on MMC device descriptor
+    xptr_t  dev_xp = chdev_dir.mmc[cxy];
+    // store command arguments in thread descriptor
+    this->command.mmc.dev_xp    = dev_xp;
+    // get buffer physical address
+    paddr_t  buf_paddr;
+    error = vmm_v2p_translate( CONFIG_KERNEL_IDENTITY_MAP , buf_ptr , &buf_paddr );
+    assert( (error == 0) , __FUNCTION__ , "cannot get buffer paddr" );
+    // store command arguments in thread descriptor
+    this->command.mmc.dev_xp    = chdev_dir.mmc[buf_cxy];
     this->command.mmc.type      = MMC_CC_INVAL;
     this->command.mmc.buf_paddr = buf_paddr;
     this->command.mmc.buf_size  = buf_size;
+    // execute operation
+    dev_mmc_access( this );
+    // return operation status
+    return this->command.mmc.error;
+}
+/////////////////////////////////////
+error_t dev_mmc_sync( paddr_t    buf_paddr,
+    // call MMC driver
+    error = dev_mmc_access( this );
+    mmc_dmsg("\n[INFO] %s completes for thread %x in process %x / error = %d\n",
+             __FUNCTION__ , this->trdid , this->process->pid , error );
+    return error;
+}
+////////////////////////////////////////
+error_t dev_mmc_sync( xptr_t     buf_xp,
                       uint32_t   buf_size )
+{
+    // get calling thread local pointer
+    thread_t * this = CURRENT_THREAD;
+    // get target cluster from paddr
+    cxy_t cxy = CXY_FROM_PADDR( buf_paddr );
+    assert( ((buf_paddr & (CONFIG_CACHE_LINE_SIZE -1)) == 0) , __FUNCTION__ ,
+    error_t error;
+    // get calling thread local pointer
+    thread_t * this = CURRENT_THREAD;
+    mmc_dmsg("\n[INFO] %s enters for thread %x in process %x / buf_xp = %l\n",
+                 __FUNCTION__ , this->trdid , this->process->pid , buf_xp );
+    // get buffer cluster and local pointer
+    cxy_t  buf_cxy = GET_CXY( buf_xp );
+    void * buf_ptr = GET_PTR( buf_xp );
+    assert( (((intptr_t)buf_ptr & (CONFIG_CACHE_LINE_SIZE -1)) == 0) , __FUNCTION__ ,
              "buffer not aligned on cache line" );
+    // store command arguments in thread descriptor
+    this->command.mmc.dev_xp    = chdev_dir.mmc[cxy];
+    // get  buffer physical address
+    paddr_t  buf_paddr;
+    error = vmm_v2p_translate( CONFIG_KERNEL_IDENTITY_MAP , buf_ptr , &buf_paddr );
+    assert( (error == 0) , __FUNCTION__ , "cannot get buffer paddr" );
+    // store command arguments in thread descriptor
+    this->command.mmc.dev_xp    = chdev_dir.mmc[buf_cxy];
     this->command.mmc.type      = MMC_CC_SYNC;
     this->command.mmc.buf_paddr = buf_paddr;
     this->command.mmc.buf_size  = buf_size;
+    // execute operation
+    dev_mmc_access( this );
+    // return operation status
+    return this->command.mmc.error;
+}
+    // call MMC driver
+    error = dev_mmc_access( this );
+    mmc_dmsg("\n[INFO] %s completes for thread %x in process %x / error = %d\n",
+                 __FUNCTION__ , this->trdid , this->process->pid , error );
+    return error;
+}
 /////////////////////////////////////////
 …
     // execute operation
+    dev_mmc_access( this );
+    // return operation status
+    return this->command.mmc.error;
+    return dev_mmc_access( this );
+}
 …
     // execute operation
+    dev_mmc_access( this );
+    // return operation status
+    return this->command.mmc.error;
+    return dev_mmc_access( this );
+}
 …
     // execute operation
+    dev_mmc_access( this );
+    // return operation status
+    return this->command.mmc.error;
+}
+    return dev_mmc_access( this );
+}

trunk/kernel/devices/dev_mmc.h

-                      r14
+                      r23
 typedef struct mmc_command_s
+{
     xptr_t      dev_xp;     /*! extended pointer on the relevant MMC device descriptor  */
+    xptr_t      dev_xp;     /*! extended pointer on target MMC device descriptor        */
     uint32_t    type;       /*! CC_INVAL / CC_SYNC / GET_ERROR / SET_ERROR / GET_INSTRU */
     paddr_t     buf_paddr;  /*! buffer physical address          (used by INVAL/SYNC)   */
     uint32_t    buf_size;   /*! buffer size in bytes             (used by INVAL/SYNC)   */
     uint32_t    reg_index;  /*! register index in MMC peripheral (used by SET/GET)      */
     uint32_t  * reg_ptr;    /*! local pointer on src/dst buffer  (used by SET/GET)      */
+    paddr_t     buf_paddr;  /*! physical address of memory buffer (used by INVAL/SYNC)  */
+    uint32_t    buf_size;   /*! buffer size in bytes              (used by INVAL/SYNC)  */
+    uint32_t    reg_index;  /*! register index in MMC peripheral  (used by SET/GET)     */
+    uint32_t  * reg_ptr;    /*! local pointer on src/dst buffer   (used by SET/GET)     */
     error_t     error;      /*! operation status (0 if success)                         */
+}
 …
  * to access both the MMC device descriptor, and the L2 cache configuration interface.
  *****************************************************************************************
  * @ buf_paddr  : buffer local physical addresse.
+ * @ buf_xp     : extended pointer on memory buffer.
  * @ buf_size   : buffer size (bytes).
  * @ return 0 if success / return EINVAL if failure
  ****************************************************************************************/
 error_t dev_mmc_inval( paddr_t   buf_paddr,
                        uint32_t  buf_size );
+error_t dev_mmc_inval( xptr_t     buf_xp,
+                       uint32_t   buf_size );
 /*****************************************************************************************
 …
  * to access both the MMC device descriptor, and the L2 cache configuration interface.
  *****************************************************************************************
  * @ buf_paddr  : buffer local physical addresse.
+ * @ buf_xp     : extended pointer on memory buffer.
  * @ buf_size   : buffer size (bytes).
  * @ return 0 if success / return EINVAL if failure
  ****************************************************************************************/
 error_t dev_mmc_sync( paddr_t    buf_paddr,
+error_t dev_mmc_sync( xptr_t     buf_xp,
                       uint32_t   buf_size );

trunk/kernel/devices/dev_nic.c

-                      r3
+                      r23
     uint32_t  channel = chdev->channel;
+    // set chdev name
+    snprintf( chdev->name , 16 , "nic_%d" , chdev->channel );
     // set driver specific fields in chdev descriptor and call driver init function
     if( impl == IMPL_NIC_SOC )

trunk/kernel/devices/dev_pic.c

-                      r3
+                      r23
     uint32_t impl = chdev->impl;
+    // set chdev name
+    strcpy( chdev->name , "pic" );
     // call the relevant driver init function
     if( impl == IMPL_PIC_SOC )

trunk/kernel/devices/dev_txt.c

-                      r16
+                      r23
     uint32_t  impl    = chdev->impl;
     uint32_t  channel = chdev->channel;
+    // set chdev name
+    snprintf( chdev->name , 16 , "txt_%d" , chdev->channel );
     // set fields "cmd", "isr", and call driver init function
 …
     xptr_t  dev_xp = chdev_dir.txt[channel];
+    assert( (dev_xp != XPTR_NULL) , __FUNCTION__ , "undefined TXT0 chdev descriptor" );
     // register command in calling thread
     this->command.txt.dev_xp  = dev_xp;

trunk/kernel/devices/dev_txt.h

r14	r23
106	106
107	107	/******************************************************************************************
108		* This blocking function writes ~~a character string~~ on the terminal identified
	108	* This blocking function writes characters on the terminal identified
109	109	* by the "channel" argument. The corresponding request is actually registered in the
110	110	* chdev requests queue, and the calling thread is descheduled, blocked until

trunk/kernel/drivers/soclib/soclib_bdv.c

-                      r4
+                      r23
 void __attribute__ ((noinline)) soclib_bdv_cmd( xptr_t th_xp )
+{
     uint32_t   to_mem;       // command argument
+    uint32_t   cmd_type;     // IOC_READ / IOC_WRITE / IOC_SYNC_READ
     uint32_t   lba;          // command argument
     uint32_t   count;        // command argument
 …
     // get command arguments and extended pointer on IOC device
     to_mem =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->command.ioc.to_mem ) );
     lba    =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->command.ioc.lba    ) );
     count  =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->command.ioc.count  ) );
     buf_xp = (xptr_t)hal_remote_lwd( XPTR( th_cxy , &th_ptr->command.ioc.buf_xp ) );
     dev_xp = (xptr_t)hal_remote_lwd( XPTR( th_cxy , &th_ptr->command.ioc.dev_xp ) );
+    cmd_type =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->command.ioc.type   ) );
+    lba      =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->command.ioc.lba    ) );
+    count    =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->command.ioc.count  ) );
+    buf_xp   = (xptr_t)hal_remote_lwd( XPTR( th_cxy , &th_ptr->command.ioc.buf_xp ) );
+    dev_xp   = (xptr_t)hal_remote_lwd( XPTR( th_cxy , &th_ptr->command.ioc.dev_xp ) );
     // get IOC device cluster and local pointer
 …
     uint32_t   buf_msb = (uint32_t)(buf_xp>>32);
+    // get access type
+    uint32_t   type =  to_mem ? BDV_OP_READ : BDV_OP_WRITE;
+    // set operation
+    uint32_t   op;
+    if( cmd_type == IOC_WRITE ) op = BDV_OP_WRITE;
+    else                        op = BDV_OP_READ;
     // set SOCLIB_BDV registers to start one I/O operation
 …
     hal_remote_sw( XPTR( bdv_cxy , bdv_ptr + BDV_LBA_REG        ) , lba     );
     hal_remote_sw( XPTR( bdv_cxy , bdv_ptr + BDV_COUNT_REG      ) , count   );
     hal_remote_sw( XPTR( bdv_cxy , bdv_ptr + BDV_OP_REG         ) , type    );
+    hal_remote_sw( XPTR( bdv_cxy , bdv_ptr + BDV_OP_REG         ) , op      );
+    // Block and deschedule server thread
+    thread_block( CURRENT_THREAD , THREAD_BLOCKED_DEV_ISR );
+    sched_yield();
+    // waiting policy  depends on the command type
+    if( cmd_type == IOC_SYNC_READ )                  // polling policy
+    {
+        uint32_t status;
+        while (1)
+        {
+            status = hal_remote_lw( XPTR( bdv_cxy , bdv_ptr + BDV_STATUS_REG ) );
+            if( status == BDV_READ_SUCCESS ) // successfully completed
+            {
+                hal_remote_sw( XPTR( th_cxy , &th_ptr->command.ioc.error ) , 0 );
+                break;
+            }
+            else if( status == BDV_BUSY )   // non completed
+            {
+                continue;
+            }
+            else                            // error reported
+            {
+                hal_remote_sw( XPTR( th_cxy , &th_ptr->command.ioc.error ) , 1 );
+                break;
+            }
+        }
+    }
+    else                                            // descheduling + IRQ policy
+    {
+        thread_block( CURRENT_THREAD , THREAD_BLOCKED_DEV_ISR );
+        sched_yield();
+    }
 } // end soclib_bdv_cmd()

trunk/kernel/drivers/soclib/soclib_hba.c

-                      r4
+                      r23
     chdev->ext.ioc.count = block_count;
+        // reset SOCLIB_HBA driver global variables
+    // activate HBA interrupts
+    hal_remote_sw( XPTR( hba_cxy , hba_ptr + HBA_PXIE_REG ) , 0x1 );
+        // reset SOCLIB_HBA driver global variable
     hba_active_slots = 0;
 …
 //////////////////////////////////////////////////////////////////
 void __attribute__ ((noinline)) soclib_hba_command( xptr_t th_xp )
+//////////////////////////////////////////////////////////////
+void __attribute__ ((noinline)) soclib_hba_cmd( xptr_t th_xp )
+{
     uint32_t           to_mem;       // to_mem : command argument
+    uint32_t           cmd_type;     // IOC_READ / IOC_WRITE / IOC_SYNC_READ
     uint32_t           lba;          // lba    : command argument
     uint32_t           count;        // count  : command argument
     xptr_t             buf_xp;       // buffer : command argument
     xptr_t             dev_xp;       // device : command argument
     uint32_t           cmd_id;       // current slot index in command bit_vector
     hba_cmd_desc_t   * cmd_desc;     // command descriptor pointer
     hba_cmd_table_t  * cmd_table;    // command table pointer
     bool_t             found;
     uint32_t           iter;
 …
     // get command arguments and extended pointer on IOC device
     to_mem    =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->command.ioc.to_mem ) );
+    cmd_type  =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->command.ioc.type   ) );
     lba       =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->command.ioc.lba    ) );
     count     =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->command.ioc.count  ) );
 …
+        }
         if( found )  // register and starts the I/O operation
+        if( found )  // slot available in SOCLIB_HBA
+        {
             // compute pointers on command descriptor and command table
 …
             cmd_desc->prdtl[0] = 1;
             cmd_desc->prdtl[1] = 0;
             if( to_mem ) cmd_desc->flag[0] = 0x00;
             else         cmd_desc->flag[0] = 0x40;
+            if( cmd_type == IOC_WRITE ) cmd_desc->flag[0] = 0x40;
+            else                        cmd_desc->flag[0] = 0x00;
 #if USE_IOB // software L2/L3 cache coherence
+            // compute physical addresses
+            paddr_t   cmd_desc_paddr;    // command descriptor physical address
+            paddr_t   cmd_table_paddr;   // command table header physical address
+            bool_t    ident = CONFIG_KERNEL_IDENTITY;
+            error = vmm_v2p_translate( ident , cmd_table , &cmd_table_paddr );
+            if( error )
+            {
+                printk("\n[PANIC] in %s : cannot get paddr fo cmd_table\n", __FUNCTION__ );
+                hal_core_sleep()
+            }
+            error = vmm_v2p_translate( ident , cmd_desc , &cmd_desc_paddr );
+            if( error )
+            {
+                printk("\n[PANIC] in %s : cannot get paddr fo cmd_desc\n", __FUNCTION__ );
+                hal_core_sleep()
+            }
+            // update L3 for command table
+            dev_mmc_sync( cmd_table_paddr , sizeof(hba_cmd_table_t) );
+            // update L3 for command descriptor
+            dev_mmc_sync( cmd_desc_paddr , sizeof(hba_cmd_desc_t) );
+            dev_mmc_sync( cmd_table , sizeof(hba_cmd_table_t) );
+            dev_mmc_sync( cmd_desc , sizeof(hba_cmd_desc_t) );
 #endif // end software L2/L3 cache coherence
-            // activates HBA interrupts
-            hal_remote_sw( XPTR( hba_cxy , hba_ptr + HBA_PXIE_REG ) , 0x1 );
             // set hba_owner_thread[slot]
             hba_owner_thread[cmd_id] = th_xp;
+            // register slot in bit_vector
+            hba_active_slots |= 1<<cmd_id;
             // set HBA_PXCI_REG to start transfer
             hal_remote_sw( XPTR( hba_cxy , hba_ptr + HBA_PXCI_REG ) , 1<<cmd_id );
-            ioc_dmsg("INFO in %s : thread %x / buffer = %llx at cycle %d\n",
-            __FUNCTION__ , hal_remote_lw( XPTR( th_cxy , &th_ptr->trdid ) ) ,
-            buf_xp , hal_time_stamp() );
             // exit the while
             break;
+        }
+        else   // deschedule if no slot available in SOCLIB_HBA
+        {
+            sched_yield();
+        }
+    }  // end while
+        else   // no slot available in SOCLIB_HBA
+        {
+            if( cmd_type == IOC_SYNC_READ )     // fatal if synchronous access
+            {
+                printk("\n[PANIC] in %s : no slot available for a SYNC_READ\n", __FUNCTION__ );
+                hal_core_sleep();
+            }
+            else                                // retry if asynchronous access.
+            {
+                sched_yield();
+            }
+        }
+    }  // end while to get a slot
+    // waiting policy depends on the command type
+    if( cmd_type == IOC_SYNC_READ )                // polling, busy waiting
+    {
+        uint32_t  pxis;
+        uint32_t  pxci;
+        uint32_t  error;
+        uint32_t  fault_id;
+        while(1)
+        {
+            pxis     = hal_remote_lw( XPTR( hba_cxy , hba_ptr + HBA_PXIS_REG ) );
+            pxci     = hal_remote_lw( XPTR( hba_cxy , hba_ptr + HBA_PXCI_REG ) );
+            error    = (pxis & 0x40000000) >> 30;
+            fault_id = (pxis & 0x1F000000) >> 24;
+            if( (pxci & (1<<cmd_id)) == 0 )  // completed
+            {
+                // release slot
+                hba_active_slots &= ~(1<<cmd_id);
+                // set operation status in client thread command
+                if( error && (fault_id == cmd_id) )
+                {
+                    hal_remote_sw( XPTR( th_cxy , &th_ptr->command.ioc.error ) , 1 );
+                }
+                else
+                {
+                    hal_remote_sw( XPTR( th_cxy , &th_ptr->command.ioc.error ) , 0 );
+                }
+                // exit while
+                break;
+            }
+        }
+    }
+    else                                           // descheduling + IRQ
+    {
+        thread_block( CURRENT_THREAD , THREAD_BLOCKED_DEV_ISR );
+        sched_yield();
+    }
 } // end soclib_hba_cmd()
 …
     uint32_t * hba_ptr  = (uint32_t *)GET_PTR( chdev->base );
     // get HBA_PXIS_REG and HBA_PXIS_REG current values
+    // get HBA_PXIS_REG and HBA_PXCI_REG current values
     uint32_t current_pxis = hal_remote_lw( XPTR( hba_cxy , hba_ptr + HBA_PXIS_REG ) );
     uint32_t current_pxci = hal_remote_lw( XPTR( hba_cxy , hba_ptr + HBA_PXCI_REG ) );

trunk/kernel/drivers/soclib/soclib_hba.h

r4	r23
145	145	* @ xp_thread : extended pointer on the client thread.
146	146	*******************************************************************************************/
147		extern void soclib_hba_c~~omman~~d( xptr_t thread_xp );
	147	extern void soclib_hba_cmd( xptr_t thread_xp );
148	148
149	149	/********************************************************************************************

trunk/kernel/kern/chdev.c

r16	r23
32	32	#include <rpc.h>
33	33	#include <chdev.h>
	34	#include <devfs.h>
34	35
35	36	////////////////////////////////////////////

trunk/kernel/kern/chdev.h

-                      r16
+                      r23
  * This file defines the kernel representation of a generic (i.e. implementation
  * independant) Channel Device descriptor (in brief "chdev").
  * ALMOS-MKH supports multi-channels peripherals, and defines one separated descriptor
  * for each channel (and for each RX/TX direction for the NIC device).
+ * ALMOS-MKH supports multi-channels peripherals, and defines one separated chdev
+ * descriptor for each channel (and for each RX/TX direction for the NIC device).
  * Each chdev contains a waiting queue, registering the "client threads" requests,
  * and an associated "server thread", handling these requests.
 …
 /******************************************************************************************
  * This structure defines a chdev descriptor.
  * There is one chdev descriptor per channel.
+ * For multi-channels device, there is one chdev descriptor per channel.
  * This structure is NOT replicated, and can be located in any cluster.
  * One kernel thread, in charge of handling the commands registered in the waiting queue
 …
     uint32_t             channel;     /*! channel index                                  */
     bool_t               is_rx;       /*! relevant for NIC peripheral channels only      */
+        xptr_t               base;        /*! extended pointer on channel segment            */
+        xptr_t               base;        /*! extended pointer on channel segment paddr      */
+    char                 name[16];    /*! name (required by DEVFS)                       */
     dev_cmd_t          * cmd;         /*! local pointer on driver command function       */

trunk/kernel/kern/cluster.c

-                      r19
+                      r23
  * Author  Ghassan Almaless (2008,2009,2010,2011,2012)
  *         Mohamed Lamine Karaoui (2015)
  *         Alain Greiner (2016)
+ *         Alain Greiner (2016,2017)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
 ///////////////////////////////////////////////////////////////////////////////////////////
 process_t process_zero;     // allocated in kernel_init.c file
+extern process_t process_zero;     // allocated in kernel_init.c file
 …
     // initialise local_list in process manager
         spinlock_init( &cluster->pmgr.local_lock );
     list_root_init( &cluster->pmgr.local_root );
+        remote_spinlock_init( XPTR( local_cxy , &cluster->pmgr.local_lock ) );
+    xlist_root_init( XPTR( local_cxy , &cluster->pmgr.local_root ) );
     cluster->pmgr.local_nr = 0;
 …
+{
     cluster_t * cluster = LOCAL_CLUSTER;
         hal_atomic_inc( &cluster->cores_in_kernel );
+        hal_atomic_add( &cluster->cores_in_kernel , 1 );
+}
 …
+{
     cluster_t * cluster = LOCAL_CLUSTER;
         hal_atomic_dec( &cluster->cores_in_kernel );
+        hal_atomic_add( &cluster->cores_in_kernel , -1 );
+}
 …
 xptr_t cluster_get_reference_process_from_pid( pid_t pid )
+{
     xptr_t xp;   // extended pointer on process descriptor
+    xptr_t ref_xp;   // extended pointer on reference process descriptor
     cluster_t * cluster = LOCAL_CLUSTER;
 …
     // Check valid PID
+    if( lpid >= CONFIG_MAX_PROCESS_PER_CLUSTER )
+    {
+        printk("\n[PANIC] in %s : illegal PID\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
+    if( lpid >= CONFIG_MAX_PROCESS_PER_CLUSTER )  return XPTR_NULL;
     if( local_cxy == owner_cxy )   // local cluster is owner cluster
+    {
         xp = cluster->pmgr.pref_tbl[lpid];
+        ref_xp = cluster->pmgr.pref_tbl[lpid];
+    }
     else                              // use a remote_lwd to access owner cluster
+    {
         xp = (xptr_t)hal_remote_lwd( XPTR( owner_cxy , &cluster->pmgr.pref_tbl[lpid] ) );
+    }
     return xp;
+        ref_xp = (xptr_t)hal_remote_lwd( XPTR( owner_cxy , &cluster->pmgr.pref_tbl[lpid] ) );
+    }
+    return ref_xp;
+}
 …
 process_t * cluster_get_local_process_from_pid( pid_t pid )
+{
+    process_t    * ret     = NULL;
+    list_entry_t * root    = &LOCAL_CLUSTER->pmgr.local_root;
+    list_entry_t * iter;
+    process_t    * process;
+    LIST_FOREACH( root , iter )
+    {
+        process = LIST_ELEMENT( iter , process_t , local_list );
+        if( process->pid == pid )
+    xptr_t         process_xp;
+    process_t    * process_ptr;
+    xptr_t         root_xp;
+    xptr_t         iter_xp;
+    bool_t         found;
+    found   = false;
+    root_xp = XPTR( local_cxy , &LOCAL_CLUSTER->pmgr.local_root );
+    XLIST_FOREACH( root_xp , iter_xp )
+    {
+        process_xp  = XLIST_ELEMENT( iter_xp , process_t , local_list );
+        process_ptr = (process_t *)GET_PTR( process_xp );
+        if( process_ptr->pid == pid )
+        {
             ret = process;
+            found = true;
             break;
+        }
+    }
+    return ret;
+    if (found ) return process_ptr;
+    else        return NULL;
 }  // end cluster_get_local_process_from_pid()
 …
     // get lock protecting the process manager local list
+    spinlock_lock( &pm->local_lock );
+    list_add_first( &pm->local_root , &process->local_list );
+    remote_spinlock_lock( XPTR( local_cxy , &pm->local_lock ) );
+    xlist_add_first( XPTR( local_cxy , &pm->local_root ),
+                     XPTR( local_cxy , &process->local_list ) );
     pm->local_nr++;
     // release lock protecting the process manager local list
     spinlock_unlock( &pm->local_lock );
+    remote_spinlock_unlock( XPTR( local_cxy , &pm->local_lock ) );
+}
 …
     // get lock protecting the process manager local list
     spinlock_lock( &pm->local_lock );
     list_unlink( &process->local_list );
+    remote_spinlock_lock( XPTR( local_cxy , &pm->local_lock ) );
+    xlist_unlink( XPTR( local_cxy , &process->local_list ) );
     pm->local_nr--;
     // release lock protecting the process manager local list
     spinlock_unlock( &pm->local_lock );
+    remote_spinlock_unlock( XPTR( local_cxy , &pm->local_lock ) );
+}

trunk/kernel/kern/cluster.h

-                      r19
+                      r23
  * authors  Ghassan Almaless (2008,2009,2010,2011,2012)
  *          Mohamed Lamine Karaoui (2015)
  *          Alain Greiner (2016)
+ *          Alain Greiner (2016,2017)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
 struct core_s;
 struct process_s;
-struct device_s;
 …
  * For any process P, the process descriptor is replicated in all clusters containing
  * at least one thread of process P, but only the "reference" cluster descriptor contains
+ * the reference (complete) structures such as the GPT, the VSL, or the FDT.
+ * The "owner" cluster is in charge to allocate a lpid (local process index),
+ * for all process owned by a cluster K, and to register the "reference" cluster for
+ * all process owned by K.
+ * the reference (complete) GPT, VSL, and FDT structures.
+ * The "owner" cluster K is in charge to allocate a lpid (local process index),
+ * to the owned processes, and to register the "reference" cluster for these processes.
+ *
  * Warning : the "owner" cluster, and the "reference" cluster can be different clusters.
+ *
  * The process manager of a cluster K maintains three structures:
  * 1) The pref_tbl[] is an array indexed by lpid, for all processes owned by cluster K.
+ * 1) The pref_tbl[] is an array indexed by lpid. There is one entry per owned process.
  *    Each entry contains an extended pointer on the reference process descriptor.
+ *
  * 2) The local_root is the root of the local list of process descriptors in cluster K.
  *    A process descriptor P is present in K, as soon as P has a thread in cluster K.
+ * 3) The copies_root[] array is indexed by lpid. Each entry contains the root of
+ *    the xlist of copies for a given process owned by cluster K.
+ *
+ * 3) The copies_root[] array is indexed by lpid. There is one entry per owned process,
+ *    and each each entry contains the root of the xlist of copies for this process.
  ******************************************************************************************/
 …
     uint32_t          pref_nr;                /*! number of processes owned by cluster    */
     list_entry_t      local_root;             /*! root of list of process in cluster      */
     spinlock_t        local_lock;             /*! lock protecting access to local list    */
+    xlist_entry_t     local_root;             /*! root of list of process in cluster      */
+    remote_spinlock_t local_lock;             /*! lock protecting access to local list    */
     uint32_t          local_nr;               /*! number of process in cluster            */
 …
 typedef struct cluster_s
+{
         spinlock_t        kcm_lock;           /*! local, protect creation of KCM allocators   */
+        spinlock_t        kcm_lock;        /*! local, protect creation of KCM allocators      */
     // global parameters
         uint32_t          paddr_width;        /*! numer of bits in physical address           */
     uint32_t          x_width;            /*! number of bits to code x_size  (can be 0)   */
     uint32_t          y_width;            /*! number of bits to code y_size  (can be 0)   */
         uint32_t          x_size;             /*! number of clusters in a row    (can be 1)   */
         uint32_t          y_size;             /*! number of clusters in a column (can be 1)   */
         cxy_t             io_cxy;             /*! io cluster identifier                       */
     uint32_t          dqdt_root_level;    /*! index of root node in dqdt_tbl[]            */
+        uint32_t          paddr_width;     /*! numer of bits in physical address              */
+    uint32_t          x_width;         /*! number of bits to code x_size  (can be 0)      */
+    uint32_t          y_width;         /*! number of bits to code y_size  (can be 0)      */
+        uint32_t          x_size;          /*! number of clusters in a row    (can be 1)      */
+        uint32_t          y_size;          /*! number of clusters in a column (can be 1)      */
+        cxy_t             io_cxy;          /*! io cluster identifier                          */
+    uint32_t          dqdt_root_level; /*! index of root node in dqdt_tbl[]               */
     // local parameters
         uint32_t          cores_nr;           /*! number of cores in cluster                  */
     uint32_t          cores_in_kernel;    /*! number of cores currently in kernel mode    */
+        uint32_t          cores_nr;        /*! number of cores in cluster                     */
+    uint32_t          cores_in_kernel; /*! number of cores currently in kernel mode       */
         core_t            core_tbl[CONFIG_MAX_LOCAL_CORES];         /*! embedded cores        */
         ppm_t             ppm;                /*! embedded kernel page manager                */
         khm_t             khm;                /*! embedded kernel heap manager                */
         kcm_t             kcm;                /*! embedded kernel cache manager (for KCMs)    */
+        ppm_t             ppm;             /*! embedded kernel page manager                   */
+        khm_t             khm;             /*! embedded kernel heap manager                   */
+        kcm_t             kcm;             /*! embedded kernel cache manager (for KCMs)       */
     kcm_t           * kcm_tbl[KMEM_TYPES_NR];         /*! pointers on allocated KCMs      */
+    uint32_t          ram_size;           /*! physical memory size                        */
+    uint32_t          ram_base;           /*! physical memory base (local address)        */
+        rpc_fifo_t        rpc_fifo;           /*! cluster RPC fifo (shared)                   */
+        list_entry_t      devlist;            /*! root of list of devices in cluster          */
+    struct device_s * icu;                /*! pointer on local XCU device                 */
+    int32_t           pages_var;          /*! pages number increment from last update     */
+    int32_t           threads_var;        /*! threads number increment from last update   */
+    uint32_t          ram_size;        /*! physical memory size                           */
+    uint32_t          ram_base;        /*! physical memory base (local address)           */
+        rpc_fifo_t        rpc_fifo;        /*! cluster RPC fifo (shared)                      */
+        list_entry_t      devlist;         /*! root of list of devices in cluster             */
+    int32_t           pages_var;       /*! pages number increment from last DQQT update   */
+    int32_t           threads_var;     /*! threads number increment from last DQDT update */
         dqdt_node_t       dqdt_tbl[CONFIG_MAX_DQDT_DEPTH];     /*! embedded DQDT nodes        */
     pmgr_t            pmgr;               /*! embedded process manager                    */
+    pmgr_t            pmgr;            /*! embedded process manager                       */
         char              name[CONFIG_SYSFS_NAME_LEN];
 …
 /******************************************************************************************
  * This function returns an extended pointer on the reference process descriptor
  * from the process PID.  It can be called by any thread running in any cluster,
  * as it uses a RPC to the owner cluster if the current cluster is not the owner.
+ * from the process PID. This PID can be be different from the calling thread process.
+ * It can be called by any thread running in any cluster,
  ******************************************************************************************
  * @ pid  : process identifier.
  * @ return extended pointer on the reference process descriptor.
+ * @ return extended pointer on reference process if success / return XPTR_NULL if error.
  *****************************************************************************************/
 xptr_t cluster_get_reference_process_from_pid( pid_t pid );

trunk/kernel/kern/core.c

-                      r19
+                      r23
 #include <core.h>
-// TODO #include <sysfs.h>
 /////////////////////////////////
 void core_init( core_t    * core,
 …
 ////////////////////////////////////
 void core_get_time( core_t   * core,
                     uint32_t * tm_ms,
+                    uint32_t * tm_s,
                     uint32_t * tm_us )
+{

trunk/kernel/kern/do_syscall.c

-                      r16
+                      r23
  * do_syscall.c - architecture independant entry-point for system calls.
+ *
  * AUthor    Alain Greiner (2016)
+ * Author    Alain Greiner (2016)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
 /////////////////////////////////////////////////////////////////////////////////////////////
+// This array of pointers define the kernel functions for syscalls.
+/////////////////////////////////////////////////////////////////////////////////////////////
+static inline int sys_undefined()
+{
+    printk("\n[PANIC] in %s : undefined system call\n", __FUNCTION__ );
+    hal_core_sleep();
+    return 0;
+}
+/////////////////////////////////////////////////////////////////////////////////////////////
+// This array of pointers define the kernel functions implementing the syscalls.
 // It must be kept consistent with the enum in syscalls.h
 /////////////////////////////////////////////////////////////////////////////////////////////
 …
 static const sys_func_t syscall_tbl[SYSCALLS_NR] =
+{
+        sys_thread_exit,        // 0
+        sys_mmap,               // 1
+        sys_thread_create,      // 2
+        sys_thread_join,        // 3
+        sys_thread_detach,      // 4
+        sys_thread_yield,       // 5
+        sys_sem,                // 6
+        sys_cond_var,           // 7
+        sys_barrier,            // 8
+        sys_rwlock,             // 9
+        sys_thread_sleep,       // 10
+        sys_thread_wakeup,      // 11
+        sys_open,               // 12
+        sys_creat,              // 13
+        sys_read,               // 14
+        sys_write,              // 15
+        sys_lseek,              // 16
+        sys_close,              // 17
+        sys_unlink,             // 18
+        sys_pipe,               // 19
+        sys_chdir,              // 20
+        sys_mkdir,              // 21
+        sys_mkfifo,             // 22
+        sys_opendir,            // 23
+        sys_readdir,            // 24
+        sys_closedir,           // 25
+        sys_getcwd,             // 26
+        sys_clock,              // 27
+        sys_alarm,              // 28
+        sys_dma_memcpy,         // 29
+        sys_utls,               // 30
+        sys_notAvailable,               // 31        Reserved for sigreturn TODO  ???
+        sys_signal,             // 32
+        sys_sigreturn_setup,    // 33
+        sys_kill,               // 34
+        sys_getpid,             // 35
+        sys_fork,               // 36
+        sys_exec,               // 37
+        sys_thread_getattr,     // 38
+        sys_ps,                 // 39
+        sys_madvise,            // 40
+        sys_mcntl,              // 41
+        sys_stat,               // 42
+        sys_thread_migrate,     // 43
+        sys_sbrk,               // 44
+        sys_rmdir,              // 45
+        sys_ftime,              // 46
+        sys_chmod,              // 47
+        sys_fsync,              // 48
+        sys_gettimeofday,       // 49
+        sys_times               // 50
+    sys_thread_exit,        // 0
+    sys_mmap,               // 1
+    sys_thread_create,      // 2
+    sys_thread_join,        // 3
+    sys_thread_detach,      // 4
+    sys_thread_yield,       // 5
+    sys_sem,                // 6
+    sys_condvar,            // 7
+    sys_barrier,            // 8
+    sys_mutex,              // 9
+    sys_thread_sleep,       // 10
+    sys_thread_wakeup,      // 11
+    sys_open,               // 12
+    sys_creat,              // 13
+    sys_read,               // 14
+    sys_write,              // 15
+    sys_lseek,              // 16
+    sys_close,              // 17
+    sys_unlink,             // 18
+    sys_pipe,               // 19
+    sys_chdir,              // 20
+    sys_mkdir,              // 21
+    sys_mkfifo,             // 22
+    sys_opendir,            // 23
+    sys_readdir,            // 24
+    sys_closedir,           // 25
+    sys_getcwd,             // 26
+    sys_clock,              // 27
+    sys_alarm,              // 28
+    sys_rmdir,              // 29
+    sys_utls,               // 30
+    sys_chmod,              // 31
+    sys_signal,             // 32
+    sys_gettimeofday,       // 33
+    sys_kill,               // 34
+    sys_getpid,             // 35
+    sys_fork,               // 36
+    sys_exec,               // 37
+    sys_stat,               // 38
+    sys_trace,              // 39
 };

trunk/kernel/kern/dqdt.c

-                      r19
+                      r23
             // set child[3] extended pointer (coordinates may overflow)
+            if ( (level > 0) && ((x + (1<<(level-1))) < x_size)  && ((y + (1<<(level-1))) < y_size) )
+            if ( (level > 0) &&
+                 ((x + (1<<(level-1))) < x_size) &&
+                 ((y + (1<<(level-1))) < y_size) )
+            {
                 c_cxy = local_cxy + ((1<<(level-1))<<y_width) + (1<<(level-1));

trunk/kernel/kern/kernel_init.c

-                      r19
+                      r23
  * kernel_init.c - kernel parallel initialization
+ *
  * Authors :  Alain Greiner  (2016)
  *            Mohamed Lamine Karaoui (2016)
+ * Authors :  Mohamed Lamine Karaoui (2015)
+ *            Alain Greiner  (2016,2017)
+ *
  * Copyright (c) Sorbonne Universites
 …
 #include <vfs.h>
 #include <soclib_tty.h>
+// TODO #include <devfs.h>
+#include <devfs.h>
 // TODO #include <sysfs.h>
 …
 // @ return 0 if success / return EINVAL if not found.
 ///////////////////////////////////////////////////////////////////////////////////////////
 static error_t core_get_identifiers( boot_info_t * info,
                                      uint32_t    * lid,
+static error_t get_core_identifiers( boot_info_t * info,
+                                     lid_t       * lid,
                                      cxy_t       * cxy,
                                      gid_t       * gid )
 …
 void kernel_init( boot_info_t * info )
+{
     uint32_t     core_lid = -1;      // running core local index
+    lid_t        core_lid = -1;      // running core local index
     cxy_t        core_cxy = -1;      // running core cluster identifier
     gid_t        core_gid;           // running core hardware identifier
 …
     // all cores get core identifiers
     error = core_get_identifiers( info,
+    error = get_core_identifiers( info,
                                   &core_lid,
                                   &core_cxy,
 …
     /////////////////////////////////////////////////////////////////////////////////
     kinit_dmsg("\n[INFO] %s : core[%x][%d] exit barrier 0\n",
                __FUNCTION__ , core_cxy , core_lid );
+    kinit_dmsg("\n[INFO] %s : core[%x][%d] exit barrier 0 at cycle %d\n",
+               __FUNCTION__ , core_cxy , core_lid , hal_time_stamp() );
     // all cores check core identifiers
 …
         hal_core_sleep();
+    }
-    else
+    {
-        kinit_dmsg("\n[INFO] %s : core[%x][%d] enters at cycle %d / sp = %x\n",
-                   __FUNCTION__ , core_cxy , core_lid , hal_time_stamp() , hal_get_stack() );
+    }
     // CP0 initializes the local cluster manager (cores and memory allocators)
 …
                    __FUNCTION__ , local_cxy );
             hal_core_sleep();
+        }
-        else
+        {
-            kinit_dmsg("\n[INFO] %s : core[%x][%d] initialised cluster at cycle %d\n",
-                       __FUNCTION__ , core_cxy , core_lid , hal_time_stamp());
+        }
+    }
 …
     /////////////////////////////////////////////////////////////////////////////////
     kinit_dmsg("\n[INFO] %s : core[%x][%d] exit barrier 1\n",
                __FUNCTION__ , core_cxy , core_lid );
+    kinit_dmsg("\n[INFO] %s : core[%x][%d] exit barrier 1 at cycle %d\n",
+               __FUNCTION__ , core_cxy , core_lid , hal_time_stamp() );
     // all cores get pointer on local cluster manager and on core descriptor
 …
     /////////////////////////////////////////////////////////////////////////////////
     kinit_dmsg("\n[INFO] %s : core[%x][%d] exit barrier 2\n",
                __FUNCTION__ , core_cxy , core_lid );
+    kinit_dmsg("\n[INFO] %s : core[%x][%d] exit barrier 2 at cycle %d\n",
+               __FUNCTION__ , core_cxy , core_lid , hal_time_stamp() );
     // all cores initialize the private idle thread descriptor
 …
+    }
+    // TODO CP0 in IO cluster initialize VFS, devFS and sysFS
+    {
+            // devfs_root_init();
+            // sysfs_root_init();
+            // clusters_sysfs_register();
+        // vfs_init();
+            // sysconf_init();
+    }
+printk("\n bloup 0\n");
+    // CP0 in all clusters initializes cooperatively VFS and DEVFS
+    if( (core_lid == 0)  )
+    {
+        xptr_t  root_inode_xp;
+        // initialize root File System
+        if( CONFIG_VFS_ROOT_IS_FATFS )
+        {
+            root_inode_xp = fatfs_init();
+        }
+        else
+        {
+            printk("\n[PANIC] in %s : root FS must be FATFS\n", __FUNCTION__ );
+            hal_core_sleep();
+        }
+        if( root_inode_xp == XPTR_NULL )
+        {
+            printk("\n[PANIC] in %s : core[%x][%d] cannot initialize file system\n",
+                   __FUNCTION__ , local_cxy , core_lid );
+            hal_core_sleep();
+        }
+printk("\n bloup 1\n");
+        // mount the DEVFS File system
+            devfs_mount( root_inode_xp , "dev" );
+    }
+printk("\n bloup 2\n");
     // CP0 in I/O cluster print banner
 …
     /////////////////////////////////////////////////////////////////////////////////
     kinit_dmsg("\n[INFO] %s : core[%x][%d] exit barrier 3\n",
                __FUNCTION__ , core_cxy , core_lid );
+    kinit_dmsg("\n[INFO] %s : core[%x][%d] exit barrier 3 at cycle %d\n",
+               __FUNCTION__ , core_cxy , core_lid , hal_time_stamp() );
     // each core activates its private PTI IRQ

trunk/kernel/kern/printk.c

-                      r14
+                      r23
 extern chdev_t            txt0_chdev;        // allocated in kernel_init.c
+/////////////////////////////////////
+uint32_t snprintf( char     * string,
+                   uint32_t   length,
+                   char     * format, ... )
+{
+#define TO_STREAM(x) do { string[ps] = (x); ps++; if(ps==length) return -1; } while(0);
+    va_list    args;      // printf arguments
+    uint32_t   ps;        // write pointer to the string buffer
+    ps = 0;
+    va_start( args , format );
+xprintf_text:
+    while ( *format != 0 )
+    {
+        if (*format == '%')   // copy argument to string
+        {
+            format++;
+            goto xprintf_arguments;
+        }
+        else                  // copy one char to string
+        {
+            TO_STREAM( *format );
+            format++;
+        }
+    }
+    va_end( args );
+    // add terminating NUL chracter
+    TO_STREAM( 0 );
+    return ps;
+xprintf_arguments:
+    {
+        char              buf[30];    // buffer to display one number
+        char *            pbuf;       // pointer on first char to display
+        uint32_t          len = 0;    // number of char to display
+        static const char HexaTab[] = "0123456789ABCDEF";
+        uint32_t          i;
+        // Ignore fields width and precision
+        for ( ; (*format >= '0' && *format <= '9') || (*format == '.') ; format++ );
+        switch (*format)
+        {
+            case ('c'):             // char conversion
+            {
+                int val = va_arg( args, int );
+                buf[0] = val;
+                pbuf   = buf;
+                len    = 1;
+                break;
+            }
+            case ('d'):             // decimal signed integer
+            {
+                int val = va_arg( args, int );
+                if (val < 0)
+                {
+                    TO_STREAM( '-' );
+                    val = -val;
+                }
+                for(i = 0; i < 10; i++)
+                {
+                    buf[9 - i] = HexaTab[val % 10];
+                    if (!(val /= 10)) break;
+                }
+                len =  i + 1;
+                pbuf = &buf[9 - i];
+                break;
+            }
+            case ('u'):             // decimal unsigned integer
+            {
+                uint32_t val = va_arg( args, uint32_t );
+                for(i = 0; i < 10; i++)
+                {
+                    buf[9 - i] = HexaTab[val % 10];
+                    if (!(val /= 10)) break;
+                }
+                len =  i + 1;
+                pbuf = &buf[9 - i];
+                break;
+            }
+            case ('x'):             // 32 bits hexadecimal
+            case ('l'):             // 64 bits hexadecimal
+            {
+                uint32_t       imax;
+                uint64_t val;
+                if ( *format == 'l' )   // 64 bits
+                {
+                    val = va_arg( args, uint64_t);
+                    imax = 16;
+                }
+                else                    // 32 bits
+                {
+                    val = va_arg( args, uint32_t);
+                    imax = 8;
+                }
+                TO_STREAM( '0' );
+                TO_STREAM( 'x' );
+                for(i = 0; i < imax; i++)
+                {
+                    buf[(imax-1) - i] = HexaTab[val % 16];
+                    if (!(val /= 16))  break;
+                }
+                len =  i + 1;
+                pbuf = &buf[(imax-1) - i];
+                break;
+            }
+            case ('s'):             /* string */
+            {
+                char* str = va_arg( args, char* );
+                while (str[len]) { len++; }
+                pbuf = str;
+                break;
+            }
+            default:       // unsupported argument type
+            {
+                return -1;
+            }
+        }  // end switch on  argument type
+        format++;
+        // copy argument to string
+        for( i = 0 ; i < len ; i++ )
+        {
+            TO_STREAM( pbuf[i] );
+        }
+        goto xprintf_text;
+    }
+} // end xprintf()
 ///////////////////////////////////////////////////////////////////////////////////
 // This static function is called by kernel_printf() to display a string on the
 …
 ///////////////////////////////////////////////////////////////////////////////////
 // @ channel  : TXT channel.
 // @ busy     : TXT device acces mode.
+// @ busy     : TXT device acces mode (busy waiting if non zero).
 // @ buf      : buffer containing the characters.
 // @ nc       : number of characters.
 …
 //////////////////////////////////////////////////////////////////////////////////////
 // @ channel   : channel index.
 // @ busy      : TXT device access mode.
+// @ busy      : TXT device access mode (busy waiting if non zero).
 // @ format    : printf like format.
 // @ args      : format arguments.
 …
+}
 // Local Variables:
 // tab-width: 4

trunk/kernel/kern/printk.h

-                      r16
+                      r23
 /**********************************************************************************
+ * This function build a formated string.
+ * The supported formats are defined below :
+ *   %c : single character
+ *   %d : signed decimal 32 bits integer
+ *   %u : unsigned decimal 32 bits integer
+ *   %x : hexadecimal 32 bits integer
+ *   %l : hexadecimal 64 bits integer
+ *   %s : NUL terminated character string
+ **********************************************************************************
+ * @ string     : pointer on target buffer (allocated by caller).
+ * @ length     : target buffer length (number of bytes).
+ * @ format     : format respecting the printf syntax.
+ * @ returns the string length (including NUL) if success / return -1 if error.
+ *********************************************************************************/
+uint32_t snprintf( char     * string,
+                   uint32_t   length,
+                   char     * format, ... );
+/**********************************************************************************
  * This function displays a formated string on the kernel terminal TXT0,
  * using a busy waiting policy: It calls directly the relevant TXT driver,
 …
  * @ format     : formated string.
  *********************************************************************************/
 extern void         printk( char* format, ... );
+void         printk( char* format, ... );
 /**********************************************************************************
 …
  * @ format     : formated string.
  *********************************************************************************/
 extern void         user_printk( char* format, ... );
+void         user_printk( char* format, ... );
 /**********************************************************************************
 …
 #else
 #define sched_dmsg(...)
+#endif
+#if CONFIG_SIGNAL_DEBUG
+#define signal_dmsg(...)   printk(__VA_ARGS__)
+#else
+#define signal_dmsg(...)
 #endif

trunk/kernel/kern/process.c

-                      r14
+                      r23
  * Authors  Ghassan Almaless (2008,2009,2010,2011,2012)
  *          Mohamed Lamine Karaoui (2015)
  *          Alain Greiner (2016)
+ *          Alain Greiner (2016,2017)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
 #include <process.h>
 #include <elf.h>
+#include <syscalls.h>
 //////////////////////////////////////////////////////////////////////////////////////////
 …
                              pid_t       ppid )
+{
+    // reset signal manager  TODO [AG]
+    // reset the file descriptors array
+    // reset reference process vmm
+    vmm_init( process );
+    // reset reference process file descriptors array
         process_fd_init( process );
     // reset the process files structures and cd_lock
+    // reset reference process files structures and cd_lock
         process->vfs_root_xp     = XPTR_NULL;
+        process->vfs_bin_xp      = XPTR_NULL;
         process->vfs_cwd_xp      = XPTR_NULL;
+        process->vfs_bin_xp      = XPTR_NULL;
+    spinlock_init( &process->cd_lock );
+    remote_rwlock_init( XPTR( local_cxy , &process->cwd_lock ) );
     // reset children list root
 …
         process->children_nr     = 0;
     // reset semaphore list root
+    // reset semaphore / mutex / barrier / condvar list roots
     xlist_root_init( XPTR( local_cxy , &process->sem_root ) );
+        process->sem_nr          = 0;
+    xlist_root_init( XPTR( local_cxy , &process->mutex_root ) );
+    xlist_root_init( XPTR( local_cxy , &process->barrier_root ) );
+    xlist_root_init( XPTR( local_cxy , &process->condvar_root ) );
+    remote_spinlock_init( XPTR( local_cxy , &process->sync_lock ) );
     // register new process in the parent children list
 …
     xlist_add_first( root , entry );
     // reset th_tbl[] array
+    // reset th_tbl[] array as empty
     uint32_t i;
     for( i = 0 ; i < CONFIG_THREAD_MAX_PER_CLUSTER ; i++ )
 …
     spinlock_init( &process->th_lock );
-    // reset process VMM
-        memset( &process->vmm , 0 , sizeof(vmm_t) );
     // initialize PID and PPID
         process->pid   = pid;
     process->ppid  = ppid;
+    // set ref_xp field and is_ref flag
+    process->is_ref = true;
+    // set ref_xp field
     process->ref_xp = XPTR( local_cxy , process );
 …
     // register new process descriptor in owner cluster manager copies_list
     cluster_process_copies_link( process );
+    // initalise signal manager TODO [AG]
         hal_wbflush();
 …
                            xptr_t      reference_process_xp )
+{
+    // replicate the remote process descriptor in new process descriptor
+    xptr_t local_process_xp = XPTR( local_cxy , local_process );
+    hal_remote_memcpy( local_process_xp , reference_process_xp , sizeof(process_t) );
+    // initalise signal manager TODO [AG]
+    // initialise file descriptors array TODO [AG]
+    // initialise process files structures TODO [AG]
+    // set the ref_xp field and clear the is_ref flag
+    // get reference process cluster and local pointer
+    cxy_t       ref_cxy = GET_CXY( reference_process_xp );
+    process_t * ref_ptr = (process_t *)GET_PTR( reference_process_xp );
+    // reset local process vmm
+    vmm_init( local_process );
+    // reset process file descriptors array
+        process_fd_init( local_process );
+    // reset vfs_root_xp / vfs_bin_xp / vfs_cwd_xp fields
+    local_process->vfs_root_xp = hal_remote_lwd( XPTR( ref_cxy , &ref_ptr->vfs_root_xp ) );
+    local_process->vfs_bin_xp  = hal_remote_lwd( XPTR( ref_cxy , &ref_ptr->vfs_bin_xp ) );
+    local_process->vfs_cwd_xp  = XPTR_NULL;
+    // set the pid, ppid, ref_xp fields
+    local_process->pid    = hal_remote_lw( XPTR( ref_cxy , &ref_ptr->pid ) );
+    local_process->ppid   = hal_remote_lw( XPTR( ref_cxy , &ref_ptr->ppid ) );
     local_process->ref_xp = reference_process_xp;
-    local_process->is_ref = false;
     // reset children list root (not used in a process descriptor copy)
 …
     // reset semaphores list root (not used in a process descriptor copy)
     xlist_root_init( XPTR( local_cxy , &local_process->sem_root ) );
+    local_process->sem_nr        = 0;
+    // initialize th_tbl[] array as empty
+    xlist_root_init( XPTR( local_cxy , &local_process->mutex_root ) );
+    xlist_root_init( XPTR( local_cxy , &local_process->barrier_root ) );
+    xlist_root_init( XPTR( local_cxy , &local_process->condvar_root ) );
+    // reset th_tbl[] array as empty
     uint32_t i;
     for( i = 0 ; i < CONFIG_THREAD_MAX_PER_CLUSTER ; i++ )
 …
     spinlock_init( &local_process->th_lock );
-    // initialise  process VMM TODO [AG]
     // register new process descriptor in local cluster manager local_list
     cluster_process_local_link( local_process );
 …
     // register new process descriptor in owner cluster manager copies_list
     cluster_process_copies_link( local_process );
+    // initalise signal manager TODO [AG]
         hal_wbflush();
 …
     pmgr_t * pmgr = &LOCAL_CLUSTER->pmgr;
+    // get the lock protecting the list of local process descriptors
+    remote_spinlock_lock( XPTR( local_cxy , &pmgr->local_lock ) );
     // remove the process descriptor from local_list in local cluster manager
-    spinlock_lock( &pmgr->local_lock );
     xlist_unlink( XPTR( local_cxy , &process->local_list ) );
+    spinlock_unlock( &pmgr->local_lock );
+    // release the lock protecting the list of local process descriptors
+    remote_spinlock_unlock( XPTR( local_cxy , &pmgr->local_lock ) );
     // get extended pointer on copies_lock in owner cluster manager
 …
     // From this point, the process descriptor is unreachable
+    // close all open files and update dirty TODO [AG]
     // release signal manager TODO [AG]
+    // delete all open file descriptors
+    process_fd_destroy( process );
+    // Close bin file and decrease refcount for root and cwd
+        if( process->vfs_bin_xp != XPTR_NULL ) vfs_close( process->vfs_bin_xp , NULL );
+    // Decrease refcount for bin file, root file and cwd file
+        vfs_file_count_down( process->vfs_bin_xp );
     vfs_file_count_down( process->vfs_root_xp );
     vfs_file_count_down( process->vfs_cwd_xp );
 …
 ///////////////////////////////////////////////
 process_t * process_get_local_copy( pid_t pid )
+{
     error_t        error;
     bool_t         found;
     list_entry_t * iter;
     process_t    * process;     // pointer on local copy
+    process_t    * process_ptr;   // local pointer on process
+    xptr_t         process_xp;    // extended pointer on process
+    pid_t          process_pid;   // process identifier
     cluster_t * cluster = LOCAL_CLUSTER;
     // get lock protecting local list of processes
     spinlock_lock( &cluster->pmgr.local_lock );
+    remote_spinlock_lock( XPTR( local_cxy , &cluster->pmgr.local_lock ) );
     // scan the local list of process descriptors to find the process
+    found = false;
+    LIST_FOREACH( &cluster->pmgr.local_root , iter )
+    {
+        process = LIST_ELEMENT( iter , process_t , local_list );
+        if( process->pid == pid )
+    xptr_t  iter;
+    bool_t  found = false;
+    XLIST_FOREACH( XPTR( local_cxy , &cluster->pmgr.local_root ) , iter )
+    {
+        process_xp  = XLIST_ELEMENT( iter , process_t , local_list );
+        process_ptr = (process_t *)GET_PTR( process_xp );
+        process_pid = hal_remote_lw( XPTR( local_cxy , &process_ptr->pid ) );
+        if( process_ptr->pid == pid )
+        {
             found = true;
 …
     // release lock protecting local list of processes
     spinlock_unlock( &cluster->pmgr.local_lock );
     // allocate memory for a local process descriptor
     // and initialise it from reference if required
+    remote_spinlock_unlock( XPTR( local_cxy , &cluster->pmgr.local_lock ) );
+    // allocate memory for a new local process descriptor
+    // and initialise it from reference cluster if required
     if( !found )
+    {
         // get extended pointer on reference process descriptor
+        xptr_t reference = cluster_get_reference_process_from_pid( pid );
+        xptr_t ref_xp = cluster_get_reference_process_from_pid( pid );
+        assert( (ref_xp != XPTR_NULL) , __FUNCTION__ , "illegal pid\n" );
         // allocate memory for local process descriptor
         process = process_alloc();
         if( process == NULL )  return NULL;
+        process_ptr = process_alloc();
+        if( process_ptr == NULL )  return NULL;
         // initialize local process descriptor copy
         error = process_copy_init( process, reference );
+        error = process_copy_init( process_ptr , ref_xp );
         if( error ) return NULL;
+        // register process in global copies_list
+    }
+    return process;
+    }
+    return process_ptr;
 } // end process_get_local_copy()
 …
     remote_spinlock_init( XPTR( local_cxy , &process->fd_array.lock ) );
+    process->fd_array.max       = CONFIG_PROCESS_FILE_MAX_NR;
     process->fd_array.current   = 0;
+    process->fd_array.current = 0;
     // initialize array
     for ( fd = 0 ; fd < process->fd_array.max ; fd++ )
+    for ( fd = 0 ; fd < CONFIG_PROCESS_FILE_MAX_NR ; fd++ )
+    {
         process->fd_array.array[fd] = XPTR_NULL;
 …
+}
+//////////////////////////////////////////////
+void process_fd_destroy( process_t * process )
+{
+    uint32_t fd;
+    // loop on all open file descriptors to close all open files
+    for( fd = 0 ; fd < process->fd_array.max ; fd++ )
+    {
+        xptr_t file_xp = process->fd_array.array[fd];
+        if ( file_xp != XPTR_NULL ) vfs_close( file_xp , NULL );
+    }
+//////////////////////////////
+bool_t process_fd_array_full()
+{
+    // get extended pointer on reference process
+    xptr_t ref_xp = CURRENT_THREAD->process->ref_xp;
+    // get reference process cluster and local pointer
+    process_t * ref_ptr = (process_t *)GET_PTR( ref_xp );
+    cxy_t       ref_cxy = GET_CXY( ref_xp );
+    // get number of open file descriptors from reference fd_array
+    uint32_t current = hal_remote_lw( XPTR( ref_cxy , &ref_ptr->fd_array.current ) );
+        return ( current >= CONFIG_PROCESS_FILE_MAX_NR );
+}
-///////////////////////////////////////////////////
-bool_t process_fd_array_full( process_t * process )
+{
-        return ( process->fd_array.current >= process->fd_array.max);
+}
 /////////////////////////////////////////////////
+error_t process_fd_allocate( process_t * process,
+                             xptr_t      file_xp,
+                             uint32_t   * ret_fd )
+error_t process_fd_register(  xptr_t     file_xp,
+                              uint32_t * file_id )
+{
     bool_t    found;
+    uint32_t  fd;
+        remote_spinlock_lock( XPTR( local_cxy , &process->fd_array.lock ) );
+    uint32_t  id;
+    xptr_t    xp;
+    // get extended pointer on reference process
+    xptr_t ref_xp = CURRENT_THREAD->process->ref_xp;
+    // get reference process cluster and local pointer
+    process_t * ref_ptr = (process_t *)GET_PTR( ref_xp );
+    cxy_t       ref_cxy = GET_CXY( ref_xp );
+    // take lock protecting reference fd_array
+        remote_spinlock_lock( XPTR( ref_cxy , &ref_ptr->fd_array.lock ) );
     found   = false;
+    for ( fd = 0; fd < process->fd_array.max; fd++ )
+    {
+        if ( process->fd_array.array[fd] == XPTR_NULL )
+    for ( id = 0; id < CONFIG_PROCESS_FILE_MAX_NR ; id++ )
+    {
+        xp = hal_remote_lwd( XPTR( ref_cxy , &ref_ptr->fd_array.array[id] ) );
+        if ( xp == XPTR_NULL )
+        {
             found = true;
             process->fd_array.array[fd] = file_xp;
                 process->fd_array.current++;
                         *ret_fd = fd;
+            hal_remote_swd( XPTR( ref_cxy , &ref_ptr->fd_array.array[id] ) , file_xp );
+                hal_remote_atomic_add( XPTR( ref_cxy , &ref_ptr->fd_array.current ) , 1 );
+                        *file_id = id;
             break;
+        }
+    }
+        remote_spinlock_unlock( XPTR( local_cxy , &process->fd_array.lock ) );
+    // release lock protecting reference fd_array
+        remote_spinlock_unlock( XPTR( ref_cxy , &ref_ptr->fd_array.lock ) );
     if ( !found ) return EMFILE;
     else          return 0;
+}
+////////////////////////////////////////////////
+error_t process_fd_release( process_t * process,
+                            uint32_t    fd )
+{
+    if ( (fd < 0) || (fd > process->fd_array.max) ) return EBADF;
+    remote_spinlock_lock( XPTR( local_cxy , &process->fd_array.lock ) );
+    process->fd_array.array[fd] = XPTR_NULL;
+        process->fd_array.current--;
+        remote_spinlock_unlock( XPTR( local_cxy , &process->fd_array.lock ) );
+    return 0;
+}
+///////////////////////////////////////
+void process_fd_copy( fd_array_t * dst,
+                      fd_array_t * src )
+{
+    uint32_t fd;
+    xptr_t   entry;
+    remote_spinlock_lock( XPTR( local_cxy , &src->lock ) );
+    // loop on all entries in source process fd_array
+    for( fd = 0 ; fd < src->max ; fd++ )
+        {
+                entry = src->array[fd];
+                if( entry != XPTR_NULL )
+                {
+            // increment file descriptor ref count
+            vfs_file_count_up( entry );
+                        // copy entry in destination process fd_array
+                        dst->array[fd] = entry;
+                }
+        }
+    // release lock on source process fd_array
+        remote_spinlock_unlock( XPTR( local_cxy , &src->lock ) );
+}
+}  // end process_fd_register()
+////////////////////////////////////////////////
+xptr_t process_fd_get_xptr( process_t * process,
+                            uint32_t    file_id )
+{
+    xptr_t  file_xp;
+    // access local copy of process descriptor
+    file_xp = process->fd_array.array[file_id];
+    if( file_xp == XPTR_NULL )
+    {
+        // get reference process cluster and local pointer
+        xptr_t      ref_xp  = process->ref_xp;
+        cxy_t       ref_cxy = GET_CXY( ref_xp );
+        process_t * ref_ptr = (process_t *)GET_PTR( ref_xp );
+        // access reference process descriptor
+        file_xp = hal_remote_lwd( XPTR( ref_cxy , &ref_ptr->fd_array.array[file_id] ) );
+        // update local fd_array if found
+        if( file_xp != XPTR_NULL )
+        {
+            process->fd_array.array[file_id] = file_xp;
+        }
+    }
+    return file_xp;
+}  // end process_fd_get_xptr()
 ///////////////////////////////////////////
 …
         remote_spinlock_lock( XPTR( src_cxy , &src_ptr->lock ) );
-    // get number of entries in fd_array
-    uint32_t max = hal_remote_lw( XPTR( src_cxy , &src_ptr->max ) );
     // loop on all entries in source process fd_array
     for( fd = 0 ; fd < max ; fd++ )
+    for( fd = 0 ; fd < CONFIG_PROCESS_FILE_MAX_NR ; fd++ )
+        {
                 entry = (xptr_t)hal_remote_lwd( XPTR( src_cxy , &src_ptr->array[fd] ) );
 …
     pid   = exec_info->pid;
+    if( CXY_FROM_PID( pid ) != local_cxy )
+    {
+        printk("\n[PANIC] in %s : illegal process PID %x in cluster %x\n",
+               __FUNCTION__ , pid , local_cxy );
+        hal_core_sleep();
+    }
+    assert( (CXY_FROM_PID( pid ) == local_cxy) , __FUNCTION__ , "illegal PID\n" );
     exec_dmsg("\n[INFO] %s enters in cluster %x for process %x / path = %s\n",
 …
+        }
-    // create "stack" vseg descriptor for associated main thread
-    vseg_t * stack_vseg = vmm_create_vseg( process,
-,             // base defined by VMM
-,             // size defined by VMM
-                                           VSEG_TYPE_STACK );
-    if( stack_vseg == NULL )
+        {
-                printk("\n[ERROR] in %s : cannot create stack vseg for process %x / path = %s\n",
-                       __FUNCTION__, pid , path );
-        process_destroy( process );
-        return error;
+        }
     // select a core in cluster
     lid  = cluster_select_local_core();
 …
     // initialize pthread attributes for main thread
+    attr.pid          = pid;
+    attr.entry_func   = (void*)process->vmm.entry_point;
+    attr.entry_args   = exec_info->args_pointers;
+    attr.flags        = PT_FLAG_DETACH;             // main thread always detached
+    attr.cxy          = local_cxy;
+    attr.lid          = lid;
+    // create and initialise thread descriptor, link thread & process
+        error = thread_user_create( &thread,
+    attr.attributes = PT_ATTR_DETACH | PT_ATTR_CLUSTER_DEFINED | PT_ATTR_CORE_DEFINED;
+    attr.cxy        = local_cxy;
+    attr.lid        = lid;
+    // create and initialise thread descriptor
+        error = thread_user_create( pid,
+                                (void *)process->vmm.entry_point,
+                                exec_info->args_pointers,
                                 &attr,
+                                stack_vseg->min,
+                                stack_vseg->max - stack_vseg->min );
+                                &thread );
         if( error )
+        {
 …
+{
         process_t   * process_init;  // process_init descriptor
-        thread_t    * thread_init;   // process_init main thread descriptor
     pid_t         init_pid;      // process_init pid
     exec_info_t   exec_info;     // structure to be passed to process_make_exec()
 …
         process_zero.children_nr = 1;
+    // TODO open stdin / stdout / stderr pseudo-files
+    xptr_t  stdin_xp;
+    xptr_t  stdout_xp;
+    xptr_t  stderr_xp;
+        // error1 = vfs_open( process_init->vfs_cwd_xp, NULL, VFS_O_RDONLY, &stdin_xp );
+        // error2 = vfs_open( process_init->vfs_cwd_xp, NULL, VFS_O_WRONLY, &stdout_xp );
+        // error3 = vfs_open( process_init->vfs_cwd_xp, NULL, VFS_O_WRONLY, &stderr_xp );
+    // TODO create inodes for stdin / stdout / stderr pseudo-files
+    // these inodes should be created in the cluster containing the relevant TXT chdev
+    // open stdin / stdout / stderr pseudo-files
+    xptr_t    stdin_xp;
+    xptr_t    stdout_xp;
+    xptr_t    stderr_xp;
+    uint32_t  stdin_id;
+    uint32_t  stdout_id;
+    uint32_t  stderr_id;
+        error1 = vfs_open( XPTR_NULL, CONFIG_DEV_STDIN , O_RDONLY, 0, &stdin_xp , &stdin_id  );
+        error2 = vfs_open( XPTR_NULL, CONFIG_DEV_STDOUT, O_WRONLY, 0, &stdout_xp, &stdout_id );
+        error3 = vfs_open( XPTR_NULL, CONFIG_DEV_STDERR, O_WRONLY, 0, &stderr_xp, &stderr_id );
         if( error1 || error2 || error3 )
+        {
                 if( !error1 ) vfs_close( stdin_xp  , NULL );
                 if( !error2 ) vfs_close( stdout_xp , NULL );
                 if( !error3 ) vfs_close( stderr_xp , NULL );
+                if( !error1 ) vfs_close( stdin_xp  , stdin_id );
+                if( !error2 ) vfs_close( stdout_xp , stdout_id );
+                if( !error3 ) vfs_close( stderr_xp , stderr_id );
                 printk("\n[PANIC] in %s : cannot open stdin/stdout/stderr in cluster %x\n",
 …
+        }
+    // register stdin / stdout / stderr in the fd_array 3 first slots
+        process_init->fd_array.array[0] = stdin_xp;
+        process_init->fd_array.array[1] = stdout_xp;
+        process_init->fd_array.array[2] = stderr_xp;
+    process_init->fd_array.current  = 3;
+    // check stdin / stdout / stderr indexes
+    if( (stdin_id != 0) || (stdout_id != 1) || (stderr_id != 2) )
+    {
+                printk("\n[PANIC] in %s : bad indexes for stdin/stdout/stderr in cluster %x\n",
+            __FUNCTION__ , local_cxy );
+        hal_core_sleep();
+    }
     // initialize the exec_info structure

trunk/kernel/kern/process.h

-                      r14
+                      r23
  * Authors  Ghassan Almaless (2008,2009,2010,2011,2012)
  *          Mohamed Lamine Karaoui (2015)
  *          Alain Greiner (2016)
+ *          Alain Greiner (2016,2017)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
 /*********************************************************************************************
- * These macros are used to compose or decompose global thread identifier (TRDID)
- * to or from cluster identifier / local thread index (CXY , LTID)
- ********************************************************************************************/
-#define LTID_FROM_TRDID( trdid )   (ltid_t)(trdid & 0x0000FFFF)
-#define CXY_FROM_TRDID( trdid )    (cxy_t)(trdid >> 16)
-#define TRDID( cxy , ltid )        (trdid_t)((cxy << 16) | ltid )
-/*********************************************************************************************
  * This structure defines an array of extended pointers on the open file descriptors
  * for a given process. We use an extended pointer because the open file descriptor
 …
  * A free entry in this array contains the XPTR_NULL value.
  * The array size is defined by a the CONFIG_PROCESS_FILE_MAX_NR parameter.
+ * All modifications (open/close) must be done by the reference cluster, and reported
+ * All modifications (open/close) in this structure must be done by the reference cluster,
+ * and reported in process copies.
  ********************************************************************************************/
 …
         remote_spinlock_t lock;             /*! lock protecting fd_array[] change.              */
     uint32_t          current;          /*! current number of open files                    */
-    uint32_t          max;              /*! max number of open files (can be increased)     */
         xptr_t            array[CONFIG_PROCESS_FILE_MAX_NR];
+}
 …
  * allocated to this cluster.
  * The process descriptor for a PID process is replicated in all clusters containing
+ * at least one thread of the PID process, with some restrictions:
+ * - The list of registered vsegs, the page table (contained in vmm), and the fd_array[]
+ *   are only complete in the reference process descriptor, other copies are read-only caches.
+ * - The following fields are NOT defined in copies other than the reference:
+ *   children_root , children_list , children_nr , sig_mgr
+ * at least one thread of the PID process, with the following rules :
+ *
+ * 1) The <pid>, <ppid>, <ref_xp>, <vfs_root_xp>, <vfs_bin_xp>  fields are defined
+ *    in all process descriptor copies.
+ * 2) The <vfs_cwd_xp> and associated <cwd_lock>, that can be dynamically modified,
+ *    are only defined in the reference process descriptor.
+ * 2) The <vmm>, containing the list of registered vsegs, and the page table, are only
+ *    complete in the reference process cluster, other copies are read-only caches.
+ * 3) the <fd_array>, containing extended pointers on the open file descriptors, is only
+ *    complete in the reference process cluster, other copies are read-only caches.
+ * 4) The <sem_root>, <mutex_root>, <barrier_root>, <condvar_root>, and the associated
+ *    <sync_lock>, that are dynamically allocated, are only defined in the reference cluster.
+ * 5) The <children_root>, and <children_nr> fields are only defined in the reference
+ *    cluster, and are undefined in other clusters.
+ * 6) The <brothers_list>, <local_list>, <copies_list>, <th_tbl>, <th_nr>, <th_lock> fields
+ *    are defined in all process descriptors copies.
+ * 7) The <sig_mgr> field is only defined in the reference cluster. TODO
  ********************************************************************************************/
 typedef struct process_s
+{
+        vmm_t            vmm;               /*! embedded virtual memory manager                 */
+        fd_array_t       fd_array;          /*! embedded file descriptors array                 */
+        xptr_t           vfs_root_xp;       /*! extende pointer on current file system root     */
+        xptr_t           vfs_cwd_xp;        /*! extended pointer on current working directory   */
+        xptr_t           vfs_bin_xp;        /*! extended pointer on associate .elf file         */
+        spinlock_t       cd_lock;           /*! lock protecting working directory changes       */
+        vmm_t             vmm;              /*! embedded virtual memory manager                 */
+        fd_array_t        fd_array;         /*! embedded open file descriptors array            */
+        xptr_t            vfs_root_xp;      /*! extende pointer on current VFS root inode       */
+        xptr_t            vfs_bin_xp;       /*! extended pointer on .elf file inode             */
+        pid_t             pid;              /*! process identifier                              */
+        pid_t             ppid;             /*! parent process identifier                       */
+    xptr_t            ref_xp;           /*! extended pointer on reference process           */
+        xptr_t            vfs_cwd_xp;       /*! extended pointer on current working dir inode   */
+        remote_rwlock_t   cwd_lock;         /*! lock protecting working directory changes       */
+        pid_t            pid;               /*! process identifier                              */
+        pid_t            ppid;              /*! parent process identifier                       */
+        bool_t           is_ref;            /*! this is the reference process if true           */
+    xptr_t           ref_xp;            /*! extended pointer on reference process           */
+        xlist_entry_t    children_root;     /*! root of the children process xlist              */
+    uint32_t         children_nr;       /*! number of children processes                    */
+        xlist_entry_t    brothers_list;     /*! member of list of children of same parent       */
+    list_entry_t     local_list;        /*! member of list of process in same cluster       */
+    xlist_entry_t    copies_list;       /*! member of list of copies of same process        */
+        spinlock_t       th_lock;           /*! lock protecting th_tbl[] concurrent access      */
+        uint32_t         th_nr;             /*! number of threads in this cluster               */
+        xlist_entry_t     children_root;    /*! root of the children process xlist              */
+    uint32_t          children_nr;      /*! number of children processes                    */
+        xlist_entry_t     brothers_list;    /*! member of list of children of same parent       */
+    xlist_entry_t     local_list;       /*! member of list of process in same cluster       */
+    xlist_entry_t     copies_list;      /*! member of list of copies of same process        */
+        spinlock_t        th_lock;          /*! lock protecting th_tbl[] concurrent access      */
+        uint32_t          th_nr;            /*! number of threads in this cluster               */
         struct thread_s * th_tbl[CONFIG_THREAD_MAX_PER_CLUSTER]; /*! pointers on local threads  */
+    xlist_entry_t    sem_root;          /*! root of the process semaphores list             */
+    uint32_t         sem_nr;            /*! number of semaphores                            */
+        sig_mgr_t        sig_mgr;           /*! embedded signal manager TODO [AG]               */
+    xlist_entry_t     sem_root;         /*! root of the process semaphore list              */
+    xlist_entry_t     mutex_root;       /*! root of the process mutex list                  */
+    xlist_entry_t     barrier_root;     /*! root of the process barrier list                */
+    xlist_entry_t     condvar_root;     /*! root of the process condvar list                */
+    remote_spinlock_t sync_lock;        /*! lock protecting sem,mutex,barrier,condvar lists */
+        sig_mgr_t         sig_mgr;          /*! embedded signal manager TODO [AG]               */
+}
 process_t;
 …
     xptr_t             vfs_bin_xp;     /*! extended pointer on process .elf file            */
     char               path[256];      /*! pathname for  .elf file                          */
+    char               path[CONFIG_VFS_MAX_PATH_LENGTH];   /*!  .elf file path              */
     char            ** args_pointers;  /*! physical base address of array of pointers       */
 …
 exec_info_t;
-/*********************************************************************************************
- * This macro returns a pointer on the process descriptor for the calling thread.
- ********************************************************************************************/
-#define CURRENT_PROCESS (hal_get_current_thread()->process)
 /***************   Process Descriptor Operations    *****************************************/
 …
  * The PID value must have been defined previously by the owner cluster manager.
  * The reference cluster can be different from the owner cluster.
  * It set the pid / ppid / is_ref / pref / fields.
+ * It set the pid / ppid / ref_xp fields.
  * It registers this process descriptor in three lists:
  * - the children_list in the parent process descriptor.
 …
 /*********************************************************************************************
  * This function releases all memory allocated for a process descriptor in the local cluster,
  * after releasing memory allocated for embedded substructures (fd_array, vmm, etc).
+ * including memory allocated for embedded substructures (fd_array, vmm, etc).
  * The local th_tbl[] array must be empty.
  *********************************************************************************************
 …
  * If this local copy does not exist yet, it is dynamically created, from the reference
  * process descriptor, registered in the global copies_list, and registered in the local_list.
  * This function is used by both thread_user_create() and thread_user_copy() functions.
+ * This function is used by the thread_user_create() function.
  *********************************************************************************************
  * @ pid     : searched process identifier.
 …
 /*********************************************************************************************
  * This function reset the file descriptor array for a given process: no open file.
+ * This function initialises all entries of the local fd_array as empty.
  *********************************************************************************************
  * @ process  : pointer on the local process descriptor.
 …
 /*********************************************************************************************
+ * This function closes all open files and releases all file descriptors.
+ * This function uses as many remote accesses as required, to reset an entry in fd_array[],
+ * in all clusters containing a copy. The entry is identified by the <file_id> argument.
+ * This function must be executed by a thread running reference cluster, that contain
+ * the complete list of process descriptors copies.
  *********************************************************************************************
  * @ process  : pointer on the local process descriptor.
+ ********************************************************************************************/
+void process_fd_destroy( process_t * process );
+ * @ file_id  : file descriptor index in the fd_array.
+ ********************************************************************************************/
+void process_fd_remove( process_t * process,
+                        uint32_t    file_id );
+/*********************************************************************************************
+ * This function returns an extended pointer on a file descriptor identified by its index
+ * in fd_array. It can be called by any thread running in any cluster.
+ * It access first the local process descriptor. In case of local miss, it uses remote access
+ * to access the reference process descriptor.
+ * It updates the local fd_array when the file descriptor exist in reference cluster.
+ * The file descriptor refcount is not incremented.
+ *********************************************************************************************
+ * @ process  : pointer on the local process descriptor.
+ * @ file_id  : file descriptor index in the fd_array.
+ * @ return extended pointer on file descriptor if success / return XPTR_NULL if not found.
+ ********************************************************************************************/
+xptr_t process_fd_get_xptr( process_t * process,
+                            uint32_t    file_id );
 /*********************************************************************************************
  * This function checks the number of open files for a given process.
+ *********************************************************************************************
+ * @ process  : pointer on the local process descriptor.
+ * It can be called by any thread in any cluster, because it uses portable remote access
+ * primitives to access the reference process descriptor.
+ *********************************************************************************************
  * @ returns true if file descriptor array full.
  ********************************************************************************************/
+bool_t process_fd_array_full( process_t * process );
+/*********************************************************************************************
+ * These functions allocates a slot in the fd_array for a given process,
+ * and returns the file descriptor index.
+ *********************************************************************************************
+ * @ process  : pointer on the local process descriptor.
+ * @ file     : extended pointer on the file descriptor.
+ * @ fd       : [out] file descriptor index
+bool_t process_fd_array_full();
+/*********************************************************************************************
+ * This function allocates a free slot in the fd_array of the reference process,
+ * register the <file_xp> argument in the allocated slot, and return the slot index.
+ * It can be called by any thread in any cluster, because it uses portable remote access
+ * primitives to access the reference process descriptor.
+ *********************************************************************************************
+ * @ file_xp  : extended pointer on the file descriptor to be registered.
+ * @ file_id  : [out] buffer for fd_array slot index.
  * @ return 0 if success / return EMFILE if array full.
  ********************************************************************************************/
+error_t process_fd_allocate( process_t * process,
+                             xptr_t      file_xp,
+                             uint32_t  * fd );
+/*********************************************************************************************
+ * This function releases an existing file descriptor from the process fd_array.
+ *********************************************************************************************
+ * @ process  : pointer on the local process descriptor.
+ * @ return 0 if success / return EBADF if illegal file descriptor.
+ ********************************************************************************************/
+error_t process_fd_release( process_t * process,
+                            uint32_t    fd );
+/*********************************************************************************************
+ * This function copies all non-zero entries from a local <src> fd_array,
+ * embedded in a process descriptor, to another local <dst_xp> fd_array, embedded
+ * in another process descriptor.
+ * It takes the remote lock protecting the <src> fd_array during the copy.
+ * For each involved file descriptor, the refcount is incremented.
+ *********************************************************************************************
+ * @ dst   : pointer on the destination fd_array_t.
+ * @ src   : pointer on the source fd_array_t.
+ ********************************************************************************************/
+void process_fd_local_copy( fd_array_t * dst,
+                            fd_array_t * src );
+error_t process_fd_register( xptr_t      file_xp,
+                             uint32_t  * file_id );
 /*********************************************************************************************
 …
 /********************   Thread Related Operations   *****************************************/

trunk/kernel/kern/rpc.c

-                      r16
+                      r23
  * rpc.c - RPC related operations implementation.
+ *
+ * Authors Mohamed Lamine Karaoui (2015)
+ *         Alain Greiner (2016)
+ * Author    Alain Greiner (2016,2017)
+ *
  * Copyright (c)  UPMC Sorbonne Universites
 …
 #include <vfs.h>
 #include <fatfs.h>
+#include <signal.h>
 #include <dev_icu.h>
 #include <rpc.h>
 …
     &rpc_thread_user_create_server,     // 4
     &rpc_thread_kernel_create_server,   // 5
     &rpc_undefined,                     // 6
+    &rpc_signal_rise_server,            // 6
     &rpc_undefined,                     // 7
     &rpc_undefined,                     // 8
 …
     &rpc_vfs_dentry_create_server,      // 12
     &rpc_vfs_dentry_destroy_server,     // 13
     &rpc_undefined,                     // 14
     &rpc_undefined,                     // 15
     &rpc_undefined,                     // 16
+    &rpc_vfs_file_create_server,        // 14
+    &rpc_vfs_file_destroy_server,       // 15
+    &rpc_fatfs_get_cluster_server,      // 16
     &rpc_undefined,                     // 17
     &rpc_undefined,                     // 18
 …
     &rpc_vmm_get_ref_vseg_server,       // 20
     &rpc_vmm_get_pte_server,            // 21
     &rpc_semaphore_alloc_server,        // 22
     &rpc_semaphore_free_server,         // 23
+    &rpc_kcm_alloc_server,              // 22
+    &rpc_kcm_free_server,               // 23
     &rpc_mapper_move_server,            // 24
     &rpc_undefined,                     // 25
 …
     &rpc_undefined,                     // 28
     &rpc_undefined,                     // 29
-    &rpc_fatfs_get_cluster_server       // 30
 };
 …
 /////////////////////////////////////////////////////////////////////////////////////////
 //               Marshaling functions attached to RPC_PMEM_GET_PAGES
+// [0]           Marshaling functions attached to RPC_PMEM_GET_PAGES
 /////////////////////////////////////////////////////////////////////////////////////////
 …
 /////////////////////////////////////////////////////////////////////////////////////////
 //               Marshaling functions attached to RPC_PROCESS_PID_ALLOC
+// [1]           Marshaling functions attached to RPC_PROCESS_PID_ALLOC
 /////////////////////////////////////////////////////////////////////////////////////////
 …
 /////////////////////////////////////////////////////////////////////////////////////////
 //               Marshaling functions attached to RPC_PROCESS_EXEC
+// [2]           Marshaling functions attached to RPC_PROCESS_EXEC
 /////////////////////////////////////////////////////////////////////////////////////////
 …
 /////////////////////////////////////////////////////////////////////////////////////////
 //               Marshaling functions attached to RPC_PROCESS_KILL
+// [3]           Marshaling functions attached to RPC_PROCESS_KILL
 /////////////////////////////////////////////////////////////////////////////////////////
 …
+{
     // only reference cluster can send this RPC
     if( !process->is_ref )
+    if( GET_CXY( process->ref_xp ) != local_cxy )
+    {
         printk("PANIC in %s : caller is not the reference process\n", __FUNCTION__ );
 …
 /////////////////////////////////////////////////////////////////////////////////////////
 //               Marshaling functions attached to RPC_THREAD_USER_CREATE
+// [4]           Marshaling functions attached to RPC_THREAD_USER_CREATE
 /////////////////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////
 void rpc_thread_user_create_client( cxy_t            cxy,
+                                    pid_t            pid,         // in
+                                    void           * start_func,  // in
+                                    void           * start_arg,   // in
                                     pthread_attr_t * attr,        // in
                                     xptr_t         * thread_xp,   // out
 …
     // set input arguments in RPC descriptor
+    rpc.args[0] = (uint64_t)(intptr_t)attr;
+    rpc.args[0] = (uint64_t)pid;
+    rpc.args[1] = (uint64_t)(intptr_t)start_func;
+    rpc.args[2] = (uint64_t)(intptr_t)start_arg;
+    rpc.args[3] = (uint64_t)(intptr_t)attr;
     // register RPC request in remote RPC fifo
 …
     // get output arguments from RPC descriptor
     *thread_xp = (xptr_t)rpc.args[1];
     *error     = (error_t)rpc.args[2];
+    *thread_xp = (xptr_t)rpc.args[4];
+    *error     = (error_t)rpc.args[5];
+}
 …
     thread_t       * thread_ptr; // local pointer on thread descriptor
     xptr_t           thread_xp;  // extended pointer on thread descriptor
     pid_t            pid;        // process identifier
+    process_t      * process;    // local pointer on process descriptor
+    vseg_t         * vseg;       // local pointer on stack vseg
+    error_t          error = 0;
+    void           * start_func;
+    void           * start_arg;
+    error_t          error;
     // get client cluster identifier and pointer on RPC descriptor
 …
     // get pointer on attributes structure in client cluster from RPC descriptor
+    attr_ptr = (pthread_attr_t *)(intptr_t)hal_remote_lwd( XPTR(client_cxy , &desc->args[0]) );
+    // get input arguments from RPC descriptor
+    pid        = (pid_t)                     hal_remote_lwd(XPTR(client_cxy , &desc->args[0]));
+    start_func = (void *)(intptr_t)          hal_remote_lwd(XPTR(client_cxy , &desc->args[1]));
+    start_arg  = (void *)(intptr_t)          hal_remote_lwd(XPTR(client_cxy , &desc->args[2]));
+    attr_ptr   = (pthread_attr_t *)(intptr_t)hal_remote_lwd(XPTR(client_cxy , &desc->args[3]));
     // makes a local copy of attributes structure
 …
                        sizeof(pthread_attr_t) );
+    if( attr_copy.cxy != local_cxy )
+    {
+        printk("\n[PANIC] in %s : target cluster = %X / local_cluster = %x\n",
+               __FUNCTION__ , attr_copy.cxy , local_cxy );
+        hal_core_sleep();
+    }
+    // get local process descriptor
+    pid     = attr_copy.pid;
+    process = cluster_get_local_process_from_pid( pid );
+    if( process == NULL )
+    {
+        printk("\n[ERROR] in %s : no process descriptor in cluster %x for pid = %x\n",
+               __FUNCTION__ , local_cxy , pid );
+        error = ENOMEM;
+    }
+    // allocate a stack from local VMM
+    vseg = vmm_create_vseg( process,
+,
+,
+                            VSEG_TYPE_STACK );
+    if( vseg == NULL )
+    {
+        printk("\n[ERROR] in %s : cannot create stack vseg in cluster %x for pid %x\n",
+               __FUNCTION__ , local_cxy , pid );
+        error = ENOMEM;
+    }
+    // create thread in local cluster
+    if( thread_user_create( &thread_ptr,
+                            &attr_copy,
+                            vseg->min,
+                            vseg->max - vseg->min ) ) error = ENOMEM;
+    assert( (attr_copy.cxy == local_cxy) , __FUNCTION__ , "bad target cluster\n" );
+    // call kernel function
+    error = thread_user_create( pid,
+                                start_func,
+                                start_arg,
+                                &attr_copy,
+                                &thread_ptr );
     // set output arguments
 …
 /////////////////////////////////////////////////////////////////////////////////////////
 //               Marshaling functions attached to RPC_THREAD_KERNEL_CREATE
+// [5]           Marshaling functions attached to RPC_THREAD_KERNEL_CREATE
 /////////////////////////////////////////////////////////////////////////////////////////
 …
 /////////////////////////////////////////////////////////////////////////////////////////
+//               Marshaling functions attached to RPC_VFS_INODE_CREATE
+// [6]           Marshaling functions attached to RPC_SIGNAL_RISE
+/////////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////
+void rpc_signal_rise_client( cxy_t       cxy,
+                             process_t * process,    // in
+                             uint32_t    sig_id )    // in
+{
+    // RPC must be remote
+    if( cxy == local_cxy )
+    {
+        printk("PANIC in %s : target is not remote\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
+    // initialise RPC descriptor header
+    rpc_desc_t  rpc;
+    rpc.index    = RPC_SIGNAL_RISE;
+    rpc.response = 1;
+    // set input arguments in RPC descriptor
+    rpc.args[0] = (uint64_t)(intptr_t)process;
+    rpc.args[1] = (uint64_t)sig_id;
+    // register RPC request in remote RPC fifo
+    rpc_send_sync( cxy , &rpc );
+}
+////////////////////////////////////////
+void rpc_signal_rise_server( xptr_t xp )
+{
+    process_t  * process;  // local pointer on process descriptor
+    uint32_t     sig_id;   // signal index
+    // get client cluster identifier and pointer on RPC descriptor
+    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
+    rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
+    // get attributes from RPC descriptor
+    process = (process_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
+    sig_id  = (uint32_t)             hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
+    // call local kernel function
+    signal_rise( process , sig_id );
+}
+/////////////////////////////////////////////////////////////////////////////////////////
+// [10]          Marshaling functions attached to RPC_VFS_INODE_CREATE
 /////////////////////////////////////////////////////////////////////////////////////////
 …
 void rpc_vfs_inode_create_client( cxy_t          cxy,
                                   xptr_t         dentry_xp,  // in
+                                  uint32_t       type,       // in
+                                  uint32_t       fs_type,    // in
+                                  uint32_t       inode_type, // in
                                   uint32_t       attr,       // in
                                   uint32_t       mode,       // in
+                                  uint32_t       rights,     // in
                                   uint32_t       uid,        // in
                                   uint32_t       gid,        // in
 …
     // set input arguments in RPC descriptor
     rpc.args[0] = (uint64_t)dentry_xp;
+    rpc.args[1] = (uint64_t)type;
+    rpc.args[2] = (uint64_t)attr;
+    rpc.args[3] = (uint64_t)mode;
+    rpc.args[4] = (uint64_t)uid;
+    rpc.args[5] = (uint64_t)gid;
+    rpc.args[1] = (uint64_t)fs_type;
+    rpc.args[2] = (uint64_t)inode_type;
+    rpc.args[3] = (uint64_t)attr;
+    rpc.args[4] = (uint64_t)rights;
+    rpc.args[5] = (uint64_t)uid;
+    rpc.args[6] = (uint64_t)gid;
     // register RPC request in remote RPC fifo (blocking function)
 …
     // get output values from RPC descriptor
     *inode_xp = (xptr_t)rpc.args[6];
     *error    = (error_t)rpc.args[7];
+    *inode_xp = (xptr_t)rpc.args[7];
+    *error    = (error_t)rpc.args[8];
+}
 …
+{
     xptr_t           dentry_xp;
+    uint32_t         type;
+    uint32_t         fs_type;
+    uint32_t         inode_type;
     uint32_t         attr;
     uint32_t         mode;
+    uint32_t         rights;
     uint32_t         uid;
     uint32_t         gid;
 …
     // get input arguments from client rpc descriptor
+    dentry_xp = (xptr_t)  hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
+    type      = (uint32_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
+    attr      = (uint32_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[2] ) );
+    mode      = (uint32_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[3] ) );
+    uid       = (uid_t)   hal_remote_lwd( XPTR( client_cxy , &desc->args[4] ) );
+    gid       = (gid_t)   hal_remote_lwd( XPTR( client_cxy , &desc->args[5] ) );
+    dentry_xp  = (xptr_t)  hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
+    fs_type    = (uint32_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
+    inode_type = (uint32_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[2] ) );
+    attr       = (uint32_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[3] ) );
+    rights     = (uint32_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[4] ) );
+    uid        = (uid_t)   hal_remote_lwd( XPTR( client_cxy , &desc->args[5] ) );
+    gid        = (gid_t)   hal_remote_lwd( XPTR( client_cxy , &desc->args[6] ) );
     // call local kernel function
     error = vfs_inode_create( dentry_xp,
+                              type,
+                              fs_type,
+                              inode_type,
                               attr,
                               mode,
+                              rights,
                               uid,
                               gid,
 …
     // set output arguments
     hal_remote_swd( XPTR( client_cxy , &desc->args[6] ) , (uint64_t)inode_xp );
     hal_remote_swd( XPTR( client_cxy , &desc->args[7] ) , (uint64_t)error );
+}
 /////////////////////////////////////////////////////////////////////////////////////////
 //               Marshaling functions attached to RPC_VFS_INODE_DESTROY
+    hal_remote_swd( XPTR( client_cxy , &desc->args[7] ) , (uint64_t)inode_xp );
+    hal_remote_swd( XPTR( client_cxy , &desc->args[8] ) , (uint64_t)error );
+}
+/////////////////////////////////////////////////////////////////////////////////////////
+// [11]          Marshaling functions attached to RPC_VFS_INODE_DESTROY
 /////////////////////////////////////////////////////////////////////////////////////////
 …
 /////////////////////////////////////////////////////////////////////////////////////////
 //               Marshaling functions attached to RPC_VFS_DENTRY_CREATE
+// [12]          Marshaling functions attached to RPC_VFS_DENTRY_CREATE
 /////////////////////////////////////////////////////////////////////////////////////////
 …
 /////////////////////////////////////////////////////////////////////////////////////////
 //               Marshaling functions attached to RPC_VFS_DENTRY_DESTROY
+// [13]          Marshaling functions attached to RPC_VFS_DENTRY_DESTROY
 /////////////////////////////////////////////////////////////////////////////////////////
 …
 /////////////////////////////////////////////////////////////////////////////////////////
+//               Marshaling functions attached to RPC_VMM_GET_REF_VSEG
+// [14]          Marshaling functions attached to RPC_VFS_FILE_CREATE
+/////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////
+void rpc_vfs_file_create_client( cxy_t                  cxy,
+                                 struct vfs_inode_s   * inode,       // in
+                                 uint32_t               file_attr,   // in
+                                 xptr_t               * file_xp,     // out
+                                 error_t              * error )      // out
+{
+    // RPC must be remote
+    if( cxy == local_cxy )
+    {
+        printk("PANIC in %s : target cluster is not remote\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
+    // initialise RPC descriptor header
+    rpc_desc_t  rpc;
+    rpc.index    = RPC_VFS_FILE_CREATE;
+    rpc.response = 1;
+    // set input arguments in RPC descriptor
+    rpc.args[0] = (uint64_t)(intptr_t)inode;
+    rpc.args[1] = (uint64_t)file_attr;
+    // register RPC request in remote RPC fifo (blocking function)
+    rpc_send_sync( cxy , &rpc );
+    // get output values from RPC descriptor
+    *file_xp = (xptr_t)rpc.args[2];
+    *error   = (error_t)rpc.args[3];
+}
+////////////////////////////////////////////
+void rpc_vfs_file_create_server( xptr_t xp )
+{
+    uint32_t      file_attr;
+    vfs_inode_t * inode;
+    xptr_t        file_xp;
+    error_t       error;
+    // get client cluster identifier and pointer on RPC descriptor
+    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
+    rpc_desc_t * desc        = (rpc_desc_t *)GET_PTR( xp );
+    // get arguments "file_attr" and "inode" from client RPC descriptor
+    inode     = (vfs_inode_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
+    file_attr = (uint32_t)               hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
+    // call local kernel function
+    error = vfs_file_create( inode,
+                             file_attr,
+                             &file_xp );
+    // set output arguments
+    hal_remote_swd( XPTR( client_cxy , &desc->args[2] ) , (uint64_t)file_xp );
+    hal_remote_swd( XPTR( client_cxy , &desc->args[3] ) , (uint64_t)error );
+}
+/////////////////////////////////////////////////////////////////////////////////////////
+// [15]          Marshaling functions attached to RPC_VFS_FILE_DESTROY
+/////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////
+void rpc_vfs_file_destroy_client( cxy_t        cxy,
+                                  vfs_file_t * file )
+{
+    // RPC must be remote
+    if( cxy == local_cxy )
+    {
+        printk("PANIC in %s : target cluster is not remote\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
+    // initialise RPC descriptor header
+    rpc_desc_t  rpc;
+    rpc.index    = RPC_VFS_FILE_DESTROY;
+    rpc.response = 1;
+    // set input arguments in RPC descriptor
+    rpc.args[0] = (uint64_t)(intptr_t)file;
+    // register RPC request in remote RPC fifo (blocking function)
+    rpc_send_sync( cxy , &rpc );
+}
+/////////////////////////////////////////////
+void rpc_vfs_file_destroy_server( xptr_t xp )
+{
+    vfs_file_t * file;
+    // get client cluster identifier and pointer on RPC descriptor
+    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
+    rpc_desc_t * desc        = (rpc_desc_t *)GET_PTR( xp );
+    // get arguments "dentry" from client RPC descriptor
+    file = (vfs_file_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
+    // call local kernel function
+    vfs_file_destroy( file );
+}
+/////////////////////////////////////////////////////////////////////////////////////////
+// [16]          Marshaling functions attached to RPC_FATFS_GET_CLUSTER
+/////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////
+void rpc_fatfs_get_cluster_client( cxy_t      cxy,
+                                   mapper_t * mapper,    // in
+                                   uint32_t   first,     // in
+                                   uint32_t   page,      // in
+                                   uint32_t * cluster,   // out
+                                   error_t  * error )    // out
+{
+    // RPC must be remote
+    if( cxy == local_cxy )
+    {
+        printk("PANIC in %s : target is not remote\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
+    // initialise RPC descriptor header
+    rpc_desc_t  rpc;
+    rpc.index    = RPC_FATFS_GET_CLUSTER;
+    rpc.response = 1;
+    // set input arguments in RPC descriptor
+    rpc.args[0] = (uint64_t)(intptr_t)mapper;
+    rpc.args[1] = (uint64_t)first;
+    rpc.args[2] = (uint64_t)page;
+    // register RPC request in remote RPC fifo
+    rpc_send_sync( cxy , &rpc );
+    // get output argument from rpc descriptor
+    *cluster = (uint32_t)rpc.args[3];
+    *error   = (error_t)rpc.args[4];
+}
+//////////////////////////////////////////////
+void rpc_fatfs_get_cluster_server( xptr_t xp )
+{
+    mapper_t    * mapper;
+    uint32_t      first;
+    uint32_t      page;
+    uint32_t      cluster;
+    error_t       error;
+    // get client cluster identifier and pointer on RPC descriptor
+    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
+    rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
+    // get input arguments
+    mapper = (mapper_t *)(intptr_t)hal_remote_lpt( XPTR( client_cxy , &desc->args[0] ) );
+    first  = (uint32_t)            hal_remote_lw ( XPTR( client_cxy , &desc->args[1] ) );
+    page   = (uint32_t)            hal_remote_lw ( XPTR( client_cxy , &desc->args[2] ) );
+    // call the kernel function
+    error = fatfs_get_cluster( mapper , first , page , &cluster );
+    // set output argument
+    hal_remote_swd( XPTR( client_cxy , &desc->args[3] ) , (uint64_t)cluster );
+    hal_remote_swd( XPTR( client_cxy , &desc->args[4] ) , (uint64_t)error );
+}
+/////////////////////////////////////////////////////////////////////////////////////////
+// [20]          Marshaling functions attached to RPC_VMM_GET_REF_VSEG
 /////////////////////////////////////////////////////////////////////////////////////////
 …
 /////////////////////////////////////////////////////////////////////////////////////////
 //               Marshaling functions attached to RPC_VMM_GET_PTE
+// [21]          Marshaling functions attached to RPC_VMM_GET_PTE
 /////////////////////////////////////////////////////////////////////////////////////////
 …
 /////////////////////////////////////////////////////////////////////////////////////////
+//               Marshaling functions attached to RPC_SEMAPHORE_ALLOC
+/////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////
+void rpc_semaphore_alloc_client( cxy_t    cxy,
+                                 xptr_t * sem_xp )     // out
+// [22]          Marshaling functions attached to RPC_KCM_ALLOC
+/////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////
+void rpc_kcm_alloc_client( cxy_t      cxy,
+                           uint32_t   kmem_type,   // in
+                           xptr_t *   buf_xp )     // out
+{
     // RPC must be remote
 …
     rpc.response = 1;
+    // set input arguments in RPC descriptor
+    rpc.args[0] = (uint64_t)kmem_type;
     // register RPC request in remote RPC fifo
     rpc_send_sync( cxy , &rpc );
     // get output arguments from RPC descriptor
     *sem_xp = (xptr_t)rpc.args[0];
+}
 ////////////////////////////////////////////
 void rpc_semaphore_alloc_server( xptr_t xp )
+    *buf_xp = (xptr_t)rpc.args[1];
+}
+//////////////////////////////////////
+void rpc_kcm_alloc_server( xptr_t xp )
+{
     // get client cluster identifier and pointer on RPC descriptor
 …
     rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
+    // allocates memory for semaphore
+    // get input argument "kmem_type" from client RPC descriptor
+    uint32_t kmem_type = (uint32_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
+    // allocates memory for kcm
     kmem_req_t  req;
     req.type  = KMEM_SEM;
+    req.type  = kmem_type;
     req.flags = AF_ZERO;
     remote_sem_t * sem_ptr = kmem_alloc( &req );
+    void * buf_ptr = kmem_alloc( &req );
     // set output argument
     xptr_t sem_xp = XPTR( local_cxy , sem_ptr );
     hal_remote_swd( XPTR( client_cxy , &desc->args[0] ) , (uint64_t)sem_xp );
+    xptr_t buf_xp = XPTR( local_cxy , buf_ptr );
+    hal_remote_swd( XPTR( client_cxy , &desc->args[1] ) , (uint64_t)buf_xp );
+}
 /////////////////////////////////////////////////////////////////////////////////////////
+//               Marshaling functions attached to RPC_SEMAPHORE_FREE
+/////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////
+void rpc_semaphore_free_client( cxy_t          cxy,
+                                remote_sem_t * sem )   // in
+// [23]          Marshaling functions attached to RPC_KCM_FREE
+/////////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////
+void rpc_kcm_free_client( cxy_t      cxy,
+                          void     * buf,          // in
+                          uint32_t   kmem_type )   // in
+{
     // RPC must be remote
 …
     // set input arguments in RPC descriptor
+    rpc.args[0] = (uint64_t)(intptr_t)sem;
+    rpc.args[0] = (uint64_t)(intptr_t)buf;
+    rpc.args[1] = (uint64_t)kmem_type;
     // register RPC request in remote RPC fifo
 …
+}
 ///////////////////////////////////////////
 void rpc_semaphore_free_server( xptr_t xp )
+/////////////////////////////////////
+void rpc_kcm_free_server( xptr_t xp )
+{
     // get client cluster identifier and pointer on RPC descriptor
 …
     rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
+    // get input argument "sem_ptr" from client RPC descriptor
+    void * sem = (void *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
+    // get input arguments "buf" and "kmem_type" from client RPC descriptor
+    void     * buf = (void *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
+    uint32_t   kmem_type = (uint32_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
     // releases memory
     kmem_req_t  req;
     req.type = KMEM_SEM;
     req.ptr  = sem;
     kmem_free(&req);
+    req.type = kmem_type;
+    req.ptr  = buf;
+    kmem_free( &req );
+}
 /////////////////////////////////////////////////////////////////////////////////////////
+//               Marshaling functions attached to RPC_MAPPER_MOVE
+/////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////
+void rpc_mapper_move_client( cxy_t        cxy,
+                             mapper_t   * mapper,      // in
+                             bool_t       read,        // in
+                             uint32_t     nb_frags,    // in
+                             fragment_t * frags,       // in
+                             error_t    * error )      // out
+{
+    // RPC must be remote
+    if( cxy == local_cxy )
+    {
+        printk("PANIC in %s : target is not remote\n", __FUNCTION__ );
+// [24]          Marshaling functions attached to RPC_MAPPER_MOVE
+/////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////
+void rpc_mapper_move_client( cxy_t      cxy,
+                             mapper_t * mapper,        // in
+                             uint32_t   to_buffer,     // in
+                             uint32_t   file_offset,   // in
+                             void     * buffer,        // in
+                             uint32_t   size,          // in
+                             error_t  * error )        // out
+{
+    // RPC must be remote
+    if( cxy == local_cxy )
+    {
+        printk("PANIC in %s : target cluster is not remote\n", __FUNCTION__ );
         hal_core_sleep();
+    }
 …
     // set input arguments in RPC descriptor
     rpc.args[0] = (uint64_t)(intptr_t)mapper;
+    rpc.args[1] = (uint64_t)read;
+    rpc.args[2] = (uint64_t)nb_frags;
+    rpc.args[3] = (uint64_t)(intptr_t)frags;
+    // register RPC request in remote RPC fifo
+    rpc_send_sync( cxy , &rpc );
+    // get output argument from rpc descriptor
+    *error = (error_t)rpc.args[4];
+    rpc.args[1] = (uint64_t)to_buffer;
+    rpc.args[2] = (uint64_t)file_offset;
+    rpc.args[3] = (uint64_t)(intptr_t)buffer;
+    rpc.args[4] = (uint64_t)size;
+    // register RPC request in remote RPC fifo (blocking function)
+    rpc_send_sync( cxy , &rpc );
+    // get output values from RPC descriptor
+    *error     = (error_t)rpc.args[5];
+}
 …
 void rpc_mapper_move_server( xptr_t xp )
+{
+    mapper_t    * mapper;
+    bool_t        read;
+    uint32_t      nb;
+    void        * frags;
+    error_t       error;
+    // get client cluster identifier and pointer on RPC descriptor
+    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
+    rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
+    // get input arguments
+    mapper = (mapper_t*)(intptr_t)hal_remote_lpt( XPTR( client_cxy , &desc->args[0] ) );
+    read   = (bool_t)             hal_remote_lw ( XPTR( client_cxy , &desc->args[1] ) );
+    nb     = (uint32_t)           hal_remote_lw ( XPTR( client_cxy , &desc->args[2] ) );
+    frags  = (void*)(intptr_t)    hal_remote_lpt( XPTR( client_cxy , &desc->args[3] ) );
+    // call the mapper_move_fragments() function
+    error = mapper_move_fragments( mapper , read , nb , XPTR( client_cxy , frags ) );
+    // set output argument
+    hal_remote_swd( XPTR( client_cxy , &desc->args[4] ) , (uint64_t)error );
+}
+/////////////////////////////////////////////////////////////////////////////////////////
+//               Marshaling functions attached to RPC_FATFS_GET_CLUSTER
+/////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////
+void rpc_fatfs_get_cluster_client( cxy_t      cxy,
+                                   mapper_t * mapper,    // in
+                                   uint32_t   first,     // in
+                                   uint32_t   page,      // in
+                                   uint32_t * cluster,   // out
+                                   error_t  * error )    // out
+{
+    // RPC must be remote
+    if( cxy == local_cxy )
+    {
+        printk("PANIC in %s : target is not remote\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
+    // initialise RPC descriptor header
+    rpc_desc_t  rpc;
+    rpc.index    = RPC_FATFS_GET_CLUSTER;
+    rpc.response = 1;
+    // set input arguments in RPC descriptor
+    rpc.args[0] = (uint64_t)(intptr_t)mapper;
+    rpc.args[1] = (uint64_t)first;
+    rpc.args[2] = (uint64_t)page;
+    // register RPC request in remote RPC fifo
+    rpc_send_sync( cxy , &rpc );
+    // get output argument from rpc descriptor
+    *cluster = (uint32_t)rpc.args[3];
+    *error   = (error_t)rpc.args[4];
+}
+//////////////////////////////////////////////
+void rpc_fatfs_get_cluster_server( xptr_t xp )
+{
+    mapper_t    * mapper;
+    uint32_t      first;
+    uint32_t      page;
+    uint32_t      cluster;
+    error_t       error;
+    // get client cluster identifier and pointer on RPC descriptor
+    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
+    rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
+    // get input arguments
+    mapper = (mapper_t*)(intptr_t)hal_remote_lpt( XPTR( client_cxy , &desc->args[0] ) );
+    first  = (uint32_t)           hal_remote_lw ( XPTR( client_cxy , &desc->args[1] ) );
+    page   = (uint32_t)           hal_remote_lw ( XPTR( client_cxy , &desc->args[2] ) );
+    // call the kernel function
+    error = fatfs_get_cluster( mapper , first , page , &cluster );
+    // set output argument
+    hal_remote_swd( XPTR( client_cxy , &desc->args[3] ) , (uint64_t)cluster );
+    hal_remote_swd( XPTR( client_cxy , &desc->args[4] ) , (uint64_t)error );
+    mapper_t * mapper;
+    uint32_t   to_buffer;
+    uint32_t   file_offset;
+    void     * buffer;
+    uint32_t   size;
+    error_t    error;
+    // get client cluster identifier and pointer on RPC descriptor
+    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
+    rpc_desc_t * desc        = (rpc_desc_t *)GET_PTR( xp );
+    // get arguments from client RPC descriptor
+    mapper      = (mapper_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
+    to_buffer   =                       hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
+    file_offset =                       hal_remote_lwd( XPTR( client_cxy , &desc->args[2] ) );
+    buffer      = (void     *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[3] ) );
+    size        =                       hal_remote_lwd( XPTR( client_cxy , &desc->args[4] ) );
+    // call local kernel function
+    error = mapper_move( mapper,
+                         to_buffer,
+                         file_offset,
+                         buffer,
+                         size );
+    // set output argument to client RPC descriptor
+    hal_remote_swd( XPTR( client_cxy , &desc->args[5] ) , (uint64_t)error );
+}

trunk/kernel/kern/rpc.h

-                      r16
+                      r23
  * rpc.h - RPC (Remote Procedure Call) operations definition.
+ *
+ * Authors Mohamed Karaoui (2015)
+ *         Alain Greiner (2016)
+ * Author  Alain Greiner (2016,2017)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
 struct vfs_inode_s;
 struct vfs_dentry_s;
+struct vfs_file_s;
 struct thread_s;
 struct mapper_s;
 …
     RPC_THREAD_USER_CREATE     = 4,
     RPC_THREAD_KERNEL_CREATE   = 5,
+    RPC_SIGNAL_RISE            = 6,
     RPC_VFS_INODE_CREATE       = 10,
 …
     RPC_VFS_DENTRY_CREATE      = 12,
     RPC_VFS_DENTRY_DESTROY     = 13,
+    RPC_VFS_FILE_CREATE        = 14,
+    RPC_VFS_FILE_DESTROY       = 15,
+    RPC_FATFS_GET_CLUSTER      = 16,
     RPC_VMM_GET_REF_VSEG       = 20,
     RPC_VMM_GET_PTE            = 21,
     RPC_SEMAPHORE_ALLOC        = 22,
     RPC_SEMAPHORE_FREE         = 23,
+    RPC_KCM_ALLOC              = 22,
+    RPC_KCM_FREE               = 23,
     RPC_MAPPER_MOVE            = 24,
+    RPC_FATFS_GET_CLUSTER      = 30,
+    RPC_MAX_INDEX              = 31,
+    RPC_MAX_INDEX              = 30,
+}
 rpc_index_t;
 …
         rpc_index_t       index;       // index of requested RPC service
         volatile uint32_t response;    // response valid when 0
     uint64_t          args[8];     // input/output arguments buffer
+    uint64_t          args[10];    // input/output arguments buffer
+}
 rpc_desc_t;
 …
 void __attribute__((noinline)) rpc_undefined();
 /**********************************************************************************/
 /******* Marshalling functions attached to the various RPCs ***********************/
 …
 /***********************************************************************************
  * The RPC_PMEM_GET_PAGES allocates one or several pages in a remote cluster,
+ * [0] The RPC_PMEM_GET_PAGES allocates one or several pages in a remote cluster,
  * and returns the PPN of the first allocated page.
  ***********************************************************************************
 …
 /***********************************************************************************
  * The RPC_PROCESS_PID_ALLOC allocates one new PID in a remote cluster, registers
+ * [1] The RPC_PROCESS_PID_ALLOC allocates one new PID in a remote cluster, registers
  * the new process in the remote cluster, and returns the PID, and an error code.
  ***********************************************************************************
 …
 /***********************************************************************************
  * The RPC_PROCESS_EXEC creates a process descriptor copy, in a remote cluster
+ * [2] The RPC_PROCESS_EXEC creates a process descriptor copy, in a remote cluster
  * and initializes if from information found in the reference process descriptor.
  * This remote cluster becomes the new reference cluster.
 …
 /***********************************************************************************
  * The RPC_PROCESS_KILL is actually a multicast RPC sent by the reference cluster
+ * [3] The RPC_PROCESS_KILL is actually a multicast RPC sent by the reference cluster
  * to other clusters containing a process descriptor copy, to destroy these copies.
  ***********************************************************************************
 …
 /***********************************************************************************
  * The RPC_THREAD_USER_CREATE creates an user thread in the server cluster,
  * as specified by the pthread_attr_t argument. It returns the local pointer
  * on the thread descriptor in server cluster, and an error code.
  * It is called by the pthread_create system call.
+ * [4] The RPC_THREAD_USER_CREATE creates an user thread in the server cluster,
+ * as specified by the arguments. It returns an extended pointer on the new
+ * thread descriptor in server cluster, and an error code.
+ * It is called by the sys_thread_create() system call.
  ***********************************************************************************
  * @ cxy       : server cluster identifier.
 …
  **********************************************************************************/
 void rpc_thread_user_create_client( cxy_t                   cxy,
+                                    pid_t                   pid,
+                                    void                  * start_func,
+                                    void                  * start_arg,
                                     struct pthread_attr_s * attr,
                                     xptr_t                * thread_xp,
 …
 /***********************************************************************************
  * The RPC_THREAD_KERNEL_CREATE creates a kernel thread in the server cluster,
+ * [5] The RPC_THREAD_KERNEL_CREATE creates a kernel thread in the server cluster,
  * as specified by the type, func and args arguments. It returns the local pointer
  * on the thread descriptor in server cluster and an error code.
  * It is used by the dev_init() function to cretae the device server thread.
+ * It is used by the dev_init() function to create the device server thread.
  ***********************************************************************************
  * @ cxy       : server cluster identifier.
 …
 void rpc_thread_kernel_create_server( xptr_t xp );
+/***********************************************************************************
+ * [6] The RPC_SIGNAL_RISE ask a target cluster to register a given signal in
+ * all threads descriptors of a given process.
+ * It is used by the sys_kill() function.
+ ***********************************************************************************
+ * @ cxy       : server cluster identifier.
+ * @ process   : [in]  local pointer on target process descriptor in server.
+ * @ sig_id    : [in]  signal index.
+ **********************************************************************************/
+void rpc_signal_rise_client( cxy_t              cxy,
+                             struct process_s * process,
+                             uint32_t           sig_id );
+void rpc_signal_rise_server( xptr_t xp );
 /***********************************************************************************
  * The RPC_VFS_INODE_CREATE creates an inode and the associated mapper in a
+ * [10] The RPC_VFS_INODE_CREATE creates an inode and the associated mapper in a
  * remote cluster. The parent dentry must have been previously created.
  * It returns an extended pointer on the created inode.
  ***********************************************************************************
+ * @ cxy       :  server cluster identifier
+ * @ dentry_xp : [in]  extended pointer on parent dentry.
+ * @ type      : [in]  file system type.
+ * @ attr      : [in]  TODO ???
+ * @ mode      : [in]  access mode.
+ * @ uid       : [in]  user ID
+ * @ gid       : [in]  group ID
+ * @ inode_xp  : [out] buffer for extended pointer on created inode.
+ * @ error     : [out] error status (0 if success).
+ * @ cxy        :  server cluster identifier.
+ * @ dentry_xp  : [in]  extended pointer on parent dentry.
+ * @ fs_type    : [in]  file system type.
+ * @ inode_type : [in]  file system type.
+ * @ attr       : [in]  inode attributes.
+ * @ rights     : [in]  access rights
+ * @ uid        : [in]  user ID
+ * @ gid        : [in]  group ID
+ * @ inode_xp   : [out] buffer for extended pointer on created inode.
+ * @ error      : [out] error status (0 if success).
  **********************************************************************************/
 void rpc_vfs_inode_create_client( cxy_t      cxy,
                                   xptr_t     dentry_xp,
+                                  uint32_t   type,
+                                  uint32_t   fs_type,
+                                  uint32_t   inode_type,
                                   uint32_t   attr,
                                   uint32_t   mode,
+                                  uint32_t   rights,
                                   uint32_t   uid,
                                   uint32_t   gid,
 …
 /***********************************************************************************
  * The RPC_VFS_INODE_DESTROY releases memory allocated for an inode descriptor
+ * [11] The RPC_VFS_INODE_DESTROY releases memory allocated for an inode descriptor
  * and for the associated mapper in a remote cluster.
  ***********************************************************************************
 …
 /***********************************************************************************
  * The RPC_VFS_DENTRY_CREATE creates a dentry in a remote cluster.
+ * [12] The RPC_VFS_DENTRY_CREATE creates a dentry in a remote cluster.
  * It returns an extended pointer on the created dentry.
  ***********************************************************************************
 …
 /***********************************************************************************
  * The RPC_VFS_DENTRY_DESTROY releases memory allocated for an dentry descriptor
+ * [13] The RPC_VFS_DENTRY_DESTROY releases memory allocated for an dentry descriptor
  * in a remote cluster.
  ***********************************************************************************
 …
 void rpc_vfs_dentry_destroy_server( xptr_t xp );
+/***********************************************************************************
+ * The RPC_VMM_GET_REF_VSEG returns an extended pointer
+/***********************************************************************************
+ * [14] The RPC_VFS_FILE_CREATE creates a file descriptor in a remote cluster.
+ * It returns an extended pointer on the created file structure.
+ ***********************************************************************************
+ * @ cxy        :  server cluster identifier
+ * @ inode      : [in]  local pointer on parent inode.
+ * @ file_attr  : [in]  new file attributes.
+ * @ file_xp    : [out] buffer for extended pointer on created file.
+ * @ error      : [out] error status (0 if success).
+ **********************************************************************************/
+void rpc_vfs_file_create_client( cxy_t                  cxy,
+                                 struct vfs_inode_s   * inode,
+                                 uint32_t               file_attr,
+                                 xptr_t               * file_xp,
+                                 error_t              * error );
+void rpc_vfs_file_create_server( xptr_t xp );
+/***********************************************************************************
+ * [15] The RPC_VFS_FILE_DESTROY releases memory allocated for a file descriptor
+ * in a remote cluster.
+ ***********************************************************************************
+ * @ cxy       :  server cluster identifier
+ * @ file       : [in]  local pointer on file.
+ **********************************************************************************/
+void rpc_vfs_file_destroy_client( cxy_t               cxy,
+                                  struct vfs_file_s * file );
+void rpc_vfs_file_destroy_server( xptr_t xp );
+/***********************************************************************************
+ * [16] The RPC_FATFS_GET_CLUSTER can be send by any thread running in a "client"
+ * cluster to scan the FAT mapper, stored in a remote "server" cluster, and get
+ * from the mapper the local pointer on a given page.
+ ***********************************************************************************
+ * @ cxy      : server cluster identifier.
+ * @ mapper   : [in]  local pointer on FAT mapper.
+ * @ first    : [in]  FATFS cluster index allocated to first page of file.
+ * @ page     : [in]  page index in file.
+ * @ cluster  : [out] local pointer on buffer for found FATFS cluster index.
+ * @ error    : [out] local pointer on buffer for error code (in client cluster).
+ **********************************************************************************/
+void rpc_fatfs_get_cluster_client( cxy_t             cxy,
+                                   struct mapper_s * mapper,
+                                   uint32_t          first,
+                                   uint32_t          page,
+                                   uint32_t        * cluster,
+                                   error_t         * error );
+void rpc_fatfs_get_cluster_server( xptr_t xp );
+/***********************************************************************************
+ * [20] The RPC_VMM_GET_REF_VSEG returns an extended pointer
  * on the vseg containing a given virtual address in a given process.
  * The server cluster is supposed to be the reference cluster.
 …
 /***********************************************************************************
  * The RPC_VMM_GET_PTE returns in the "ppn" and "attr" arguments the PTE value
+ * [21] The RPC_VMM_GET_PTE returns in the "ppn" and "attr" arguments the PTE value
  * for a given VPN in a given process.
  * The server cluster is supposed to be the reference cluster, and the vseg
 …
 /***********************************************************************************
+ * The RPC_SEMAPHORE_ALLOC allocates memory for a semaphore in a remote cluster,
+ * and returns an extended pointer on the created semaphore.
+  It returns NULL if physical memory cannot be allocated.
+ ***********************************************************************************
+ * @ cxy     : server cluster identifier.
+ * @ sem_xp  : [out] buffer for extended pointer on semaphore.
+ **********************************************************************************/
+void rpc_semaphore_alloc_client( cxy_t    cxy,
+                                 xptr_t * sem_xp );
+void rpc_semaphore_alloc_server( xptr_t xp );
+/***********************************************************************************
+ * The RPC_SEMAPHORE_FREE releases memory allocated for a semaphore
+ * [22] The RPC_KCM_ALLOC allocates memory from a given KCM in a remote cluster,
+ * and returns an extended pointer on the allocated object.
+  It returns XPTR_NULL if physical memory cannot be allocated.
+ ***********************************************************************************
+ * @ cxy       : server cluster identifier.
+ * @ kmem_type : [in]  KCM object type (as defined in kmem.h).
+ * @ buf_xp    : [out] buffer for extended pointer on allocated buffer.
+ **********************************************************************************/
+void rpc_kcm_alloc_client( cxy_t      cxy,
+                           uint32_t   kmem_type,
+                           xptr_t   * buf_xp );
+void rpc_kcm_alloc_server( xptr_t xp );
+/***********************************************************************************
+ * [23] The RPC_KCM_FREE releases memory allocated for a KCM object of a given type,
  * in a remote cluster.
  ***********************************************************************************
+ * @ cxy     : server cluster identifier.
+ * @ sem     : [in] local pointer on semaphore.
+ **********************************************************************************/
+void rpc_semaphore_free_client( cxy_t                 cxy,
+                                struct remote_sem_s * sem );
+void rpc_semaphore_free_server( xptr_t xp );
+/***********************************************************************************
+ * The RPC_MAPPER_MOVE can be send by any thread running in a "client" cluster
+ * to the "server" cluster containing the mapper of a given file. The service is
+ * to move data between the mapper and an user buffer. This user buffer is described
+ * as a set of fragments. Each fragment is contained in one single physical page.
+ * It is defined by four parameters : size / file_offset / ppn / page_offset,
+ * defined in the mapper.h file. The client thread is in charge of building
+ * the fragments array covering the user buffer.
+ * As each fragments can be stored in a different cluster, and this fragment can
+ * be stored in two successive pages in the radix tree, each fragment is moved
+ * using one or two different hal_remote_memcpy().
+ ***********************************************************************************
+ * @ cxy      : server cluster identifier.
+ * @ inode    : [in]  local pointer on inode (in server cluster).
+ * @ read     : [in]  mapper to buffer if true / buffer to mapper if false.
+ * @ nb_frags : [in]  number of fragments in fragments array.
+ * @ frags    : [in]  local pointer on fragments array (in client cluster).
+ * @ error    : [out] local pointer on buffer for error code (in client cluster).
+ **********************************************************************************/
+void rpc_mapper_move_client( cxy_t                cxy,
+                             struct mapper_s    * mapper,
+                             bool_t               read,
+                             uint32_t             nb_frags,
+                             struct fragment_s  * frags,
+                             error_t            * error );
+ * @ cxy       : server cluster identifier.
+ * @ buf       : [in] local pointer on allocated buffer.
+ * @ kmem_type : [in]  KCM object type (as defined in kmem.h).
+ **********************************************************************************/
+void rpc_kcm_free_client( cxy_t     cxy,
+                          void    * buf,
+                          uint32_t  kmem_type );
+void rpc_kcm_free_server( xptr_t xp );
+/***********************************************************************************
+ * [24] The RPC_MAPPER_MOVE is called by the vfs_move() function.
+ * It allows a client thread to requires a remote mapper to move data to/from
+ * an user buffer, as specified by the arguments.
+ ***********************************************************************************
+ * @ cxy         : server cluster identifier.
+ * @ mapper      : [in]  local pointer on mapper
+ * @ to_buffer   : [in]  move data from buffer to mapper if non zero.
+ * @ file_offset : [in]  first byte to move in mapper
+ * @ buffer      : [in]  pointer on buffer in user space
+ * @ size        : [in]  number of bytes to move
+ * @ error       : [out] error status (0 if success).
+ **********************************************************************************/
+void rpc_mapper_move_client( cxy_t             cxy,
+                             struct mapper_s * mapper,
+                             uint32_t          to_buffer,
+                             uint32_t          file_offset,
+                             void            * buffer,
+                             uint32_t          size,
+                             error_t         * error );
 void rpc_mapper_move_server( xptr_t xp );
+/***********************************************************************************
+ * The RPC_FATFS_GET_CLUSTER can be send by any thread running in a "client" cluster
+ * to scan the FAT mapper, stored in a remote "server" cluster, and get the FATFS
+ * cluster index of a given page of a given file.
+ ***********************************************************************************
+ * @ cxy      : server cluster identifier.
+ * @ mapper   : [in]  local pointer on FAT mapper.
+ * @ first    : [in]  FATFS cluster index allocated to first page of file.
+ * @ page     : [in]  page index in file.
+ * @ cluster  : [out] local pointer on buffer for found FATFS cluster index.
+ * @ error    : [out] local pointer on buffer for error code (in client cluster).
+ **********************************************************************************/
+void rpc_fatfs_get_cluster_client( cxy_t             cxy,
+                                   struct mapper_s * mapper,
+                                   uint32_t          first,
+                                   uint32_t          page,
+                                   uint32_t        * cluster,
+                                   error_t         * error );
+void rpc_fatfs_get_cluster_server( xptr_t xp );
 #endif

trunk/kernel/kern/signal.c

-                      r5
+                      r23
 #include <hal_types.h>
+#include <errno.h>
+#include <hal_atomic.h>
+#include <printk.h>
 #include <thread.h>
+#include <process.h>
+#include <core.h>
+#include <spinlock.h>
 #include <signal.h>
+//////////////////////////////////////
+void signal_rise( process_t * process,
+                  uint32_t    sig_id )
+{
+    // get the lock protecting the set of local threads
+        spinlock_lock( &process->th_lock );
+    // loop on local threads
+        thread_t * thread;
+        uint32_t   i;
+        for( i = 0 ; i < process->th_nr ; i++ )
+        {
+                thread = process->th_tbl[i];
+                hal_atomic_or( &thread->signals , (1 << sig_id) );
+        signal_dmsg("\n[INFO] %s : thread %x in process %x received signal %d\n",
+                    __FUNCTION__, thread->trdid , process->pid , sig_id );
+        }
+    // release the lock
+        spinlock_unlock( &process->th_lock );
+}  // end signal_rise()
+/*
 SIGNAL_HANDLER(kill_sigaction)
+{
+        struct thread_s *this;
+        this = CURRENT_THREAD;
+        this->state = S_KERNEL;
+        thread_s * this = CURRENT_THREAD;
         printk(INFO, "INFO: Recieved signal %d, pid %d, tid %x, core %d  [ KILLED ]\n",
+        printk("\n[INFO] %s : threadReceived signal %d, pid %d, tid %x, core %d  [ KILLED ]\n",
                sig,
                this->process->pid,
 …
+}
 //////////////////////////////////////////////////
+///////////////////////////////////////////////
 void signal_manager_init( process_t * process )
+{
 …
+}
+//////////////////////////////////////
+void signal_rise( process_t * process,
                   uint32_t    sig )
+/////////////////////////////////////
+void signal_notify( thread_t * this )
+{
+        thread_t     * thread;
+        uint32_t       i;
+        uint32_t     sig_state;
+        uint32_t     sig;
+        sig_mgr_t  * sig_mgr;
+        uint32_t     irq_state;
+        spinlock_lock( &process->th_lock );
+        for( i = 0 ; i < process->th_nr ; i++ )
+        {
+                thread = process->th_tbl[i];
+                hal_atomic_or( &thread->signals , (1 << sig) );
+        }
+        spinlock_unlock( &process->th_lock );
+        sig_dmsg("\n[INFO] %s : %d threads have been signaled for process %d\n",
+                        __FUNCTION__, process->th_nr , process->pid );
+}  // end signal_rise()
+///////////////////////////////////////////
+RPC_DECLARE( __signal_rise,                             \
+                RPC_RET( RPC_RET_PTR(error_t, err)),    \
+                RPC_ARG( RPC_ARG_VAL(pid_t,   pid),     \
+                         RPC_ARG_VAL(uint32_t,  sig))     \
+           )
+{
+         process_t   * process;
+        struct hnode_s  *hnode;
+        /* Avoid killing process0 and init */
+        /* FIXME: Zero should not be hard-coded but obtains with something like MAIN_KERN */
+        if( ((pid == PID_MIN_GLOBAL) || (pid == PID_MIN_GLOBAL+1))
+                        && (current_cid == 0) )
+        {
+                *err = EPERM;
+                sig_dmsg(1, "%s: can't kill process %u on cluster %u\n",           \
+                                __FUNCTION__, PID_GET_LOCAL(pid), current_cid);
+                goto SYS_RISE_ERR_PID;
+        }
+        /* Step 1 : lock the process manager */
+        processs_manager_lock();
+        /* Step 2 : Get the process' address */
+        /* Case 1 : current cluster is the anchor and the owner. */
+        if ( PID_GET_CLUSTER(pid) == current_cid )
+        {
+                sig_dmsg(1, "%s: process %u is in the processs manager array of cluster  %u\n",       \
+                                __FUNCTION__, pid, current_cid);
+                process = process_lookup(pid)->process;
+        }
+        else /* Case 2 : current cluster is not the anchor, so the struct
+              * process_s is in its hash table.
+              */
+        {
+                sig_dmsg(1, "%s: process %u is in the processs manager hash table of cluster  %u\n",  \
+                                __FUNCTION__, pid, current_cid);
+                hnode = hfind(processs_manager_get_htable(), (void*)pid);
+                process    = ( process_t*) container_of(hnode,          \
+                                 process_t, t_hnode);
+        }
+        /* Step 4 : check process' address */
+        if ( process == NULL )
+        {
+                *err = ESRCH;
+                goto SYS_RISE_ERR;
+        }
+        /* Step 5 : deliver signal */
+        if((sig == SIGTERM) || (sig == SIGKILL))
+                *err = signal_rise_all(process, sig);
+        else
+                *err = signal_rise_one(process, sig);
+        /* Step 6 : unlock processs manager */
+        processs_manager_unlock();
+        return;
+SYS_RISE_ERR:
+        processs_manager_unlock();
+SYS_RISE_ERR_PID:
+        sig_dmsg(1, "%s: Cluster %u has not deliver signal %u to process %u (err %u)\n",  \
+                        __FUNCTION__, current_cid, sig, err );
+        return;
+}
+///////////////////////////////
+error_t sys_kill( pid_t    pid,
+                  uint32_t sig)
+{
+    cxy_t       owner_cxy;    // process owner cluster
+    lpid_t      owner_lpid;   // local process identifier
+    xptr_t      root_xp;      // extended pointer on root of xlist of process copies
+    xptr_t      lock_xp;      // extended pointer on remote_spinlock protecting this list
+    xptr_t      iter_xp;      // iterator for process copies list
+    xptr_t      process_xp;   // local pointer on process copy
+    cxy_t       process_cxy;  // cluster of process copy
+    process_t * process_ptr;  // local pointer on process copy
+        error_t     error;
+    // get local pointer on local cluster manager
+    cluster_t * cluster = LOCAL_CLUSTER;
+    // get owner process cluster and lpid
+    owner_cxy  = CXY_FROM_PID( pid );
+    owner_lpid = LPID_FROM_PID( pid );
+    // get extended pointers on copies root and lock
+    root_xp = XPTR( owner_cxy , &cluster->copies_root[lpid] );
+    lock_xp = XPTR( owner_cxy , &cluster->copies_lock[lpid] );
+    // take the lock protecting the copies
+    remote_spinlock_lock( lock_xp );
+    // TODO the loop below sequencialize the RPCs
+    // they could be pipelined...
+    // traverse the list of copies
+    XLIST_FOREACH( root_xp , iter_xp )
+    {
+        process_xp  = XLIST_ELEMENT( iter_xp , process_t , copies_list );
+        process_cxy = GET_CXY( process_xp );
+        process_ptr = (process_t *)GET_PTR( process_xp );
+        if( process_xy == local_cxy )   // process copy is local
+        {
+            error = signal_rise( process_ptr , sig );
+        }
+        else                           // process copy is remote
+        {
+            rpc_signal_rise_client( process_cxy , process_ptr , sig );
+        }
+    }
+        return 0;
+}
+////////////////////////////////////
+void signal_notify( thread_s * this)
+{
+        register uint32_t sig_state;
+        register uint32_t sig;
+        register struct sig_mgr_s *sig_mgr;
+        uint32_t irq_state;
+        sig_state = this->info.sig_state & this->info.sig_mask;
+        sig_state = this->signals;
         sig       = 0;
 …
+        }
+}
+*/

trunk/kernel/kern/signal.h

-                      r16
+                      r23
  * Author  Ghassan Almaless (2008,2009,2010,2011,2012)
  *         Mohamed Lamine Karaoui (2015)
  *         Alain Greiner    (2016)
+ *         Alain Greiner    (2016,2017)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
 #define SIG_ERROR     -1L
 #define SIGHUP     1       /*! hangup */
 #define SIGINT     2       /*! interrupt */
 #define SIGQUIT    3       /*! quit */
 #define SIGILL     4       /*! illegal instruction (not reset when caught) */
 #define SIGTRAP    5       /*! trace trap (not reset when caught) */
 #define SIGIOT     6       /*! IOT instruction */
 #define SIGABRT    6       /*! used by abort, replace SIGIOT in the future */
 #define SIGEMT     7       /*! EMT instruction */
 #define SIGFPE     8       /*! floating point exception */
 #define SIGKILL    9       /*! kill (cannot be caught or ignored) */
 #define SIGBUS     10      /*! bus error */
 #define SIGSEGV    11      /*! segmentation violation */
 #define SIGSYS     12      /*! bad argument to system call */
 #define SIGPIPE    13      /*! write on a pipe with no one to read it */
 #define SIGALRM    14      /*! alarm clock */
 #define SIGTERM    15      /*! software termination signal from kill */
 #define SIGURG     16      /*! urgent condition on IO channel */
 #define SIGSTOP    17      /*! sendable stop signal not from tty */
 #define SIGTSTP    18      /*! stop signal from tty */
 #define SIGCONT    19      /*! continue a stopped process */
 #define SIGCHLD    20      /*! to parent on child stop or exit */
 #define SIGCLD     20      /*! System V name for SIGCHLD */
 #define SIGTTIN    21      /*! to readers pgrp upon background tty read */
 #define SIGTTOU    22      /*! like TTIN for output if (tp->t_local&LTOSTOP) */
 #define SIGIO      23      /*! input/output possible signal */
 #define SIGPOLL    SIGIO   /*! System V name for SIGIO */
 #define SIGXCPU    24      /*! exceeded CPU time limit */
 #define SIGXFSZ    25      /*! exceeded file size limit */
 #define SIGVTALRM  26      /*! virtual time alarm */
 #define SIGPROF    27      /*! profiling time alarm */
 #define SIGWINCH   28      /*! window changed */
 #define SIGLOST    29      /*! resource lost (eg, record-lock lost) */
 #define SIGUSR1    30      /*! user defined signal 1 */
 #define SIGUSR2    31      /*! user defined signal 2 */
 #define SIG_NR     32      /*! signal 0 implied */
+#define SIGHUP     1       /*! hangup                                                     */
+#define SIGINT     2       /*! interrupt                                                  */
+#define SIGQUIT    3       /*! quit                                                       */
+#define SIGILL     4       /*! illegal instruction (not reset when caught)                */
+#define SIGTRAP    5       /*! trace trap (not reset when caught)                         */
+#define SIGIOT     6       /*! IOT instruction                                            */
+#define SIGABRT    6       /*! used by abort, replace SIGIOT in the future                */
+#define SIGEMT     7       /*! EMT instruction                                            */
+#define SIGFPE     8       /*! floating point exception                                   */
+#define SIGKILL    9       /*! kill (cannot be caught or ignored)                         */
+#define SIGBUS     10      /*! bus error                                                  */
+#define SIGSEGV    11      /*! segmentation violation                                     */
+#define SIGSYS     12      /*! bad argument to system call                                */
+#define SIGPIPE    13      /*! write on a pipe with no one to read it                     */
+#define SIGALRM    14      /*! alarm clock                                                */
+#define SIGTERM    15      /*! software termination signal from kill                      */
+#define SIGURG     16      /*! urgent condition on IO channel                             */
+#define SIGSTOP    17      /*! sendable stop signal not from tty                          */
+#define SIGTSTP    18      /*! stop signal from tty                                       */
+#define SIGCONT    19      /*! continue a stopped process                                 */
+#define SIGCHLD    20      /*! to parent on child stop or exit                            */
+#define SIGCLD     20      /*! System V name for SIGCHLD                                  */
+#define SIGTTIN    21      /*! to readers pgrp upon background tty read                   */
+#define SIGTTOU    22      /*! like TTIN for output if (tp->t_local&LTOSTOP)              */
+#define SIGIO      23      /*! input/output possible signal                               */
+#define SIGPOLL    SIGIO   /*! System V name for SIGIO                                    */
+#define SIGXCPU    24      /*! exceeded CPU time limit                                    */
+#define SIGXFSZ    25      /*! exceeded file size limit                                   */
+#define SIGVTALRM  26      /*! virtual time alarm                                         */
+#define SIGPROF    27      /*! profiling time alarm                                       */
+#define SIGWINCH   28      /*! window changed                                             */
+#define SIGLOST    29      /*! resource lost (eg, record-lock lost)                       */
+#define SIGUSR1    30      /*! user defined signal 1                                      */
+#define SIGUSR2    31      /*! user defined signal 2                                      */
+#define SIG_NR     32      /*! signal 0 implied                                           */
 #define SIG_DEFAULT_MASK         0xFFEEFFFF
 …
 /*******************************************************************************************
  * This structure ...
+ * This structure ... TODO
  ******************************************************************************************/
 …
 /*******************************************************************************************
  * This structure ...
+ * This structure ... TODO
  ******************************************************************************************/
 …
 /*******************************************************************************************
  * This structure TODO
+ * This structure ... TODO
  ******************************************************************************************/
 …
 sig_mgr_t;
 /*******************************************************************************************
+ * This function TODO
+ ******************************************************************************************/
+int sys_signal ( uint32_t       sig,
+                 sa_handler_t * handler );
+/*******************************************************************************************
+ * This function TODO
+ * This function ... TODO
  ******************************************************************************************/
 int sys_sigreturn_setup( void * sigreturn_func );
-/*******************************************************************************************
- * This function register the signal <sig> in the bit_vector of all threads of a given
- * process identified by its <pid>, in all clusters containing threads for this process.
- * It can be executed by any thread running in any cluster, as this function uses
- * remote access to traverse the list of process copies, and the RPC_RISE_SIGNAL
- * to deliver the signal to all involved clusters.
- * The list of process copies is rooted in the owner cluster.
- ******************************************************************************************/
-int sys_kill( pid_t    pid,
-              uint32_t sig );
 /*******************************************************************************************
  * This function TODO
+ * This function ... TODO
  ******************************************************************************************/
 error_t signal_manager_init( struct process_s * process );
+void signal_manager_init( struct process_s * process );
 /*******************************************************************************************
 …
  * It must be executed by a thread running in the same cluster as the target threads
  * (can be a local thread or a RPC thread).
+ *******************************************************************************************
+ * @ process   : local pointer on local target process.
+ * @ sig_id    : signal type.
  ******************************************************************************************/
 error_t signal_rise( struct process_s * process,
                      uint32_t           sig );
+void signal_rise( struct process_s * process,
+                  uint32_t           sig_id );
 /*******************************************************************************************

trunk/kernel/kern/thread.c

-                      r16
+                      r23
+ *
  * Author  Ghassan Almaless (2008,2009,2010,2011,2012)
+ *         Mohamed Lamine Karaoui (2015)
+ *         Alain Greiner (2016)
+ *         Alain Greiner (2016,2017)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
 static thread_t * thread_alloc()
+{
         page_t       * page;       // pointer on page descriptor containing thread descriptor
         kmem_req_t     req;        // kmem request
+        page_t       * page;   // pointer on page descriptor containing thread descriptor
+        kmem_req_t     req;    // kmem request
         // allocates memory for thread descriptor + kernel stack
 …
     // return pointer on new thread descriptor
+        if( page == NULL )
+    {
+        printk("\n[ERROR] in %s : no memory for thread descriptor\n", __FUNCTION__ );
+        return NULL;
+    }
+    else
+    {
+        return (thread_t *)ppm_page2base( page );
+    }
+}  // end thread_alloc()
+        if( page == NULL ) return NULL;
+    else               return (thread_t *)ppm_page2base( page );
+}
+/////////////////////////////////////////////////////////////////////////////////////
+// This static function releases the physical memory for a thread descriptor.
+// It can be called by the three functions:
+// - thread_user_create()
+// - thread_user_fork()
+// - thread_kernel_create()
+/////////////////////////////////////////////////////////////////////////////////////
+// @ thread  : pointer on thread descriptor.
+/////////////////////////////////////////////////////////////////////////////////////
+static void thread_release( thread_t * thread )
+{
+    kmem_req_t   req;
+    req.type  = KMEM_PAGE;
+    req.ptr   = ppm_base2page( thread );
+    kmem_free( &req );
+}
 /////////////////////////////////////////////////////////////////////////////////////
 …
 /////////////////////////////////////////////////////////
+error_t thread_user_create( thread_t       ** new_thread,
+error_t thread_user_create( pid_t             pid,
+                            void            * start_func,
+                            void            * start_arg,
                             pthread_attr_t  * attr,
+                            intptr_t          u_stack_base,
+                            uint32_t          u_stack_size )
+                            thread_t       ** new_thread )
+{
     error_t        error;
 …
     process_t    * process;      // pointer to local process descriptor
     lid_t          core_lid;     // selected core local index
+        kmem_req_t     req;          // kmem request (for release)
+    thread_dmsg("\n[INFO] %s : enters\n", __FUNCTION__ );
+        cluster_t    * local_cluster = LOCAL_CLUSTER;
+    vseg_t       * vseg;         // stack vseg
+    thread_dmsg("\n[INFO] %s : enters for process %x\n", __FUNCTION__ , pid );
+    // get process descriptor local copy
+    process = process_get_local_copy( pid );
+    if( process == NULL )
+    {
+                printk("\n[ERROR] in %s : cannot get process descriptor %x\n",
+               __FUNCTION__ , pid );
+        return ENOMEM;
+    }
     // select a target core in local cluster
     if( attr->flags & PT_FLAG_CORE_DEFINED ) core_lid = attr->lid;
     else                                     core_lid = cluster_select_local_core();
+    if( attr->attributes & PT_ATTR_CORE_DEFINED ) core_lid = attr->lid;
+    else                                          core_lid = cluster_select_local_core();
     // check core local index
+    if( core_lid >= local_cluster->cores_nr ) return EINVAL;
+    // get process descriptor local copy
+    process = process_get_local_copy( attr->pid );
+    if( process == NULL ) return ENOMEM;
+    if( core_lid >= LOCAL_CLUSTER->cores_nr )
+    {
+            printk("\n[ERROR] in %s : illegal core index attribute = %d\n",
+               __FUNCTION__ , core_lid );
+        return EINVAL;
+    }
+    // allocate a stack from local VMM
+    vseg = vmm_create_vseg( process, 0 , 0 , VSEG_TYPE_STACK );
+    if( vseg == NULL );
+    {
+            printk("\n[ERROR] in %s : cannot create stack vseg\n", __FUNCTION__ );
+                return ENOMEM;
+    }
     // allocates memory tor thread descriptor
     thread = thread_alloc();
+    if( thread == NULL ) return ENOMEM;
+    if( thread == NULL )
+    {
+            printk("\n[ERROR] in %s : cannot create new thread\n", __FUNCTION__ );
+        vmm_remove_vseg( vseg );
+        return ENOMEM;
+    }
     // initializes thread descriptor
 …
                          process,
                          THREAD_USER,
                          attr->entry_func,
                          attr->entry_args,
+                         start_func,
+                         start_arg,
                          core_lid,
                          u_stack_base,
                          u_stack_size );
     if( error )  // release allocated memory for thread descriptor
+    {
             req.type  = KMEM_PAGE;
         req.ptr   = ppm_base2page( thread );
         kmem_free( &req );
+                         vseg->min,
+                         vseg->max - vseg->min );
+    if( error )
+    {
+            printk("\n[ERROR] in %s : cannot initialize new thread\n", __FUNCTION__ );
+        vmm_remove_vseg( vseg );
+        thread_release( thread );
         return EINVAL;
+    }
 …
     // set DETACHED flag if required
     if( attr->flags & PT_FLAG_DETACH ) thread->flags |= THREAD_FLAG_DETACHED;
+    if( attr->attributes & PT_ATTR_DETACH ) thread->flags |= THREAD_FLAG_DETACHED;
     // allocate & initialise CPU context
         error = hal_cpu_context_create( thread );
+    if( error ) return ENOMEM;
+    if( error )
+    {
+            printk("\n[ERROR] in %s : cannot create CPU context\n", __FUNCTION__ );
+        vmm_remove_vseg( vseg );
+        thread_release( thread );
+        return ENOMEM;
+    }
     // allocate & initialise FPU context
     error = hal_fpu_context_create( thread );
+    if( error ) return ENOMEM;
+    if( error )
+    {
+            printk("\n[ERROR] in %s : cannot create FPU context\n", __FUNCTION__ );
+        vmm_remove_vseg( vseg );
+        thread_release( thread );
+        return ENOMEM;
+    }
     thread_dmsg("\n[INFO] %s : exit / trdid = %x / process %x / core = %d\n",
                 __FUNCTION__ , thread->trdid , process->pid , core_lid );
 …
+/////////////////////////////////////////////////
+error_t thread_user_fork( thread_t ** new_thread,
+                          process_t * process,
+                          intptr_t    u_stack_base,
+                          uint32_t    u_stack_size )
+//////////////////////////////////////////////
+error_t thread_user_fork( process_t * process,
+                          thread_t ** new_thread )
+{
     error_t        error;
         thread_t     * thread;       // pointer on new thread descriptor
     lid_t          core_lid;     // selected core local index
         kmem_req_t     req;          // kmem request (for release)
+        vseg_t       * vseg;         // stack vseg
     thread_dmsg("\n[INFO] %s : enters\n", __FUNCTION__ );
+    // allocate a stack from local VMM
+    vseg = vmm_create_vseg( process, 0 , 0 , VSEG_TYPE_STACK );
+    if( vseg == NULL );
+    {
+            printk("\n[ERROR] in %s : cannot create stack vseg\n", __FUNCTION__ );
+                return ENOMEM;
+    }
     // select a target core in local cluster
 …
     thread = thread_alloc();
+    if( thread == NULL ) return ENOMEM;
+    if( thread == NULL )
+    {
+        printk("\n[ERROR] in %s : cannot allocate new thread\n", __FUNCTION__ );
+        vmm_remove_vseg( vseg );
+        return ENOMEM;
+    }
     // initializes thread descriptor
 …
                          this->entry_args,
                          core_lid,
                          u_stack_base,
                          u_stack_size );
     if( error ) // release allocated memory for thread descriptor
+    {
             req.type  = KMEM_PAGE;
         req.ptr   = ppm_base2page( thread );
         kmem_free( &req );
+                         vseg->min,
+                         vseg->max - vseg->min );
+    if( error )
+    {
+            printk("\n[ERROR] in %s : cannot initialize new thread\n", __FUNCTION__ );
+        vmm_remove_vseg( vseg );
+        thread_release( thread );
         return EINVAL;
+    }
 …
     // allocate & initialise CPU context from calling thread
         error = hal_cpu_context_copy( thread , this );
+    if( error ) return ENOMEM;
+    if( error )
+    {
+            printk("\n[ERROR] in %s : cannot create CPU context\n", __FUNCTION__ );
+        vmm_remove_vseg( vseg );
+        thread_release( thread );
+        return ENOMEM;
+    }
     // allocate & initialise FPU context from calling thread
         error = hal_fpu_context_copy( thread , this );
+    if( error ) return ENOMEM;
+    thread_dmsg("INFO : %s thread %x for process %x on core %d in cluster %x\n",
+    if( error )
+    {
+            printk("\n[ERROR] in %s : cannot create CPU context\n", __FUNCTION__ );
+        vmm_remove_vseg( vseg );
+        thread_release( thread );
+        return ENOMEM;
+    }
+    thread_dmsg("\n[INFO] %s : exit / thread %x for process %x on core %d in cluster %x\n",
                  __FUNCTION__, thread->trdid, process->pid, core_lid, local_cxy );
 …
         spinlock_unlock( &process->th_lock );
+    // update local DQDT
+    dqdt_local_update_threads( -1 );
     // invalidate thread descriptor
         thread->signature = 0;
     // release memory for thread descriptor
+        kmem_req_t   req;
+        req.type     = KMEM_PAGE;
+        req.ptr      = ppm_base2page( thread );
+        kmem_free(&req);
+    thread_release( thread );
         tm_end = hal_time_stamp();
 …
 ////////////////////////////////////////////////
 void thread_signals_handler( thread_t * thread )
+void thread_signals_handle( thread_t * thread )
+{
     // TODO
 …
+}
+/////////////////////////////////////
+xptr_t thread_get_xptr( pid_t    pid,
+                        trdid_t  trdid )
+{
+    cxy_t         target_cxy;          // target thread cluster identifier
+    ltid_t        target_thread_ltid;  // target thread local index
+    thread_t    * target_thread_ptr;   // target thread local pointer
+    xptr_t        target_process_xp;   // extended pointer on target process descriptor
+    process_t   * target_process_ptr;  // local pointer on target process descriptor
+    pid_t         target_process_pid;  // target process identifier
+    xlist_entry_t root;                // root of list of process in target cluster
+    xptr_t        lock_xp;             // extended pointer on lock protecting  this list
+    // get target cluster identifier and local thread identifier
+    target_cxy         = CXY_FROM_TRDID( trdid );
+    target_thread_ltid = LTID_FROM_TRDID( trdid );
+    // get root of list of process descriptors in target cluster
+    hal_remote_memcpy( XPTR( local_cxy  , &root ),
+                       XPTR( target_cxy , &LOCAL_CLUSTER->pmgr.local_root ),
+                       sizeof(xlist_entry_t) );
+    // get extended pointer on lock protecting the list of processes
+    lock_xp = XPTR( target_cxy , &LOCAL_CLUSTER->pmgr.local_lock );
+    // take the lock protecting the list of processes in target cluster
+    remote_spinlock_lock( lock_xp );
+    // loop on list of process in target cluster to find the PID process
+    xptr_t  iter;
+    bool_t  found = false;
+    XLIST_FOREACH( XPTR( target_cxy , &LOCAL_CLUSTER->pmgr.local_root ) , iter )
+    {
+        target_process_xp  = XLIST_ELEMENT( iter , process_t , local_list );
+        target_process_ptr = (process_t *)GET_PTR( target_process_xp );
+        target_process_pid = hal_remote_lw( XPTR( target_cxy , &target_process_ptr->pid ) );
+        if( target_process_pid == pid )
+        {
+            found = true;
+            break;
+        }
+    }
+    // release the lock protecting the list of processes in target cluster
+    remote_spinlock_unlock( lock_xp );
+    // check target thread found
+    if( found == false )
+    {
+        return XPTR_NULL;
+    }
+    // get target thread local pointer
+    xptr_t xp = XPTR( target_cxy , &target_process_ptr->th_tbl[target_thread_ltid] );
+    target_thread_ptr = (thread_t *)hal_remote_lpt( xp );
+    if( target_thread_ptr == NULL )
+    {
+        return XPTR_NULL;
+    }
+    return XPTR( target_cxy , target_thread_ptr );
+}  // end thread_get_xptr()

trunk/kernel/kern/thread.h

-                      r16
+                      r23
+ *
  * Author  Ghassan Almaless (2008,2009,2010,2011,2012)
- *         Mohamed Lamine Karaoui (2015)
  *         Alain Greiner (2016)
+ *
 …
 /***************************************************************************************
+ * This defines the various pthread_attr_t flags.
+ **************************************************************************************/
+#define PT_FLAG_DETACH                0x001    // user defined not joinable
+#define PT_FLAG_CLUSTER_DEFINED       0x002    // user defined target cluster
+#define PT_FLAG_CORE_DEFINED          0x004    // user defined core cluster
+/***************************************************************************************
+ * This structure defines the input argument of the pthread_create() system call.
+ * It contains all informations required to initialize an user thread, and is passed
+ * as input argument to the thread_user_create() function.
+ * It is partly set by the kernel, partly set by the user application itself,
+ * using the pthread_attr_***() functions.
+ * These macros are used to compose or decompose global thread identifier (TRDID)
+ * to or from cluster identifier / local thread index (CXY , LTID)
+ **************************************************************************************/
+#define LTID_FROM_TRDID( trdid )   (ltid_t)(trdid & 0x0000FFFF)
+#define CXY_FROM_TRDID( trdid )    (cxy_t)(trdid >> 16)
+#define TRDID( cxy , ltid )        (trdid_t)((cxy << 16) | ltid )
+/***************************************************************************************
+ * This defines the various pthread_attr_t attributes bit-vector.
+ **************************************************************************************/
+/***************************************************************************************
+ * This opaque structure contains the user defined attributes for an user thread.
+ * It is passed as input argument to the thread_user_create() function.
+ * It is set by the user application itself, using the pthread_attr_***() functions.
+ * The currently supported attributes are defined below.
  **************************************************************************************/
 typedef struct pthread_attr_s
+{
+    pid_t       pid;             /*! owner process identifier                         */
+        void      * entry_func;      /*! pointer on entry function                        */
+        void      * entry_args;      /*! pointer on entry function arguments              */
+        uint32_t    flags;           /*! pthread flags        (entirely user specified)   */
+        cxy_t       cxy;             /*! target cluster       (can be user specified)     */
+        lid_t       lid;             /*! target core          (can be user specified)     */
+        uint32_t    attributes;      /*! user defined attributes bit vector               */
+        cxy_t       cxy;             /*! target cluster identifier                        */
+        lid_t       lid;             /*! target core index                                */
+}
 pthread_attr_t;
+typedef enum
+{
+    PT_ATTR_DETACH          = 0x0001,  /*! user defined not joinable                  */
+    PT_ATTR_CLUSTER_DEFINED = 0x0002,  /*! user defined target cluster                */
+    PT_ATTR_CORE_DEFINED    = 0x0004,  /*! user defined core index in cluster         */
+}
+pt_attributes_t;
 /***************************************************************************************
 …
 /***************************************************************************************
  * This defines the masks associated to the thread flags.
+ * This defines the thread flags bit-vector.
  **************************************************************************************/
 #define THREAD_FLAG_LOADABLE     0x0001  /*! This thread has not been executed yet    */
+#define THREAD_FLAG_DETACHED     0x0002  /*! This user thread is detached from parent */
+#define THREAD_FLAG_DETACHED     0x0002  /*! This thread is detached from parent      */
+#define THREAD_FLAG_JOIN         0x0004  /*! Parent thread made a join                */
+#define THREAD_FLAG_EXIT         0x0008  /*! This thread made an exit                 */
 /***************************************************************************************
 …
  **************************************************************************************/
 #define THREAD_BLOCKED_GLOBAL    0x0001  /*! thread global blocking                   */
+#define THREAD_BLOCKED_GLOBAL    0x0001  /*! thread desactivated / wait activation    */
 #define THREAD_BLOCKED_IO        0x0002  /*! thread wait IO operation completion      */
 #define THREAD_BLOCKED_MAPPER    0x0004  /*! thread wait mapper                       */
+#define THREAD_BLOCKED_EXIT      0x0010  /*! thread requested exit                    */
+#define THREAD_BLOCKED_JOIN      0x0008  /*! thread blocked in join / wait exit       */
+#define THREAD_BLOCKED_EXIT      0x0010  /*! thread blocked in exit / wait join i     */
 #define THREAD_BLOCKED_KILL      0x0020  /*! thread received kill signal              */
 #define THREAD_BLOCKED_SEM       0x0040  /*! thread wait semaphore                    */
 #define THREAD_BLOCKED_PAGE      0x0080  /*! thread wait page access                  */
+#define THREAD_BLOCKED_USERSYNC  0x0100  /*! thread wait POSIX (cond/mutex/barrier)   */
 #define THREAD_BLOCKED_IDLE      0x1000  /*! thread RPC wait activation               */
 #define THREAD_BLOCKED_DEV_QUEUE 0x2000  /*! thread DEV wait queue                    */
 …
  * that is returned by the kernel to the user:
  * - The TRDID 16 LSB bits contain the LTID (Local Thread Index).
  * - The TRDID 16 MSB bits contain the owner cluster CXY.
+ * - The TRDID 16 MSB bits contain the CXY of cluster containing the thread.
  * - The LTID is used to index the th_tbl[] array in the local process descriptor.
  * This TRDID is computed by the process_register_thread() function, when the user
 …
         void              * fpu_context;     /*! used for dynamic FPU allocation          */
         uint32_t            trdid;           /*! thread index (in THTBL)                  */
+        uint32_t            trdid;           /*! thread index (cxy.ltid)                  */
         thread_type_t       type;            /*! thread type                              */
         uint32_t            quantum;         /*! number of clock ticks given to thread    */
 …
         core_t            * core;            /*! pointer to the owner core                */
         process_t         * process;         /*! pointer on local process descriptor      */
+    xptr_t              parent;          /*! extended pointer on parent thread        */
+    void              * exit_value;      /*! exit_value used in case of join          */
         uint32_t            local_locks;         /*! number of local locks owned by thread    */
     list_entry_t        locks_root;      /*! root of local locks list                 */
+    remote_spinlock_t * flags_lock;      /*! lock protecting the flags                */
         uint32_t            remote_locks;        /*! number of local locks owned by thread    */
 …
         error_t             errno;           /*! errno value set by last system call      */
+    uint32_t            utls;            /*! user thread local storage                */
     bool_t              fork_user;       /*! user defined placement for next fork()   */
 …
 /***************************************************************************************
  * This function allocates memory for an user thread descriptor in the local cluster,
  * and initializes it from information contained in the "attr" argument.
  * It is used by the pthread_create system call, the CPU context is initialised from
  * scratch, and the "loadable" field is set.
  * The new thread is attached to the core specified in the "attr" argument.
  * It is registered in the local process descriptor for the process specified in "attr".
+ * and initializes it from information contained in the arguments.
+ * It is used by the "pthread_create" system call.
+ * The CPU context is initialised from scratch, and the "loadable" field is set.
+ * The new thread is attached to the core specified in the <attr> argument.
+ * It is registered in the local process descriptor specified by the <pid> argument.
  * The thread descriptor pointer is returned to allow the parent thread to register it
  * in its children list.
+ * The THREAD_BLOCKED_GLOBAL bit is set, and the thread must be activated to start.
+ ***************************************************************************************
+ * @ new_thread   : address of buffer for new thread descriptor pointer.
+ * The THREAD_BLOCKED_GLOBAL bit is set => the thread must be activated to start.
+ ***************************************************************************************
+ * @ pid          : process identifier.
+ * @ start_func   : pointer on entry function.
+ * @ start_args   : pointer on function argument (can be NULL).
  * @ attr         : pointer on pthread attributes descriptor.
+ * @ u_stack_base : actual user stack size.
+ * @ u_stack_size : actual user stack base.
+ * @ new_thread   : [out] address of buffer for new thread descriptor pointer.
  * @ returns 0 if success / returns ENOMEM if error.
  **************************************************************************************/
+error_t thread_user_create( thread_t       ** new_thread,
+error_t thread_user_create( pid_t             pid,
+                            void            * start_func,
+                            void            * start_arg,
                             pthread_attr_t  * attr,
+                            intptr_t          u_stack_base,
+                            uint32_t          u_stack_size );
+                            thread_t       ** new_thread );
 /***************************************************************************************
 …
  * The THREAD_BLOCKED_GLOBAL bit is set, and the thread must be activated to start.
  ***************************************************************************************
- * @ new_thread   : address of buffer for new thread descriptor pointer.
  * @ process      : local pointer on owner process descriptor.
+ * @ u_stack_base : actual user stack size.
+ * @ u_stack_size : actual user stack base.
+ * @ new_thread   : [out] address of buffer for new thread descriptor pointer.
  * @ returns 0 if success / returns ENOMEM if error.
  **************************************************************************************/
+error_t thread_user_fork( thread_t ** new_thread,
+                          process_t * process,
+                          intptr_t    u_stack_base,
+                          uint32_t    u_stack_size );
+error_t thread_user_fork( process_t * process,
+                          thread_t ** new_thread );
 /***************************************************************************************
 …
  * This function removes an user thread from the parent thread global list
  * of attached children threads.
- * It does take the lock, as this function can be called by the child thread.
- * In this case, it uses the extended pointer on the parent thread contained
- * in the pthread_attr_t embedded in the child thread descriptor.
  ***************************************************************************************
  * @ xp_parent : extended pointer on the parent thread descriptor.
 …
 void thread_child_parent_unlink( xptr_t xp_parent,
                                  xptr_t xp_child );
 /***************************************************************************************
 …
 void thread_signals_handle( thread_t * thread );
+/***************************************************************************************
+ * This function returns the extended pointer on a thread descriptor identified
+ * by its thread identifier, and process identifier.
+ * It can be called by any thread running in any cluster.
+ ***************************************************************************************
+ * @ pid     : process identifier.
+ * @ trdid   : thread identifier.
+ * @ return the extended pointer if thread found / return XPTR_NULL if not found.
+ **************************************************************************************/
+xptr_t thread_get_xptr( pid_t    pid,
+                        trdid_t  trdid );

trunk/kernel/kern/time.h

-                      r1
+                      r23
 /*
  * time.h: thread time related management
+ * time.h - Structure used by gettimeofday.
+ *
+ * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
+ * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ * author    Alain Greiner (2016,2017)
+ *
  * This file is part of ALMOS-kernel.
+ * Copyright (c) UPMC Sorbonne Universites
+ *
+ * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * This file is part of ALMOS-MKH.
+ *
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
 …
 #define _TIME_H_
+#include <types.h>
+#include <list.h>
+#include <device.h>
+#include <hal_types.h>
-struct event_s;
 struct alarm_info_s
+struct timeval
+{
+        uint_t signature;
+        /* Public members */
+        struct event_s *event;
+        /* Private members */
+        uint_t tm_wakeup;
+        struct list_entry list;
+        uint32_t tv_sec;        /* secondes */
+        uint32_t tv_usec;       /* microsecondes */
 };
+struct alarm_s
+{
+        struct list_entry wait_queue;
+};
+struct timeb {
+        time_t         time;
+        unsigned short millitm;
+        short          timezone;
+        short          dstflag;
+};
+struct timeval {
+        clock_t tv_sec;    /* secondes */
+        clock_t tv_usec;   /* microsecondes */
+};
+struct timezone {
+struct timezone
+{
         int tz_minuteswest;     /* minutes west of Greenwich */
         int tz_dsttime;         /* type of DST correction */
 };
-struct tms
+{
-       clock_t tms_utime;  /* user time */
-       clock_t tms_stime;  /* system time */
-       clock_t tms_cutime; /* user time of children */
-       clock_t tms_cstime; /* system time of children */
-};
-error_t alarm_manager_init(struct alarm_s *alarm);
-error_t alarm_wait(struct alarm_info_s *info, uint_t msec);
-void alarm_clock(struct alarm_s *alarm, uint_t ticks_nr);
-int sys_clock (uint64_t *val);
-int sys_alarm (unsigned nb_sec);
-int sys_ftime (struct timeb *utime);
-int sys_times(struct tms *utms);
-int sys_gettimeofday(struct timeval *tv, struct timezone *tz);
-#if CONFIG_THREAD_TIME_STAT
-struct thread_s;
-inline void tm_sleep_compute(struct thread_s *thread);
-inline void tm_usr_compute(struct thread_s *thread);
-inline void tm_sys_compute(struct thread_s *thread);
-inline void tm_wait_compute(struct thread_s *thread);
-inline void tm_exit_compute(struct thread_s *thread);
-inline void tm_born_compute(struct thread_s *thread);
-inline void tm_create_compute(struct thread_s *thread);
-#else
-#define tm_sleep_compute(thread)
-#define tm_usr_compute(thread)
-#define tm_sys_compute(thread)
-#define tm_wait_compute(thread)
-#define tm_exit_compute(thread)
-#define tm_born_compute(thread)
-#define tm_create_compute(thread)
-#endif  /* CONFIG_SCHED_STAT */
 #endif  /* _TIME_H_ */

trunk/kernel/libk/bits.c

-                      r11
+                      r23
 #include <hal_types.h>
 #include <bits.h>
+////////////////////////////////////
+void bitmap_init( bitmap_t * bitmap,
+                  uint32_t   len )
+{
+    uint32_t word;
+    uint32_t nwords = BITMAP_SIZE( len );
+    for( word = 0 ; word < nwords ; word++ )
+    {
+        bitmap[word] = 0;
+    }
+}  // end bitmap_init()
 //////////////////////////////////////////

trunk/kernel/libk/bits.h

-                      r14
+                      r23
 /**********************************************************************************************
  * This macro returns the number of 32 bits words required to register size entries.
+ * This macro returns the number of 32 bits words required to register <size> entries.
  *********************************************************************************************/
 #define BITMAP_SIZE(size) ( ((size) & 31) ? (((size)>>5) + 1) : ((size)>>5) )
-/**********************************************************************************************
- * This macro declare a bitmap data structure. It is actually an array of uint32_t.
- * size is the total number of entries in the bitmap.
- *********************************************************************************************/
-#define BITMAP( name , size )     uint32_t name[BITMAP_SIZE(size)]
 typedef uint32_t    bitmap_t;
+/**********************************************************************************************
+/*********************************************************************************************
+ * This function reset all bits in a bitmap. (array ot 32 bits words).
+ *********************************************************************************************
+ * @ bitmap  : pointer on first word in the bitmap.
+ * @ len     : number of bits to reset.
+ ********************************************************************************************/
+void bitmap_init( bitmap_t * bitmap,
+                  uint32_t   len );
+/*********************************************************************************************
  * This function set a specific bit in a bitmap.
  **********************************************************************************************
+ *********************************************************************************************
  * @ bitmap  : pointer on the bitmap
  * @ index   : bit index in the bitmap
  *********************************************************************************************/
+ ********************************************************************************************/
 extern inline void bitmap_set( bitmap_t * bitmap,
                                uint32_t   index );
 /**********************************************************************************************
+/*********************************************************************************************
  * This function clear a specific bit in a bitmap.
  **********************************************************************************************
+ *********************************************************************************************
  * @ bitmap  : pointer on the bitmap
  * @ index   : bit index in the bitmap
  *********************************************************************************************/
+ ********************************************************************************************/
 extern inline void bitmap_clear( bitmap_t * bitmap,
                                  uint32_t   index );
 /**********************************************************************************************
+/*********************************************************************************************
  * This function returns a specific bit in a bitmap.
  **********************************************************************************************
+ *********************************************************************************************
  * @ bitmap  : pointer on the bitmap
  * @ index   : bit index in the bitmap
  * @ returns tru if bitmap[index] is set
  *********************************************************************************************/
+ * @ returns true if bitmap[index] is set
+ ********************************************************************************************/
 extern inline bool_t bitmap_state( bitmap_t * bitmap,
                                    uint32_t   index );
 /**********************************************************************************************
+/*********************************************************************************************
  * This function set a range of bits in a bitmap : [index ... (index + len)[
  **********************************************************************************************
+ *********************************************************************************************
  * @ bitmap  : pointer on the bitmap
  * @ index   : first bit index in the bitmap
  * @ len     : number of bits to set
  *********************************************************************************************/
+ ********************************************************************************************/
 extern void bitmap_set_range( bitmap_t * bitmap,
                               uint32_t   index,
                               uint32_t   len );
 /**********************************************************************************************
+/*********************************************************************************************
  * This function reset a range of bits in a bitmap : [index ... (index + len)[
  **********************************************************************************************
+ *********************************************************************************************
  * @ bitmap  : pointer on the bitmap
  * @ index   : first bit index in the bitmap
  * @ len     : number of bits to clear
  *********************************************************************************************/
+ ********************************************************************************************/
 extern void bitmap_clear_range( bitmap_t * bitmap,
                                 uint32_t   index,
                                 uint32_t   len );
 /**********************************************************************************************
+/*********************************************************************************************
  * This function returns the index of first bit set in a bitmap, starting from index.
  **********************************************************************************************
+ *********************************************************************************************
  * @ bitmap  : pointer on the bitmap
  * @ index   : first bit to analyse in the bitmap
  * @ size    : number of bits to analyse in bitmap
  * @ returns index if found / returns 0xFFFFFFFF if bit not found
  *********************************************************************************************/
+ ********************************************************************************************/
 extern uint32_t bitmap_ffs2( bitmap_t * bitmap,
                              uint32_t   index,
                              uint32_t   size );
 /**********************************************************************************************
+/*********************************************************************************************
  * This function returns the index of first bit cleared in a bitmap, starting from index.
  **********************************************************************************************
+ *********************************************************************************************
  * @ bitmap  : pointer on the bitmap
  * @ index   : first bit to analyse in the bitmap
  * @ size    : number of bits to analyse in bitmap
  * @ returns index if found / returns 0xFFFFFFFF if bit not found
  *********************************************************************************************/
+ ********************************************************************************************/
 extern uint32_t bitmap_ffc2( bitmap_t * bitmap,
                              uint32_t   index,
                              uint32_t   size );
 /**********************************************************************************************
+/*********************************************************************************************
  * This function returns the index of first bit set in a bitmap, starting from bit 0.
  **********************************************************************************************
+ *********************************************************************************************
  * @ bitmap  : pointer on the bitmap
  * @ size    : number of bits to analyse in bitmap
  * @ returns index if found / returns 0xFFFFFFFF if bit not found
  *********************************************************************************************/
+ ********************************************************************************************/
 extern uint32_t bitmap_ffs( bitmap_t * bitmap,
                             uint32_t   size );
 /**********************************************************************************************
+/*********************************************************************************************
  * This function returns the index of first bit cleared in a bitmap, starting from bit 0.
  **********************************************************************************************
+ *********************************************************************************************
  * @ bitmap  : pointer on the bitmap
  * @ size    : number of bits to alalyse in bitmap
  * @ returns index if found / returns 0xFFFFFFFF if bit not found
  *********************************************************************************************/
+ ********************************************************************************************/
 extern uint32_t bitmap_ffc( bitmap_t * bitmap,
                             uint32_t   size );
 /**********************************************************************************************
+/*********************************************************************************************
  * This function returns the number of bits to code a non-zero unsigned integer value.
  **********************************************************************************************
+ *********************************************************************************************
  * @ val   : value to analyse
  * @ returns number of bits
  *********************************************************************************************/
+ ********************************************************************************************/
 static inline uint32_t bits_nr( uint32_t val )
+{
 …
+}
 /**********************************************************************************************
+/*********************************************************************************************
  * This function takes an unsigned integer value as input argument, and returns another
  * unsigned integer, that is the (base 2) logarithm of the smallest power of 2 contained
  * in the input value.
  **********************************************************************************************
+ *********************************************************************************************
  * @ val   : value to analyse
  * @ returns logarithm value
  *********************************************************************************************/
+ ********************************************************************************************/
 static inline uint32_t bits_log2( uint32_t val )
+{

trunk/kernel/libk/elf.c

-                      r14
+                      r23
 #include <vfs.h>
 #include <elf.h>
+#include <syscalls.h>
 …
     // load .elf header
+        count = vfs_read( file_xp , buffer , size );
+        count = vfs_move( true ,
+                      file_xp,
+                      buffer,
+                      size );
         if( count != size )
 …
         // set seek on segment base in file
+                error = vfs_lseek( file_xp , offset , VFS_SEEK_SET , NULL );
+                error = vfs_lseek( file_xp,
+                           offset,
+                           SEEK_SET,
+                           NULL );
                 if( error )
 …
                           process_t * process)
+{
+    char         path_copy[CONFIG_VFS_MAX_PATH_LENGTH];
         kmem_req_t   req;              // kmem request for program header
-    char         path_copy[256];   // local copy of pathname
         uint32_t     length;           // actual path length
         Elf32_Ehdr   header;           // local buffer for .elf header
 …
     uint32_t     segs_size;        // size of buffer for segment descriptors array
         xptr_t       file_xp;          // extended pointer on created file descriptor
+    uint32_t     file_id;          // file descriptor index (unused)
     uint32_t     count;            // bytes counter
         error_t      error;
 …
         length = hal_strlen_from_uspace( pathname );
     if( length > 255 )
+    if( length >= CONFIG_VFS_MAX_PATH_LENGTH )
+    {
         printk("\n[ERROR] in %s : pathname length too long\n", __FUNCTION__ );
 …
     // open file
     file_xp = XPTR_NULL;  // avoid GCC warning
+    file_id = -1;
         error = vfs_open( process->vfs_cwd_xp,
                       path_copy,
+                      VFS_O_RDONLY,
+                      &file_xp );
+                      O_RDONLY,
+,
+                      &file_xp,
+                      &file_id );
         if( error )
+        {
 …
         if( error )
+    {
         vfs_close( file_xp , &count );
+        vfs_close( file_xp , file_id );
         return -1;
+    }
 …
+        {
                 printk("\n[ERROR] in %s : no segments found\n", __FUNCTION__ );
         vfs_close( file_xp , &count );
+        vfs_close( file_xp , file_id );
                 return -1;
+        }
 …
+    {
                 printk("\n[ERROR] in %s : no memory for segment descriptors\n", __FUNCTION__ );
         vfs_close( file_xp , &count );
+        vfs_close( file_xp , file_id );
         return -1;
+    }
     // set seek pointer in file descriptor to access segment descriptors array
         error = vfs_lseek( file_xp , header.e_phoff, VFS_SEEK_SET , NULL );
+        error = vfs_lseek( file_xp , header.e_phoff, SEEK_SET , NULL );
         if( error )
+        {
                 printk("\n[ERROR] in %s : cannot seek for descriptors array\n", __FUNCTION__ );
         vfs_close( file_xp , &count );
+        vfs_close( file_xp , file_id );
             req.ptr = segs_base;
             kmem_free( &req );
 …
     // load seg descriptors array to local buffer
+        count = vfs_read( file_xp,
+        count = vfs_move( true,
+                      file_xp,
                       segs_base,
                       segs_size );
 …
+        {
                 printk("\n[ERROR] in %s : cannot read segments descriptors\n", __FUNCTION__ );
         vfs_close( file_xp , &count );
+        vfs_close( file_xp , file_id );
             req.ptr = segs_base;
             kmem_free( &req );
 …
         if( error )
+    {
         vfs_close( file_xp , &count );
+        vfs_close( file_xp , file_id );
             req.ptr = segs_base;
             kmem_free( &req );

trunk/kernel/libk/htab.c

-                      r1
+                      r23
  * htable.c - Generic, embedded hash table implementation.
+ *
+ * Author     Ghassan Almalles (2008,2009,2010,2011,2012)
+ *            Mohamed Lamine Karaoui (2015)
+ *            Alain Greiner (2016)
+ * Author      Alain Greiner (2016,2017)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
  * This file is part of ALMOS-MKH.
+ *
  * ALMOS-MKH.is free software; you can redistribute it and/or modify it
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-MKH.is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-MKH.; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
+#include <htable.h>
+#include <kmem.h>
+#include <ppm.h>
+///////////////////////////////////////////////
+error_t ht_header_init( ht_header_t  * header,
+                        ht_hash_t    * hash,
+                        ht_compare_t * compare )
+#include <kernel_config.h>
+#include <hal_types.h>
+#include <hal_special.h>
+#include <htab.h>
+#include <rwlock.h>
+#include <list.h>
+#include <printk.h>
+#include <vfs.h>
+///////////////////////////////////////////////////////////////////////////////////////////
+//    Item type specific (static) functions (two functions for each item type).
+// Example below if for <vhs_inode_t>, where the identifier is the inum field.
+///////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////
+// These static functions compute the hash index from the key.
+///////////////////////////////////////////////////////////////////////////////////////////
+// @ key      : local pointer on key.
+// @ return the index value, from 0 to (HASHTAB_SIZE - 1)
+///////////////////////////////////////////////////////////////////////////////////////////
+static uint32_t htab_inode_index( void * key )
+{
+        uint32_t * inum = key;
+        return (((*inum) >> 16) ^ ((*inum) & 0xFFFF)) % HASHTAB_SIZE;
+}
+///////////////////////////////////////////////////////////////////////////////////////
+// These static functions are used by htab_lookup(), htab_insert(), and htab_remove().
+// They scan one sub-list identified by  <index> to find an item  identified by <key>.
+// The sub-list is not modified, but the lock must have been taken by the caller.
+///////////////////////////////////////////////////////////////////////////////////////
+// @ htab    : pointer on hash table.
+// @ index   : index of sub-list to be scanned.
+// @ key     : pointer on item identifier.
+// @ return pointer on item if found / return NULL if not found.
+///////////////////////////////////////////////////////////////////////////////////////
+static void * htab_inode_scan( htab_t  * htab,
+                               uint32_t  index,
+                               void    * key )
+{
+    list_entry_t * list_entry;   // pointer on list_entry_t (iterator)
+    vfs_inode_t  * inode;        // pointer on item
+        LIST_FOREACH( &htab->roots[index] , list_entry )
+        {
+        inode = (vfs_inode_t *)LIST_ELEMENT( list_entry , vfs_inode_t , list );
+        if( inode->inum == *(uint32_t *)key ) return inode;
+    }
+    // no matching item found
+        return NULL;
+}
+////////////////////////////////////////////////////////////////////////////////////////
+//         Generic access functions
+////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////
+void htab_init( htab_t           * htab,
+                htab_item_type_t   type )
+{
         uint32_t     i;
+        kmem_req_t   req;
+        page_t     * page;
+        req.type  = KMEM_PAGE;
+        req.size  = 0;
+        req.flags = AF_ZERO;
+        page      = kmem_alloc( &req );
+        if( page == NULL ) return ENOMEM;
+        header->nb_buckets = CONFIG_PPM_PAGE_SIZE/sizeof( list_entry_t );
+        header->buckets    = ppm_page2base( page );
+        header->hash       = hash;
+        header->compare    = compare;
+        for( i=0 ; i < header->nb_buckets ; i++ )
+        {
+                list_root_init( &header->buckets[i] );
+        }
+        return 0;
+}
+////////////////////////////////////////
+error_t ht_node_init( ht_node_t * node )
+{
+        node->index = (uint32_t) -1;
+        list_entry_init( &node->list );
+        return 0;
+}
+/////////////////////////////////////////////////
+static ht_node_t * __hfind( ht_header_t * header,
+                            uint32_t      index,
+                            void        * key)
+{
+        ht_node_t    * node;
+        list_entry_t * root,
+    list_entry_t * iter;
+        root = &header->buckets[index % header->nb_buckets];
+        LIST_FOREACH( root , iter )
+        {
+                node = LIST_ELEMENT( iter , ht_node_t , list );
+                if( node->index == index )
+                {
+                        if( header->compare( node , key ) ) return node;
+                }
+        }
+        return NULL;
+}
+//////////////////////////////////////////
+ht_node_t * ht_find( ht_header_t * header,
+                     void        * key )
+{
+        uint32_t index = header->hash( key );
+        return __ht_find( header , index , key );
+}
+////////////////////////////////////////
+error_t ht_insert( ht_header_t * header,
+                   ht_node_t   * node,
+                   void        * key )
+{
+        uint32_t index = header->hash( key );
+        ht_node_t * node = __ht_find( header , index , key );
+        if( node != NULL ) return EINVAL;
+        list_entry_t * root = &header->buckets[index % header->nb_buckets];
+        list_add_first( root , &node->list);
+        node->index = index;
+        return 0;
+}
+////////////////////////////////////////
+error_t ht_remove( ht_header_t * header,
+                   void        * key )
+{
+        uint32_t index = header->hash( key );
+        ht_node_t * node = __ht_find( header , index , key );
+        if( node == NULL ) return EINVAL;
+        list_unlink( &node->list );
+        return 0;
+}
+    // initialize readlock
+    rwlock_init( &htab->lock );
+    htab->items = 0;
+    if( type == HTAB_INODE_TYPE )
+    {
+        htab->scan    = &htab_inode_scan;
+        htab->index   = &htab_inode_index;
+    }
+    else
+    {
+        printk("\n[PANIC] in %s : undefined item type\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
+    // initialize partial lists
+    for( i = 0 ; i < HASHTAB_SIZE ; i++ )
+    {
+        list_root_init( &htab->roots[i] );
+    }
+}
+/////////////////////////////////////////
+error_t htab_insert( htab_t       * htab,
+                     void         * key,
+                     list_entry_t * list_entry )
+{
+    // compute index from key
+    uint32_t index = htab->index( key );
+    // take the lock in write mode
+    rwlock_wr_lock( &htab->lock );
+    // scan sub-list to check if item exist
+    void * item = htab->scan( htab , index , key );
+    if( item != NULL ) // item exist => return error
+    {
+        // release lock
+        rwlock_wr_unlock( &htab->lock );
+        return -1;
+    }
+    else               // item doesn't exist => register
+    {
+        // register item in hash table
+        list_add_last( &htab->roots[index] , list_entry );
+        // update items number
+        htab->items++;
+        // release lock
+        rwlock_wr_unlock( &htab->lock );
+        return 0;
+    }
+}
+/////////////////////////////////////////
+error_t htab_remove( htab_t       * htab,
+                     void         * key,
+                     list_entry_t * list_entry )
+{
+    // compute index from key
+    uint32_t index = htab->index( key );
+    // take the lock in write mode
+    rwlock_wr_lock( &htab->lock );
+    // scan sub-list to chek if item exist
+    void * item = htab->scan( htab , index , key );
+    if( item == NULL ) // item doesn't exist
+    {
+        // release lock
+        rwlock_wr_unlock( &htab->lock );
+        return -1;
+    }
+    else               // item exist => remove it
+    {
+        // remove item from hash table
+        list_unlink( list_entry );
+        // update items number
+        htab->items--;
+        // release lock
+        rwlock_wr_unlock( &htab->lock );
+        return 0;
+    }
+}
+//////////////////////////////////
+void * htab_lookup( htab_t * htab,
+                    void   * key )
+{
+    // compute index from key
+    uint32_t index = htab->index( key );
+    // take the lock in read mode
+    rwlock_rd_lock( &htab->lock );
+    // scan sub-list
+    void * item = htab->scan( htab , index , key );
+    // release lock
+    rwlock_rd_unlock( &htab->lock );
+        return item;
+}

trunk/kernel/libk/htab.h

-                      r1
+                      r23
  * htab.h - Generic embedded hash table definition.
+ *
+ * Author     Ghassan Almalles (2008,2009,2010,2011,2012)
+ *            Mohamed Lamine Karaoui (2015)
+ *            Alain Greiner (2016)
+ * Authors  Alain Greiner (2016,2017)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
 #include <hal_types.h>
+#include <rwlock.h>
 #include <list.h>
+/////////////////////////////////////////////////////////////////////////////////////////
+// This file define a generic, embedded, hash table.
+//
+// It can only be accessed by threads running in the local cluster.
+// It is generic as it can be used to register various types of items.
+// The main goal is to provide fast retrieval for a large number of items of same type.
+// For this purpose the set of all registered items is split in several subsets.
+// Each subset is organised as a double linked lists.
+// - an item is uniquely identified by a <key>, that can be a single uint32_t,
+//   a character string, or a more complex structure.
+// - From the pointer on <key>, we use an item type specific htab_index() function,
+//   to compute an <index> value, defining a subset of registered items.
+// - As several items can have the same <index>, we use the item type specific defined
+//   htab_scan() function for a final associative search on the subset.
+// - Each registered item is a structure, that must contain an embedded list_entry_t,
+//   that is part of a rooted double linked list.
+//
+// Implementation Note: for each supported item type ***, you must define the two
+//                      htab_***_index() and htab_***_scan() functions, and
+//                      update the htab_init() function.
+/////////////////////////////////////////////////////////////////////////////////////////
+#define HASHTAB_SIZE    64   // number of subsets
 /****************************************************************************************
+ * This file define a generic, embedded, hash table.
+ * The main goal is to provide fast retrieval for a large number of items of same type
+ * in a given cluster. For this purpose the set of all registered items is split
+ * in several subsets. Each subset is organised as a double linked lists.
+ * - an item is uniquely identified by a <key>, that can be a single uint32_t,
+ *   a character string, or a more complex structure.
+ * - From the pointer on the <key>, the hash table uses an user defined ht_hash()
+ *   function, to compute an <index> value, defining a subset of registered
+ *   items, to restrict the associative search.
+ * - As several items can have the same <index>, the hash table uses the user defined
+ *   ht_compare() function for a final associative search on the subset.
+ * - Each registered item is a structure, that must contain an embedded ht_node_t,
+ *   This ht_node_t is part of a rooted double linked list, and contains the <index>.
+ * - Finally, the hash table returns a pointer on the embedded ht_node_t, and the
+ *   pointer on the searched item can be obtained by a simple offset.
+ * These typedef define the two item type specific function prototypes.
  ***************************************************************************************/
+struct htab_s;
+typedef void *     htab_scan_t( struct htab_s * htab , uint32_t index , void * key );
+typedef uint32_t   htab_index_t( void * key );
 /****************************************************************************************
  * This define the generic, user defined, function types.
+ * This define the supported item types.
  ***************************************************************************************/
+struct ht_node_s;
+typedef bool_t     ht_compare_t( struct ht_node_s * node , void * key );
+typedef uint32_t   ht_hash_t( void * key );
+typedef enum
+{
+    HTAB_INODE_TYPE = 1,                     /*! item is a vfs_inode_t                 */
+}
+htab_item_type_t;
 /****************************************************************************************
  * This structure defines the hash table header.
+ * This structure defines the the root of a local hash table.
  ***************************************************************************************/
 typedef struct ht_header_s
+typedef struct htab_s
+{
+        uint32_t        nb_buckets;   /*! number of subsets (one linked list per subset)   */
+        ht_hash_t     * hash;         /*! user defined hash function                       */
+        ht_compare_t  * compare;      /*! user defined compare function                    */
+        list_entry_t  * buckets;      /*! array of root of partial lists of ht_node_t      */
+        list_entry_t      roots[HASHTAB_SIZE];  /*! array of roots of partial lists        */
+        htab_index_t    * index;                /*! item type  specific function           */
+        htab_scan_t     * scan;                 /*! item type specific function            */
+    uint32_t          items;                /*! number of registered items             */
+    rwlock_t          lock;                 /*! lock protecting hash table accesses    */
+}
 ht_header_t;
+htab_t;
 /****************************************************************************************
+ * This structure defines one hash table node.
+ * This function initialises an empty hash table (zero registered item).
+ ****************************************************************************************
+ * @ htab       : pointer on hash table.
+ * @ type       : item type.
  ***************************************************************************************/
+typedef struct ht_node_s
+{
+        uint32_t     index;           /*! integer value computed from the key              */
+        list_entry_t list;                /*! member of list of all nodes in same bucket       */
+}
+ht_node_t;
+void htab_init( htab_t           * htab,
+                htab_item_type_t   type );
 /****************************************************************************************
  * This function initialises one hash table node.
+ * This function register a new item in the hash table.
  ****************************************************************************************
+ccccc
+ * @ htab       : pointer on the hash table.
+ * @ key        : pointer on the item identifier.
+ * @ list_entry : pointer on list_entry_t embedded in item to be registered.
+ * @ return 0 if success / return EINVAL if item already registered.
  ***************************************************************************************/
+void ht_node_init( ht_node_t * node );
+error_t htab_insert( htab_t       * htab,
+                     void         * key,
+                     list_entry_t * list_entry );
 /****************************************************************************************
+ * This function allocates memory for the buckets array, and initializes the header.
+ * The number of buckets (number of subsets) is PAGE_SIZE / sizeof(list_entry_t)
+ * This function remove an item from the hash table.
  ****************************************************************************************
  * @ header     : pointer on the hash table header.
  * @ ht_hash    : pointer on the user defined hash function.
  * @ ht_compare : pointer on the user defined compare function.
  * @ return 0 if success / return ENOMEM if error.
+ * @ header     : pointer on the hash table.
+ * @ key        : pointer on the item identifier.
+ * @ list_entry : pointer on list_entry_t embedded in item to be removed.
+ * @ return 0 if success / return EINVAL if item not found.
  ***************************************************************************************/
+error_t ht_header_init( ht_header_t  * header,
+                        ht_hash_t    * ht_hash,
+                        ht_compare_t * ht_compare );
+/****************************************************************************************
+ * This function register a new node in the hash table.
+ ****************************************************************************************
+ * @ header     : pointer on the hash table header.
+ * @ node       : pointer on the node to be registered (embedded in item).
+ * @ key        : pointer on the item identifier.
+ * @ return 0 if success / return EINVAL if node already registered...
+ ***************************************************************************************/
+error_t ht_insert( ht_header_t * header,
+                   ht_node_t   * node,
+                   void        * key );
+error_t htab_remove( htab_t       * htab,
+                     void         * key,
+                     list_entry_t * list_entry );
 /****************************************************************************************
 …
  * identified by its key.
  ****************************************************************************************
  * @ header     : pointer on the hash table header.
  * @ key        : pointer on the item identifier.
  * @ return pointer on node if found / return NULL if not found.
+ * @ htab      : pointer on the hash table.
+ * @ key       : pointer on the item identifier.
+ * @ return pointer on item if found / return NULL if not found.
  ***************************************************************************************/
 ht_node_t * ht_find( ht_header_t * header,
                      void        * key);
+void * htab_lookup( htab_t * htab,
+                    void   * key);
-/****************************************************************************************
- * This function remove an item from the hash table.
- ****************************************************************************************
- * @ header     : pointer on the hash table header.
- * @ key        : pointer on the item identifier.
- * @ return 0 if success / return EINVAL if not found.
- ***************************************************************************************/
-error_t ht_remove( ht_header_t * header,
-                   void        * key );
 #endif /* _HTABLE_H_ */
+#endif /* _HTAB_H_ */

trunk/kernel/libk/remote_barrier.c

-                      r14
+                      r23
 /*
  * remote_barrier.c - distributed kernel barrier implementaion
+ * remote_barrier.c - Access a POSIX barrier.
+ *
  * Author   Alain Greiner (2016)
+ * Author   Alain Greiner (2016,2017)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
 #include <hal_types.h>
 #include <hal_remote.h>
+#include <hal_irqmask.h>
+#include <remote_spinlock.h>
+#include <thread.h>
+#include <kmem.h>
+#include <printk.h>
+#include <process.h>
+#include <vmm.h>
 #include <remote_barrier.h>
 /////////////////////////////////////////
 inline void remote_barrier( xptr_t    xp,
+/////////////////////////////////////////////////
+inline void remote_barrier( xptr_t    barrier_xp,
                             uint32_t  count )
+{
     uint32_t  expected;
     remote_barrier_t * ptr = (remote_barrier_t *)GET_PTR( xp );
     cxy_t              cxy = GET_CXY( xp );
+    remote_barrier_t * ptr = (remote_barrier_t *)GET_PTR( barrier_xp );
+    cxy_t              cxy = GET_CXY( barrier_xp );
     // get barrier sense value
 …
+}
+///////////////////////////////////////////////////
+xptr_t remote_barrier_from_ident( intptr_t  ident )
+{
+    // get pointer on local process_descriptor
+    process_t * process = CURRENT_THREAD->process;
+    // get extended pointer on reference process
+    xptr_t      ref_xp = process->ref_xp;
+    // get cluster and local pointer on reference process
+    cxy_t          ref_cxy = GET_CXY( ref_xp );
+    process_t    * ref_ptr = (process_t *)GET_PTR( ref_xp );
+    // get extended pointer on root of barriers list
+    xptr_t root_xp = XPTR( ref_cxy , &ref_ptr->barrier_root );
+    // scan reference process barriers list
+    xptr_t             iter_xp;
+    xptr_t             barrier_xp;
+    cxy_t              barrier_cxy;
+    remote_barrier_t * barrier_ptr;
+    intptr_t           current;
+    bool_t             found = false;
+    XLIST_FOREACH( root_xp , iter_xp )
+    {
+        barrier_xp  = XLIST_ELEMENT( iter_xp , remote_barrier_t , list );
+        barrier_cxy = GET_CXY( barrier_xp );
+        barrier_ptr = (remote_barrier_t *)GET_PTR( barrier_xp );
+        current     = (intptr_t)hal_remote_lpt( XPTR( barrier_cxy , &barrier_ptr->ident ) );
+        if( ident == current )
+        {
+            found = true;
+            break;
+        }
+    }
+    if( found == false )  return XPTR_NULL;
+    else                  return barrier_xp;
+}  // end remote_barrier_from_ident()
+//////////////////////////////////////////////
+error_t remote_barrier_create( intptr_t ident,
+                               uint32_t count )
+{
+    xptr_t             barrier_xp;
+    remote_barrier_t * barrier_ptr;
+    // get pointer on local process descriptor
+    process_t * process = CURRENT_THREAD->process;
+    // get extended pointer on reference process
+    xptr_t      ref_xp = process->ref_xp;
+    // get reference process cluster and local pointer
+    cxy_t       ref_cxy = GET_CXY( ref_xp );
+    process_t * ref_ptr = (process_t *)GET_PTR( ref_xp );
+    // allocate memory for barrier descriptor
+    if( ref_cxy == local_cxy )                  // local cluster is the reference
+    {
+        kmem_req_t req;
+        req.type      = KMEM_BARRIER;
+        req.flags     = AF_ZERO;
+        barrier_ptr   = kmem_alloc( &req );
+        barrier_xp    = XPTR( local_cxy , barrier_ptr );
+    }
+    else                                       // reference is remote
+    {
+        rpc_kcm_alloc_client( ref_cxy , KMEM_BARRIER , &barrier_xp );
+        barrier_ptr = (remote_barrier_t *)GET_PTR( barrier_xp );
+    }
+    if( barrier_ptr == NULL ) return ENOMEM;
+    // initialise barrier
+    hal_remote_sw ( XPTR( ref_cxy , &barrier_ptr->nb_threads ) , count );
+    hal_remote_sw ( XPTR( ref_cxy , &barrier_ptr->current    ) , 0 );
+    hal_remote_sw ( XPTR( ref_cxy , &barrier_ptr->sense      ) , 0 );
+    hal_remote_spt( XPTR( ref_cxy , &barrier_ptr->ident      ) , (void*)ident );
+    xlist_entry_init( XPTR( ref_cxy , &barrier_ptr->list ) );
+    // register  barrier in reference process xlist
+    xptr_t root_xp  = XPTR( ref_cxy , &ref_ptr->barrier_root );
+    xptr_t entry_xp = XPTR( ref_cxy , &barrier_ptr->list );
+    remote_spinlock_lock( XPTR( ref_cxy , &ref_ptr->sync_lock ) );
+    xlist_add_first( root_xp , entry_xp );
+    remote_spinlock_unlock( XPTR( ref_cxy , &ref_ptr->sync_lock ) );
+    return 0;
+}  // end remote_barrier_create()
+////////////////////////////////////////////////
+void remote_barrier_destroy( xptr_t barrier_xp )
+{
+    // get pointer on local process descriptor
+    process_t * process = CURRENT_THREAD->process;
+    // get extended pointer on reference process
+    xptr_t      ref_xp = process->ref_xp;
+    // get reference process cluster and local pointer
+    cxy_t       ref_cxy = GET_CXY( ref_xp );
+    process_t * ref_ptr = (process_t *)GET_PTR( ref_xp );
+    // get barrier cluster and local pointer
+    cxy_t              barrier_cxy = GET_CXY( barrier_xp );
+    remote_barrier_t * barrier_ptr = (remote_barrier_t *)GET_PTR( barrier_xp );
+    // remove barrier from reference process xlist
+    remote_spinlock_lock( XPTR( ref_cxy , &ref_ptr->sync_lock ) );
+    xlist_unlink( XPTR( barrier_cxy , &barrier_ptr->list ) );
+    remote_spinlock_unlock( XPTR( ref_cxy , &ref_ptr->sync_lock ) );
+    // release memory allocated for barrier descriptor
+    if( barrier_cxy == local_cxy )                        // reference is local
+    {
+        kmem_req_t  req;
+        req.type = KMEM_BARRIER;
+        req.ptr  = barrier_ptr;
+        kmem_free( &req );
+    }
+    else                                                  // reference is remote
+    {
+        rpc_kcm_free_client( barrier_cxy , barrier_ptr , KMEM_BARRIER );
+    }
+}  // end remote_barrier_destroy()
+/////////////////////////////////////////////
+void remote_barrier_wait( xptr_t barrier_xp )
+{
+    uint32_t  expected;
+    uint32_t  current;
+    uint32_t  count;
+    uint32_t  sense;
+    uint32_t  irq_state;
+    xptr_t    root_xp;
+    // get cluster and local pointer on calling thread
+    cxy_t              thread_cxy = local_cxy;
+    thread_t         * thread_ptr = CURRENT_THREAD;
+    // get cluster and local pointer on remote barrier
+    remote_barrier_t * barrier_ptr = (remote_barrier_t *)GET_PTR( barrier_xp );
+    cxy_t              barrier_cxy = GET_CXY( barrier_xp );
+    // get count and root fields from barrier descriptor
+    count   = hal_remote_lw ( XPTR( barrier_cxy , &barrier_ptr->nb_threads ) );
+    root_xp = hal_remote_lwd( XPTR( barrier_cxy , &barrier_ptr->root ) );
+    // get barrier sense value
+    sense = hal_remote_lw( XPTR( barrier_cxy , &barrier_ptr->sense ) );
+        // compute expected value
+    if ( sense == 0 ) expected = 1;
+    else              expected = 0;
+    // atomically increment current
+    current = hal_remote_atomic_add( XPTR( barrier_cxy , &barrier_ptr->current ) , 1 );
+    // last thread reset current, toggle sense, and activate all waiting threads
+    // other threads block, register in queue, and deschedule
+    if( current == (count-1) )                       // last thread
+    {
+        hal_remote_sw( XPTR( barrier_cxy , &barrier_ptr->current) , 0 );
+        hal_remote_sw( XPTR( barrier_cxy , &barrier_ptr->sense  ) , expected );
+        // activate waiting threads if required
+        if( xlist_is_empty( root_xp ) == false )
+        {
+            // disable interrupts
+                hal_disable_irq( &irq_state );
+            xptr_t  iter_xp;
+            xptr_t  thread_xp;
+            XLIST_FOREACH( root_xp , iter_xp )
+            {
+                // get extended pointer on waiting thread
+                thread_xp = XLIST_ELEMENT( iter_xp , thread_t , wait_list );
+                // remove waiting thread from queue
+                remote_spinlock_lock( XPTR( barrier_cxy , &barrier_ptr->lock ) );
+                xlist_unlink( XPTR( barrier_cxy , &barrier_ptr->list ) );
+                remote_spinlock_unlock( XPTR( barrier_cxy , &barrier_ptr->lock ) );
+                // unblock waiting thread
+                thread_unblock( thread_xp , THREAD_BLOCKED_USERSYNC );
+            }
+            // restore interrupts
+            hal_restore_irq( irq_state );
+        }
+    }
+    else                                             // not the last thread
+    {
+        // disable interrupts
+            hal_disable_irq( &irq_state );
+        // register calling thread in barrier waiting queue
+        xptr_t entry_xp = XPTR( thread_cxy , &thread_ptr->wait_list );
+        remote_spinlock_lock( XPTR( barrier_cxy , &barrier_ptr->lock ) );
+        xlist_add_last( root_xp , entry_xp );
+        remote_spinlock_unlock( XPTR( barrier_cxy , &barrier_ptr->lock ) );
+        // block & deschedule the calling thread
+        thread_block( thread_ptr , THREAD_BLOCKED_USERSYNC );
+        sched_yield();
+        // restore interrupts
+        hal_restore_irq( irq_state );
+    }
+}  // end remote_barrier_wait()

trunk/kernel/libk/remote_barrier.h

-                      r14
+                      r23
 /*
  * remote_barrier.h - distributed kernel barrier definition
+ * remote_barrier.h - Access a POSIX barrier.
+ *
  * Author  Alain Greiner (2016)
 …
  * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
 err* the Free Software Foundation; version 2.0 of the License.
+ * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-MKH is distributed in the hope that it will be useful, but
 …
 #include <kernel_config.h>
 #include <hal_types.h>
+#include <remote_spinlock.h>
+#include <xlist.h>
+/***************************************************************************************
+ *          This file defines a POSIX compliant barrier.
+ *
+ * It is used by multi-threaded applications to synchronise threads running in
+ * different clusters, as all access functions uses hal_remote_lw() / hal_remote_sw()
+ * portable remote access primitives.
+ *
+ * A barrier is declared by a given user process as a "pthread_barrier_t" global variable.
+ * This user type is implemented as an unsigned long, but the value is not used by the
+ * kernel. ALMOS-MKH uses only the barrier virtual address as an identifier.
+ * For each user barrier, ALMOS-MKH creates a kernel "remote_barrier_t" structure,
+ * dynamically allocated in the reference cluster by the remote_barrier_create() function,
+ * and destroyed by the remote_barrier_destroy() function, using RPC if the calling thread
+ * is not running in the reference cluster.
+ *
+ * The blocking "remote_barrier_wait()" function implements a descheduling policy when
+ * the calling thread is not the last expected thread: the calling thread is registered
+ * in a waiting queue, rooted in the barrier structure, and the the calling thread
+ * is blocked on the THREAD_BLOCKED_USERSYNC condition. The last arrived thread
+ * unblocks all registtered waiting threads.
+ *
+ * Implementation note:
+ * This barrier is also used by the kernel in the parallel kernel_init phase, as the
+ * remote_barrier() function does not require barrier initialisation, when the barrier
+ * is statically allocated by the compiler in the kdata segment.
+ * **************************************************************************************/
 /*****************************************************************************************
+ * This structure defines a distributed "rendez-vous" barrier, that can be used
+ * to synchronise several kernel threads running in different clusters
+ * It is used in the parallel kernel_init phase.
+ * It does not need to be initialised, but it must be statically allocated
+ * in the KDATA segment to be properly initialised by the compiler/loader.
+ * This structure defines the barrier descriptor.
+ * - It contains an xlist of all barriers dynamically created by a given process,
+ *   rooted in the reference process descriptor.
+ * - It contains the root of another xlist to register all arrived threads.
  ****************************************************************************************/
 typedef struct remote_barrier_s
+{
+    uint32_t   current;   // number of arrived threads
+    uint32_t   sense;     // barrier state (toggle)
+    uint32_t   pad[(CONFIG_CACHE_LINE_SIZE>>2)-2];
+    remote_spinlock_t  lock;          /*! lock protecting list of arrived threads       */
+    intptr_t           ident;         /*! virtual address in user space == identifier   */
+    uint32_t           current;       /*! number of arrived threads                     */
+    uint32_t           sense;         /*! barrier state (toggle)                        */
+    uint32_t           nb_threads;    /*! number of expected threads                    */
+    xlist_entry_t      list;          /*! member of list of barriers in same process    */
+    xlist_entry_t      root;          /*! root of list of arrived threads               */
+}
 remote_barrier_t;
 /*****************************************************************************************
  * This blocking function implements a toggle barrier. It returns only when all
  * expected threads reach the barrier. It can be used several times without
  * specific initialisation.
  * It is portable, as it uses the remote_lw() & remote_sw() access functions.
  * @ xp      : extended pointer on barrier in remote cluster
  * @ count   : number of expected thread
+ * This function is directly used by the kernel in the kernel_init phase,
+ * because it does not require barrier state initialisation.
+ * It returns only when the <count> expected threads reach the barrier.
+ *****************************************************************************************
+ * @ barrier_xp  : extended pointer on barrier descriptor.
+ * @ count       : number of expected threads.
  ****************************************************************************************/
 inline void remote_barrier( xptr_t   xp,
+inline void remote_barrier( xptr_t   barrier_xp,
                             uint32_t count );
+/*****************************************************************************************
+ * This function returns an extended pointer on the remote barrier identified
+ * by its virtual address in a given user process. It makes an associative search,
+ * scanning the list of barriers rooted in the reference process descriptor.
+ *****************************************************************************************
+ * @ ident    : barrier virtual address, used as identifier.
+ * @ returns extended pointer on barrier if success / returns XPTR_NULL if not found.
+ ****************************************************************************************/
+xptr_t remote_barrier_from_ident( intptr_t  ident );
+/*****************************************************************************************
+ * This function implement the pthread_barrier_init() syscall.
+ * It allocates memory for the barrier descriptor in the reference cluster for
+ * the calling process, it initializes the barrier state, and register it in the
+ * list of barriers owned by the reference process.
+ *****************************************************************************************
+ * @ count       : number of expected threads.
+ * @ ident       : barrier identifier (virtual address in user space).
+ * @ return 0 if success / return ENOMEM if failure.
+ ****************************************************************************************/
+error_t remote_barrier_create( intptr_t ident,
+                               uint32_t count );
+/*****************************************************************************************
+ * This function implement the pthread_barrier_destroy() syscall.
+ * It releases thr memory allocated for the barrier descriptor, and remove the barrier
+ * from the list of barriers owned by the reference process.
+ *****************************************************************************************
+ * @ barrier_xp  : extended pointer on barrier descriptor.
+ ****************************************************************************************/
+void remote_barrier_destroy( xptr_t   barrier_xp );
+/*****************************************************************************************
+ * This function implement the pthread_barrier_wait() syscall.
+ * It returns only when the number of expected threads (registered in the barrier
+ * dexcriptor) reach the barrier.
+ *****************************************************************************************
+ * @ barrier_xp   : extended pointer on barrier descriptor.
+ ****************************************************************************************/
+void remote_barrier_wait( xptr_t   barrier_xp );
 #endif  /* _REMOTE_BARRIER_H_ */

trunk/kernel/libk/remote_rwlock.c

-                      r1
+                      r23
  * remote_rwlock.c - kernel remote rwlock implementation.
+ *
+ * Authors  Mohamed Karaoui (2015)
+ *          Alain   Greiner (2016)
+ * Authors    Alain   Greiner (2016,2017)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
     // get next free ticket
     ticket = hal_remote_lw( ticket_xp );
     // loop to take the lock
+    ticket = hal_remote_atomic_add( ticket_xp , 1 );
+    // busy waiting loop to take the lock
         while( ticket != hal_remote_lw( current_xp ) )
+        {
 …
     // get next free ticket
     ticket = hal_remote_lw( ticket_xp );
+    ticket = hal_remote_atomic_add( ticket_xp , 1 );
     // loop to take the lock

trunk/kernel/libk/remote_rwlock.h

-                      r14
+                      r23
 /***************************************************************************************
  * This structure defines a remote rwdlock,that supports several simultaneous read
+ * This file defines a remote kernel lock, that supports several simultaneous read
  * accesses, but only one write access. It implements a ticket based allocation policy.
  * It can be used to synchronize threads running in different clusters, because
 …
  * When the lock is taken by another thread, the new-comers use a busy waiting policy.
+ *
+ * TODO This could be replaced by a descheduling policy and a threads waiting queue
+ * implemented in the lock itself: each thread releasing the lock (i.e. incrementing
+ * the current field) activates the first waiting thread...
+ * It uses a busy-waiting policy if the lock is already allocated to another thread.
  **************************************************************************************/

trunk/kernel/libk/remote_sem.c

-                      r15
+                      r23
 #include <hal_types.h>
+#include <hal_remote.h>
 #include <thread.h>
 #include <kmem.h>
 …
+{
     // get pointer on local process_descriptor
     process_t * process = CURRENT_PROCESS;
+    process_t * process = CURRENT_THREAD->process;
     // get extended pointer on reference process
 …
     XLIST_FOREACH( root_xp , iter_xp )
+    {
         sem_xp  = XLIST_ELEMENT( iter_xp , remote_sem_t , sem_list );
+        sem_xp  = XLIST_ELEMENT( iter_xp , remote_sem_t , list );
         sem_cxy = GET_CXY( sem_xp );
         sem_ptr = (remote_sem_t *)GET_PTR( sem_xp );
         ident   = hal_remote_lw( XPTR( sem_cxy , &sem_ptr->ident ) );
+        ident   = (intptr_t)hal_remote_lpt( XPTR( sem_cxy , &sem_ptr->ident ) );
         if( ident == vaddr )
+        {
 …
 }  // end remote_sem_from_vaddr()
 /////////////////////////////////////////
 error_t remote_sem_init( intptr_t  vaddr,
                          uint32_t  value )
+///////////////////////////////////////////
+error_t remote_sem_create( intptr_t  vaddr,
+                           uint32_t  value )
+{
     xptr_t         sem_xp;
 …
     // get pointer on local process descriptor
     process_t * process = CURRENT_PROCESS;
+    process_t * process = CURRENT_THREAD->process;
     // get extended pointer on reference process
     xptr_t      ref_xp = process->ref_xp;
+    // get reference process cluster and local pointer
     cxy_t       ref_cxy = GET_CXY( ref_xp );
     process_t * ref_ptr = (process_t *)GET_PTR( ref_xp );
 …
     else                         // reference is remote
+    {
         rpc_semaphore_alloc_client( ref_cxy , &sem_xp );
+        rpc_kcm_alloc_client( ref_cxy , KMEM_SEM , &sem_xp );
         sem_ptr = (remote_sem_t *)GET_PTR( sem_xp );
+    }
 …
     if( sem_xp == XPTR_NULL ) return ENOMEM;
+    // initialise semaphore lock
+    // initialise semaphore
+    hal_remote_sw ( XPTR( ref_cxy , &sem_ptr->count ) , value );
+        hal_remote_spt( XPTR( ref_cxy , &sem_ptr->ident ) , (void *)vaddr );
     remote_spinlock_init( XPTR( ref_cxy , &sem_ptr->lock ) );
+    // initialise semaphore count
+    hal_remote_sw( XPTR( ref_cxy , &sem_ptr->count ) , value );
+    // initialise vaddr
+        hal_remote_spt( XPTR( ref_cxy , &sem_ptr->ident ) , (void *)vaddr );
+    // initialise waiting threads queue
+        xlist_root_init( XPTR( ref_cxy , &sem_ptr->wait_queue ) );
+    // register new semaphore in reference process xlist
+        xlist_root_init( XPTR( ref_cxy , &sem_ptr->root ) );
+        xlist_entry_init( XPTR( ref_cxy , &sem_ptr->list ) );
+    // register semaphore in reference process xlist
     xptr_t root_xp = XPTR( ref_cxy , &ref_ptr->sem_root );
+    xptr_t xp_list = XPTR( ref_cxy , &sem_ptr->sem_list );
+    xptr_t xp_list = XPTR( ref_cxy , &sem_ptr->list );
+    remote_spinlock_lock( XPTR( ref_cxy , &ref_ptr->sync_lock ) );
     xlist_add_first( root_xp , xp_list );
+    remote_spinlock_unlock( XPTR( ref_cxy , &ref_ptr->sync_lock ) );
     return 0;
 …
 }  // en remote_sem_init()
+////////////////////////////////////////
+void remote_sem_destroy( xptr_t sem_xp )
+{
+    // get pointer on local process descriptor
+    process_t * process = CURRENT_THREAD->process;
+    // get extended pointer on reference process
+    xptr_t      ref_xp = process->ref_xp;
+    // get reference process cluster and local pointer
+    cxy_t       ref_cxy = GET_CXY( ref_xp );
+    process_t * ref_ptr = (process_t *)GET_PTR( ref_xp );
+    // get semaphore cluster and local pointer
+    cxy_t          sem_cxy = GET_CXY( sem_xp );
+    remote_sem_t * sem_ptr = (remote_sem_t *)GET_PTR( sem_xp );
+    // get lock protecting semaphore
+    remote_spinlock_lock( XPTR( sem_cxy , &sem_ptr->lock ) );
+    // get remote pointer on waiting queue
+    xptr_t root_xp = (xptr_t)hal_remote_lwd( XPTR( sem_cxy , &sem_ptr->root ) );
+    if( !xlist_is_empty( root_xp ) )   // user error
+    {
+        printk("WARNING in %s for thread %x in process %x : "
+               "destroy semaphore, but  waiting threads queue not empty\n",
+               __FUNCTION__ , CURRENT_THREAD->trdid , CURRENT_THREAD->process->pid );
+    }
+    // reset semaphore count
+    hal_remote_sw( XPTR( sem_cxy , &sem_ptr->count ) , 0 );
+    // remove semaphore from reference process xlist
+    remote_spinlock_lock( XPTR( ref_cxy , &ref_ptr->sync_lock ) );
+    xlist_unlink( XPTR( sem_cxy , &sem_ptr->list ) );
+    remote_spinlock_unlock( XPTR( ref_cxy , &ref_ptr->sync_lock ) );
+    // release lock
+    remote_spinlock_unlock( XPTR( sem_cxy , &sem_ptr->lock ) );
+    // release memory allocated for semaphore descriptor
+    if( sem_cxy == local_cxy )                            // reference is local
+    {
+        kmem_req_t  req;
+        req.type = KMEM_SEM;
+        req.ptr  = sem_ptr;
+        kmem_free( &req );
+    }
+    else                                                  // reference is remote
+    {
+        rpc_kcm_free_client( sem_cxy , sem_ptr , KMEM_SEM );
+    }
+}  // end remote_sem_destroy()
 //////////////////////////////////
 void remote_sem_wait( xptr_t sem_xp )
 …
         // register thread in waiting queue
         xptr_t root_xp   = (xptr_t)hal_remote_lwd( XPTR( sem_cxy , &sem_ptr->wait_queue ) );
+        xptr_t root_xp   = (xptr_t)hal_remote_lwd( XPTR( sem_cxy , &sem_ptr->root ) );
         xptr_t thread_xp = XPTR( local_cxy , this );
                 xlist_add_last( root_xp , thread_xp );
 …
     // get remote pointer on waiting queue root
     xptr_t queue_xp = (xptr_t)hal_remote_lwd( XPTR( sem_cxy , &sem_ptr->wait_queue ) );
         if( xlist_is_empty( queue_xp ) )   // no waiting thread
+    xptr_t root_xp = (xptr_t)hal_remote_lwd( XPTR( sem_cxy , &sem_ptr->root ) );
+        if( xlist_is_empty( root_xp ) )   // no waiting thread
+    {
         // get semaphore current value
 …
+    {
         // get first waiting thread from queue
         xptr_t thread_xp = XLIST_FIRST_ELEMENT( queue_xp , thread_t , wait_list );
+        xptr_t thread_xp = XLIST_FIRST_ELEMENT( root_xp , thread_t , wait_list );
         // get thread cluster and local poiner
 …
 }  // end remote_sem_post()
-////////////////////////////////////////
-void remote_sem_destroy( xptr_t sem_xp )
+{
-    // get semaphore cluster and local pointer
-    cxy_t          sem_cxy = GET_CXY( sem_xp );
-    remote_sem_t * sem_ptr = (remote_sem_t *)GET_PTR( sem_xp );
-    // get lock protecting semaphore
-    remote_spinlock_lock( XPTR( sem_cxy , &sem_ptr->lock ) );
-    // get remote pointer on waiting queue
-    xptr_t queue_xp = (xptr_t)hal_remote_lwd( XPTR( sem_cxy , &sem_ptr->wait_queue ) );
-    if( !xlist_is_empty( queue_xp ) )   // user error
+    {
-        printk("WARNING in %s for thread %x in process %x : "
-               "destroy semaphore, but  waiting threads queue not empty\n",
-               __FUNCTION__ , CURRENT_THREAD->trdid , CURRENT_PROCESS->pid );
+    }
-    // reset semaphore count
-    hal_remote_sw( XPTR( sem_cxy , &sem_ptr->count ) , 0 );
-    // remove semaphore from process
-    xptr_t xp_list = (xptr_t)hal_remote_lwd( XPTR( sem_cxy , &sem_ptr->sem_list ) );
-    xlist_unlink( xp_list );
-    // release lock
-    remote_spinlock_unlock( XPTR( sem_cxy , &sem_ptr->lock ) );
-    // release memory allocated
-    if( sem_cxy == local_cxy )         // reference is local
+    {
-        kmem_req_t  req;
-        req.type = KMEM_SEM;
-        req.ptr  = sem_ptr;
-        kmem_free( &req );
+    }
-    else                                // reference is remote
+    {
-        rpc_semaphore_free_client( sem_cxy , sem_ptr );
+    }
-}  // end remote_sem_destroy()
 //////////////////////////////////////////////

trunk/kernel/libk/remote_sem.h

-                      r15
+                      r23
 /*********************************************************************************************
  *      This file defines the the POSIX compliant unnamed semaphore.
+ *      This file defines a POSIX compliant unnamed semaphore.
+ *
  * A semaphore is declared by a given user process as a "sem_t" global variable.
 …
 /*********************************************************************************************
  * This structure defines the kernel remote_sem_t structure.
  * It contains the root of a waiting threads queue, implemented as a distributed xlist.
  * It contains an xlist of all semaphores, rooted in the reference process descriptor.
  * It contains a lock protecting both the semaphore value and the waiting queue.
+ * This structure defines the kernel semaphore descriptor.
+ * - It contains the root of a waiting threads queue, implemented as a distributed xlist.
+ * - It contains an xlist of all semaphores, rooted in the reference process descriptor.
+ * - It contains a lock protecting both the semaphore value and the waiting queue.
  ********************************************************************************************/
 …
         uint32_t          count;         /*! current value                                      */
     intptr_t          ident;         /*! virtual address in user space == identifier        */
     xlist_entry_t     wait_queue;    /*! root of waiting thread queue                       */
     xlist_entry_t     sem_list;      /*! member of list of semaphores in same process       */
+    xlist_entry_t     root;          /*! root of waiting thread queue                       */
+    xlist_entry_t     list;          /*! member of list of semaphores in same process       */
+}
 remote_sem_t;
-/*********************************************************************************************
- * This enum defines the semaphore operation types supported by the sys_sem() function.
- * It must be consistent with the values defined in the semaphore.c file (user library).
- ********************************************************************************************/
-typedef enum
+{
-        SEM_INIT,
-        SEM_GETVALUE,
-        SEM_WAIT,
-        SEM_POST,
-        SEM_DESTROY
+}
-sem_operation_t;
 /*********************************************************************************************
  * This function returns an extended pointer on the remote semaphore identified
  * by its virtual address in a given user process. It makes an associative search, scanning
  * the list of semaphores rooted in the reference process descriptor.
+ * by its virtual address in a given user process. It makes an associative search,
+ * scanning the list of semaphores rooted in the reference process descriptor.
  *********************************************************************************************
  * @ process  : pointer on local process descriptor.
 …
  * @ returns 0 if success / returns ENOMEM if error.
  ********************************************************************************************/
 error_t remote_sem_init( intptr_t  vaddr,
                          uint32_t  value );
+error_t remote_sem_create( intptr_t  vaddr,
+                           uint32_t  value );
+/****************************yy***************************************************************
+ * This function implements the SEM_DESTROY operation.
+ * It desactivates the semaphore, and releases the physical memory allocated in the
+ * reference cluster, using a RPC if required.
+ *********************************************************************************************
+ * @ sem_xp   : extended pointer on semaphore.
+ ********************************************************************************************/
+void remote_sem_destroy( xptr_t sem_xp );
 /****************************yy***************************************************************
  * This blocking function implements the SEM_WAIT operation.
 …
 /****************************yy***************************************************************
- * This function implements the SEM_DESTROY operation.
- * It desactivates the semaphore, and releases the physical memory allocated in the
- * reference cluster, using a RPC if required.
- *********************************************************************************************
- * @ sem_xp   : extended pointer on semaphore.
- ********************************************************************************************/
-void remote_sem_destroy( xptr_t sem_xp );
-/****************************yy***************************************************************
  * This function implements the SEM_GETVALUE operation.
  * It returns in the <data> buffer the semaphore current value.

trunk/kernel/libk/rwlock.c

r14	r23
86	86
87	87	// decrement number of readers
88		hal_atomic_~~dec( &lock->count~~ );
	88	hal_atomic_add( &lock->count , -1 );
89	89	this->local_locks--;
90	90

trunk/kernel/libk/string.h

-                      r1
+                      r23
 /********************************************************************************************
  * TODO
+ * this function copies the <src> buffer to the <dst> buffer, including the terminating NUL.
  ********************************************************************************************
+ * @ dst   : pointer on destination buffer.
+ * @ src   : pointer on source buffer.
  *******************************************************************************************/
 char * strcpy ( char * dest,
+char * strcpy ( char * dst,
                 char * src );
 /********************************************************************************************
  * TODO
+ * This function copies <n> characters from the <sr> buffer to the <dst> buffer.
  ********************************************************************************************
+ * @ dst   : pointer on destination buffer.
+ * @ src   : pointer on source buffer.
+ * @ n     : number of characters to be copied.
  *******************************************************************************************/
 char * strncpy ( char    * dest,
+char * strncpy ( char    * dst,
                  char    * src,
                  uint32_t  n );
 /********************************************************************************************
  * TODO
+ * This function locates the first occurence of the <c> character in the <s> string.
  ********************************************************************************************
+ * @ s     : string to be analysed.
+ * @ c     : searched character value (casted to a char)
+ * @ return pointer on the found character / return NULL if not found.
  *******************************************************************************************/
 char * strchr ( const char * s,
 …
 /********************************************************************************************
  * TODO
+ * This function locates the last occurence of the <c> character in the <s> string.
  ********************************************************************************************
+ * @ s     : string to be analysed.
+ * @ c     : searched character value (casted to a char)
+ * @ return pointer on the found character / return NULL if not found.
  *******************************************************************************************/
 char * strrchr ( const char * t,

trunk/kernel/libk/xhtab.c

-                      r14
+                      r23
  * xhtab.c - Remote access embedded hash table implementation.
+ *
  * Author     Alain Greiner          (2016)
+ * Author     Alain Greiner          (2016,2017)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
+///////////////////////////////////////////////////////////////////////////////////////
+// This static function s called by the xhtab_lookup() and xhtab_register() functions.
+// It scan one sub-list identified by  <index> to find an item  identified by <key>.
+// The hash table is identified by <cxy> and local pointer <xhtab>.
+///////////////////////////////////////////////////////////////////////////////////////////
+// Item type specific (static) functions (two functions for each item type).
+// - for type <vfs_dentry_t>, identifier is the name field.
+///////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////
+// These static functions compute the hash index from the key.
+///////////////////////////////////////////////////////////////////////////////////////////
+// @ key      : local pointer on key.
+// @ return the index value, from 0 to (HASHTAB_SIZE - 1)
+///////////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////
+uint32_t xhtab_dentry_index( void * key )
+{
+        char     * name  = key;
+        uint32_t   index = 0;
+        while( *name )
+    {
+        index = index + (*(name++) ^ index);
+    }
+        return index % HASHTAB_SIZE;
+}
+////////////////////////////////////////////////////////////////////////////////////////////
+// These static function are used by xhtab_lookup(), xhtab_insert(), xhtab_remove().
+// They scan one sub-list identified by  <index> to find an item  identified by <key>.
 // The sub-list is not modified, but the readlock must have been taken by the caller.
+///////////////////////////////////////////////////////////////////////////////////////
+// @ cxy       : hash table cluster.
+// @ xhtab_xp  : hash table local pointer.
+////////////////////////////////////////////////////////////////////////////////////////////
+// @ xhtab_xp  : extended pointer on hash table.
 // @ index     : index of sub-list to be scanned.
 // @ key       : local pointer on item identifier.
+///////////////////////////////////////////////////////////////////////////////////////
+static xptr_t xhtab_scan( cxy_t     cxy,
+                          xhtab_t * xhtab,
+                          uint32_t  index,
+                          void    * key )
+{
+    xptr_t   xlist_xp;    // extended pointer on xlist_entry_t (iterator)
+    xptr_t   item_xp;     // extended pointer on found item (return value)
+// return an extended pointer on item if found / return XPTR_NULL if not found.
+////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////
+static xptr_t xhtab_dentry_scan( xptr_t    xhtab_xp,
+                                 uint32_t  index,
+                                 void    * key )
+{
+    xptr_t    xlist_xp;                                 // xlist_entry_t (iterator)
+    xhtab_t * xhtab_ptr;                                // hash table local pointer
+    cxy_t     xhtab_cxy;                                // hash table cluster
+    char      local_name[CONFIG_VFS_MAX_NAME_LENGTH];   // local copy of dentry name
+    // get hash table cluster and local pointer
+    xhtab_cxy = GET_CXY( xhtab_xp );
+    xhtab_ptr = (xhtab_t *)GET_PTR( xhtab_xp );
+    // scan sub-list[index]
+    XLIST_FOREACH( XPTR( xhtab_cxy , &xhtab_ptr->roots[index] ) , xlist_xp )
+    {
+        // get extended pointer on dentry containing the xlist_entry_t
+            xptr_t dentry_xp = XLIST_ELEMENT( xlist_xp , vfs_dentry_t , xlist );
+        // get dentry cluster and local pointer
+        cxy_t          dentry_cxy = GET_CXY( dentry_xp );
+        vfs_dentry_t * dentry_ptr = (vfs_dentry_t *)GET_PTR( dentry_xp );
+    // scan the sub-list[index]
+        XLIST_FOREACH( XPTR( cxy , &xhtab->roots[index] ) , xlist_xp )
+        {
+        if ( xhtab->compare( xlist_xp , key , &item_xp ) ) return item_xp;
+    }
+    // no matching item found
+        return XPTR_NULL;
+        // make a local copy of dentry name
+        hal_remote_memcpy( XPTR( local_cxy  , local_name ) ,
+                           XPTR( dentry_cxy , dentry_ptr->name ),
+                           CONFIG_VFS_MAX_NAME_LENGTH  );
+        // check matching
+        if( strcmp( local_name , (char *)key ) == 0 ) return dentry_xp;
+    }
+    // No matching item found
+    return XPTR_NULL;
+}
+/////////////////////////////////
+void xhtab_init( xhtab_t * xhtab,
+                 uint32_t  type )
+////////////////////////////////////////////////////////////////////////////////////////
+//         Generic access functions
+////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////
+void xhtab_init( xhtab_t          * xhtab,
+                 xhtab_item_type_t  type )
+{
         uint32_t i;
 …
     if( type == XHTAB_DENTRY_TYPE )
+    {
         hal_remote_spt( XPTR( local_cxy , &xhtab->compare ) , &xhtab_dentry_compare );
         hal_remote_spt( XPTR( local_cxy , &xhtab->index   ) , &xhtab_dentry_index   );
+        xhtab->scan  = &xhtab_dentry_scan;
+        xhtab->index = &xhtab_dentry_index;
+    }
     else
 …
 ///////////////////////////////////////
+void xhtab_register( xptr_t   xhtab_xp,
+                     void   * key,
+                     xptr_t   xlist_xp )
+{
+error_t xhtab_insert( xptr_t   xhtab_xp,
+                      void   * key,
+                      xptr_t   xlist_xp )
+{
+printk("\n                @@@ xhtab_insert : 0 / name = %s / xhtab_xp = %l / xlist_xp = %l\n",
+       key , xhtab_xp , xlist_xp );
     // get xhtab cluster and local pointer
     cxy_t     xhtab_cxy = GET_CXY( xhtab_xp );
 …
         uint32_t index = xhtab_ptr->index( key );
+printk("\n                @@@ xhtab_insert : 1 / name = %s / index = %d\n",
+       key , index );
     // take the lock protecting hash table
     remote_rwlock_wr_lock( XPTR( xhtab_cxy , &xhtab_ptr->lock ) );
+    // register item in hash table
+        xlist_add_last( XPTR( xhtab_cxy , &xhtab_ptr->roots[index] ) , xlist_xp );
+    // update number of registered items
+    hal_remote_atomic_add( XPTR( xhtab_cxy , &xhtab_ptr->items ) , 1 );
+    // release the lock protecting hash table
+    remote_rwlock_wr_unlock( XPTR( xhtab_cxy , &xhtab_ptr->lock ) );
+}  // end xhtab_register()
+    // search a matching item
+    xptr_t item_xp = xhtab_ptr->scan( xhtab_xp , index , key );
+    if( item_xp != XPTR_NULL )    // error if found
+    {
+        // release the lock protecting hash table
+        remote_rwlock_wr_unlock( XPTR( xhtab_cxy , &xhtab_ptr->lock ) );
+printk("\n                @@@ xhtab_insert : 2 / name = %s / item_xp = %l\n",
+       key , item_xp );
+        return EINVAL;
+    }
+    else                          // insert item if not found
+    {
+        // register item in hash table
+            xlist_add_last( XPTR( xhtab_cxy , &xhtab_ptr->roots[index] ) , xlist_xp );
+        // update number of registered items
+        hal_remote_atomic_add( XPTR( xhtab_cxy , &xhtab_ptr->items ) , 1 );
+        // release the lock protecting hash table
+        remote_rwlock_wr_unlock( XPTR( xhtab_cxy , &xhtab_ptr->lock ) );
+printk("\n                @@@ xhtab_insert : 3 / name = %s / item_xp = %l\n",
+       key , xhtab_ptr->scan( xhtab_xp , index , key ) );
+        return 0;
+    }
+}  // end xhtab_insert()
 /////////////////////////////////////
+void xhtab_remove( xptr_t   xhtab_xp,
+                   void   * key )
+error_t xhtab_remove( xptr_t   xhtab_xp,
+                      void   * key,
+                      xptr_t   xlist_entry_xp )
+{
     // get xhtab cluster and local pointer
 …
     xhtab_t * xhtab_ptr = (xhtab_t *)GET_PTR( xhtab_xp );
+    // compute index from key
+        uint32_t index = xhtab_ptr->index( key );
     // take the lock protecting hash table
     remote_rwlock_wr_lock( XPTR( xhtab_cxy , &xhtab_ptr->lock ) );
-    // compute index from key
-        uint32_t index = xhtab_ptr->index( key );
     // get extended pointer on item to remove
+    xptr_t item_xp = xhtab_scan( xhtab_cxy , xhtab_ptr , index , key );
+    if( item_xp == XPTR_NULL )    // do nothing if not found
+    {
+        // release the lock protecting hash table
+        remote_rwlock_wr_unlock( XPTR( xhtab_cxy , &xhtab_ptr->lock ) );
+    xptr_t item_xp = xhtab_ptr->scan( xhtab_xp , index , key );
+    if( item_xp == XPTR_NULL )    // error if not found
+    {
+        // release the lock protecting hash table
+        remote_rwlock_wr_unlock( XPTR( xhtab_cxy , &xhtab_ptr->lock ) );
+        return EINVAL;
+    }
     else                          // remove item if found
+    {
-        // get item cluster and local pointer
-        cxy_t          item_cxy = GET_CXY( item_xp );
-        vfs_dentry_t * item_ptr = (vfs_dentry_t *)GET_PTR( item_xp );
         // remove item from hash table <=> unlink xlist_entry_t
         xlist_unlink( XPTR( item_cxy , &item_ptr->xlist ) );
+        xlist_unlink( xlist_entry_xp );
         // update number of registered items
 …
         // release the lock protecting hash table
         remote_rwlock_wr_unlock( XPTR( xhtab_cxy , &xhtab_ptr->lock ) );
+    }
+}  // end xhtab_unregister()
+        return 0;
+    }
+}  // end xhtab_remove()
 /////////////////////////////////////////
 …
     // scan sub-list
     item_xp = xhtab_scan( xhtab_cxy , xhtab_ptr , index , key );
+    item_xp = xhtab_ptr->scan( xhtab_xp , index , key );
     // release the lock protecting hash table
 …
-/////////////////////////////////////////
-uint32_t xhtab_dentry_index( void * key )
+{
-        char    * str   = key;
-        uint32_t  index = 0;
-        while( *str ) index = index + (*(str++) ^ index);
-        return index % HASHTAB_SIZE;
+}
-///////////////////////////////////////////////
-bool_t xhtab_dentry_compare( xptr_t   xlist_xp,
-                             void   * key,
-                             xptr_t * item_xp )
+{
-    char   tested_name[256];      // local copy of name stored in remote hash table
-    char * searched_name = key;   // local pointer on searched name
-    // compute name length
-    uint32_t length = strlen( searched_name );
-    // get extended pointer on dentry containing the xlist_entry_t
-        xptr_t dentry_xp = XLIST_ELEMENT( xlist_xp , vfs_dentry_t , xlist );
-    // get dentry cluster and local pointer
-    cxy_t          dentry_cxy = GET_CXY( dentry_xp );
-    vfs_dentry_t * dentry_ptr = (vfs_dentry_t *)GET_PTR( dentry_xp );
-    // make a local copy of remote dentry name
-    hal_remote_memcpy( XPTR( local_cxy  , tested_name ) ,
-                       XPTR( dentry_cxy , dentry_ptr->name ) , length );
-    // check matching / return if match
-    if( strcmp( tested_name , searched_name ) == 0 )
+    {
-        return true;
-        *item_xp = dentry_xp;
+    }
-    else
+    {
-        return false;
+    }
+}
-////////////////////////////////////////
-uint32_t xhtab_inode_index( void * key )
+{
-        uint32_t * inum = key;
-        return (((*inum) >> 16) ^ ((*inum) & 0xFFFF)) % HASHTAB_SIZE;
+}
-///////////////////////////////////////////////
-bool_t xhtab_inode_compare( xptr_t   xlist_xp,
-                            void   * key,
-                            xptr_t * item_xp )
+{
-    uint32_t * searched_inum = key;
-    uint32_t   tested_inum;
-    // get extended pointer on inode containing the xlist_entry_t
-        xptr_t inode_xp = XLIST_ELEMENT( xlist_xp , vfs_inode_t , xlist );
-    // get inode cluster and local pointer
-    cxy_t         inode_cxy = GET_CXY( inode_xp );
-    vfs_inode_t * inode_ptr = (vfs_inode_t *)GET_PTR( inode_xp );
-    // get tested inode inum
-    tested_inum = hal_remote_lw( XPTR( inode_cxy , &inode_ptr->inum ) );
-    // check matching / return if match
-    if( tested_inum == *searched_inum )
+    {
-        return true;
-        *item_xp = inode_xp;
+    }
-    else
+    {
-        return false;
+    }
+}

trunk/kernel/libk/xhtab.h

-                      r14
+                      r23
  * xhtab.h - Remote access embedded hash table definition.
+ *
  * Author     Alain Greiner          (2016)
+ * Author     Alain Greiner  (2016,2017)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
+/******************************************************************************************
+ * This file define a generic, embedded, hash table that can be remotely accessed by
+ * any thread running in any cluster.
+ * The main goal is to speedup search by key in a set of items identified by their key.
+ * For this purpose the set of all registered items is split in several subsets:
+ * Each subset is organised an embedded double linked lists.
+ * - an item is uniquely identified by a <key>, that can be a single uint32_t,
+ *   a name (character string), or a more complex structure.
+ * - From the <key>, the hash table uses an item type specific "xhtab_index()" function,
+ *   to compute an <index> value, defining a subset of registered items.
+ * - to discriminate between items that have the same <index>, the hash table uses another
+ *   item type specific "xhtab_compare()" function for the associative search in subset.
+ * - Each registered item is a structure, that must contain an embedded xlist_entry,
+ *   that is part of the xlist implementing the subset.
+ * - The xhtab header contains an array indexed by <index> and containing the roots
+ *   of the various xlists implementing the subsets.
+ *   pointer on the searched item can be obtained by a simple offset.
+ * Implementation note:
+ * to use this generic infrastructure for a new type of item, you must define a new
+ * type in the xhtan_item_type_t" below, and to define the two  associated
+ * "xhtab_compare() and xhtab_index().
+ *****************************************************************************************/
+///////////////////////////////////////////////////////////////////////////////////////////
+// This file define a generic, embedded, remotely accessible hash table.
+//
+// It can be accessed by any thread, running in any cluster.
+// It is generic as it can be used to register various types of items.
+// The main goal is to speedup search by key for a large number of items of same type.
+// For this purpose the set of all registered items is split in several subsets.
+// Each subset is organised an embedded double linked lists.
+// - an item is uniquely identified by a <key>, that can be a single uint32_t,
+//   a name (character string), or a more complex structure.
+// - From the pointer on <key>, we use an item type specific xhtab_index() function,
+//   to compute an <index> value, defining a subset of registered items.
+// - to discriminate between items that have the same <index>, the hash table uses another
+//   item type specific "xhtab_scan()" function for the associative search in subset.
+// - Each registered item is a structure, that must contain an embedded xlist_entry,
+//   that is part of the xlist implementing the subset.
+//
+// Implementation Note: for each supported item type ***, you must define the two
+//                      xhtab_***_index() and xhtab_***_scan() functions, and
+//                      update the xhtab_init() function.
+///////////////////////////////////////////////////////////////////////////////////////////
 #define HASHTAB_SIZE    64   // number of subsets
 /******************************************************************************************
+ * These typedef define the generic xhtab_compare() and xhtab_index() function prototypes.
+ * It must exist a specific couple of functions for each item type.
+ * @ entry_xp : extended pointer on an xlist_entry_t in a partial xlist.
+ * @ key      : local pointer on the searched item key.
+ * @ item_xp  : buffer to store extended pointer on found item.
+ * These typedef define the two item type specific function prototypes.
  *****************************************************************************************/
+typedef  bool_t    xhtab_compare_t( xptr_t entry_xp , void * key , xptr_t * item_xp );
+typedef  xptr_t    xhtab_scan_t( xptr_t xhtab_xp , uint32_t index , void * key );
 typedef  uint32_t  xhtab_index_t( void * key );
 …
 typedef enum
+{
+    XHTAB_DENTRY_TYPE = 1,                   /*! item is a vfs_dentry_t                  */
+    XHTAB_INODE_TYPE  = 2,                   /*! item is a vfs_inode_t                   */
+    XHTAB_DENTRY_TYPE = 0,                    /*! item is a vfs_dentry_t                 */
+}
 xhtab_item_type_t;
 /******************************************************************************************
  * This structure define the root of a generic, remote accessible, hash table.
+ * This structure define the root of the remote accessible hash table.
  *****************************************************************************************/
 …
+{
         xlist_entry_t      roots[HASHTAB_SIZE];   /*! array of roots of xlist                */
     xhtab_compare_t  * compare;               /*! item specific index function           */
     xhtab_index_t    * index;                 /*! item specific compare function         */
+    xhtab_index_t    * index;                 /*! item specific function                 */
+    xhtab_scan_t     * scan;                  /*! item specific function                 */
     uint32_t           items;                 /*! number of registered items             */
     remote_rwlock_t  lock;                  /*! lock protecting hash table modifs      */
+    remote_rwlock_t    lock;                  /*! lock protecting hash table accesses    */
+}
 xhtab_t;
 /******************************************************************************************
  * This function initializes an empty hash table (zero children).
+ * This function initializes an empty hash table (zero registered item).
  * The initialisation must be done by a thread running in cluster containing the table.
  ******************************************************************************************
 …
  * @ type    : item type (see above).
  *****************************************************************************************/
 void xhtab_init( xhtab_t * xhtab,
                  uint32_t  type );
+void xhtab_init( xhtab_t           * xhtab,
+                 xhtab_item_type_t   type );
 /******************************************************************************************
 …
  * @ key        : local pointer on item identifier.
  * @ xlist_xp   : extended pointer on xlist_entry_t embedded in item to be registered.
+ * @ return 0 if success / return EINVAL if item already registered.
  *****************************************************************************************/
 void xhtab_register( xptr_t   xhtab_xp,
                      void   * key,
                      xptr_t   xlist_xp );
+error_t xhtab_insert( xptr_t   xhtab_xp,
+                      void   * key,
+                      xptr_t   xlist_xp );
 /******************************************************************************************
  * This function safely remove an item from the hash table, using the lock protecting it.
  ******************************************************************************************
+ * @ xhtab_xp : extended pointer on hash table.
+ * @ key      : local pointer on item identifier.
+ * @ xhtab_xp       : extended pointer on hash table.
+ * @ key            : local pointer on item identifier.
+ * @ xlist_entry_xp : extended pointer on xlist_entry embedded in item to be removed.
+ * @ return 0 if success / return EINVAL if item not found.
  *****************************************************************************************/
+void xhtab_remove( xptr_t   xhtab_xp,
+                   void   * key );
+error_t xhtab_remove( xptr_t   xhtab_xp,
+                      void   * key,
+                      xptr_t   xlist_entry_xp );
 /******************************************************************************************
 …
-/************************  vfs_dentry_t specific functions  ******************************/
-/******************************************************************************************
- * This function compute the hash index from the key, when the item is a vhs_dentry_t.
- ******************************************************************************************
- * @ key      : local pointer on dentry name.
- * @ return the index value, from 0 to (HASHTAB_SIZE - 1)
- *****************************************************************************************/
-uint32_t xhtab_dentry_index( void * key );
-/******************************************************************************************
- * This function check the key value for a given item, when the item is a vhs_dentry_t.
- ******************************************************************************************
- * @ xlist_xp : extended pointer on xlist_entry_t contained in a vfs_dentry_t.
- * @ key      : local pointer on searched dentry name.
- * @ return true if the item name matches the searched name.
- *****************************************************************************************/
-bool_t xhtab_dentry_compare( xptr_t   xlist_xp,
-                             void   * key,
-                             xptr_t * item_xp );
-/************************  vfs_inode_t specific functions  *******************************/
-/******************************************************************************************
- * This function compute the hash index from the key, when the item is a vhs_inode_t.
- ******************************************************************************************
- * @ key      : local pointer on dentry name.
- * @ return the index value, from 0 to (HASHTAB_SIZE - 1)
- *****************************************************************************************/
-uint32_t xhtab_inode_index( void * key );
-/******************************************************************************************
- * This function check the key value for a given item, when the item is a vhs_inode_t.
- ******************************************************************************************
- * @ xlist_xp : extended pointer on xlist_entry_t contained in a vfs_dentry_t.
- * @ key      : local pointer on searched dentry name.
- * @ return true if the item name matches the searched name.
- *****************************************************************************************/
-bool_t xhtab_inode_compare( xptr_t   xlist_xp,
-                            void   * key,
-                            xptr_t * item_xp );
 #endif  /* _XHTAB_H_ */

trunk/kernel/mm/kcm.h

r18	r23
70	70	typedef struct kcm_page_s
71	71	{
72		~~BITMAP ( bitmap , CONFIG_KCM_BLOCKS_MAX )~~;
	72	uint32_t bitmap[BITMAP_SIZE(CONFIG_KCM_BLOCKS_MAX)];
73	73	uint8_t * base; /! pointer on first block in page /
74	74	kcm_t * kcm; /! owner KCM allocator /

trunk/kernel/mm/kmem.c

-                      r18
+                      r23
 #include <remote_sem.h>
 #include <remote_barrier.h>
+#include <remote_mutex.h>
+#include <remote_condvar.h>
 #include <mapper.h>
 #include <grdxt.h>
 …
     else if( type == KMEM_CPU_CTX )       return sizeof( hal_cpu_context_t );
     else if( type == KMEM_FPU_CTX )       return sizeof( hal_fpu_context_t );
+    else if( type == KMEM_BARRIER )       return sizeof( remote_barrier_t );
     else if( type == KMEM_FATFS_INODE )   return sizeof( fatfs_inode_t );
     else if( type == KMEM_FATFS_CTX )     return sizeof( fatfs_ctx_t );
     else if( type == KMEM_RAMFS_INODE )   return sizeof( ramfs_inode_t );
     else if( type == KMEM_RAMFS_CTX )     return sizeof( ramfs_ctx_t );
+    else if( type == KMEM_DEVFS_INODE )   return sizeof( devfs_inode_t );
+    else if( type == KMEM_MUTEX )         return sizeof( remote_mutex_t );
     else if( type == KMEM_VFS_CTX )       return sizeof( vfs_ctx_t );
     else if( type == KMEM_VFS_INODE )     return sizeof( vfs_inode_t );
 …
     else if( type == KMEM_VFS_FILE )      return sizeof( vfs_file_t );
     else if( type == KMEM_SEM )           return sizeof( remote_sem_t );
+    else if( type == KMEM_CONDVAR )       return sizeof( remote_condvar_t );
     else                                  return 0;
+}
 …
     else if( type == KMEM_CPU_CTX )       return "KMEM_CPU_CTX";
     else if( type == KMEM_FPU_CTX )       return "KMEM_FPU_CTX";
+    else if( type == KMEM_BARRIER )       return "KMEM_BARRIER";
     else if( type == KMEM_FATFS_INODE )   return "KMEM_FATFS_INODE";
     else if( type == KMEM_FATFS_CTX )     return "KMEM_FATFS_CTX";
     else if( type == KMEM_RAMFS_INODE )   return "KMEM_RAMFS_INODE";
     else if( type == KMEM_RAMFS_CTX )     return "KMEM_RAMFS_CTX";
+    else if( type == KMEM_DEVFS_INODE )   return "KMEM_DEVFS_INODE";
+    else if( type == KMEM_MUTEX )         return "KMEM_MUTEX";
     else if( type == KMEM_VFS_CTX )       return "KMEM_VFS_CTX";
     else if( type == KMEM_VFS_INODE )     return "KMEM_VFS_INODE";
 …
     else if( type == KMEM_VFS_FILE )      return "KMEM_VFS_FILE";
     else if( type == KMEM_SEM )           return "KMEM_SEM";
+    else if( type == KMEM_SEM )           return "KMEM_CONDVAR";
     else                                  return "undefined";
+}

trunk/kernel/mm/kmem.h

-                      r18
+                      r23
 /*************************************************************************************
+ * This enum defines the Kernel Memory Types for dynamically allocated objectsn.
+ * This enum defines the Kernel Memory Types for dynamically allocated objects.
+ * WARNING : this enum must be kepts consistent with use in kmem.c file.
  ************************************************************************************/
 …
   KMEM_CPU_CTX          = 7,   /*! hal_cpu_context_t                                */
   KMEM_FPU_CTX          = 8,   /*! hal_fpu_context_t                                */
   KMEM_TBD_9            = 9,
+  KMEM_BARRIER          = 9,   /*! remote_barrier_t                                 */
   KMEM_FATFS_INODE      = 10,  /*! fatfs_inode_t                                    */
   KMEM_FATFS_CTX        = 11,  /*! fatfs_ctx_t                                      */
   KMEM_RAMFS_INODE      = 12,  /*  ramfs_inode_t                                    */
   KMEM_RAMFS_CTX        = 13,  /*! ramfs_ctx_t                                      */
+  KMEM_DEVFS_INODE      = 12,  /*  devfs_inode_t                                    */
+  KMEM_MUTEX            = 13,  /*! remote_mutex_t                                   */
   KMEM_VFS_CTX          = 14,  /*! vfs_context_t                                    */
   KMEM_VFS_INODE        = 15,  /*! vfs_inode_t                                      */
 …
   KMEM_VFS_FILE         = 17,  /*! vfs_file_t                                       */
   KMEM_SEM              = 18,  /*! remote_sem_t                                     */
   KMEM_TBD_19           = 19,
+  KMEM_CONDVAR          = 19,  /*! remote_condvar_t                                 */
   KMEM_TYPES_NR         = 20,
+  KMEM_TYPES_NR         = 19,
 };

trunk/kernel/mm/mapper.c

-                      r18
+                      r23
 #include <hal_types.h>
 #include <hal_special.h>
+#include <hal_uspace.h>
 #include <grdxt.h>
 #include <rwlock.h>
 …
+        {
             // remove page from mapper and release to PPM
                 error = mapper_release_page( mapper , found_index , page );
+                error = mapper_release_page( mapper , page );
             if ( error ) return error;
 …
     // test if page available in mapper
     if( ( page == NULL) || page_is_flag( page , PG_INLOAD ) )  // page not available            /
+    if( ( page == NULL) || page_is_flag( page , PG_INLOAD ) )  // page not available
+    {
         // release the lock in READ_MODE and take it in WRITE_MODE
 …
                 printk("\n[ERROR] in %s : thread %x cannot insert page in mapper\n",
                        __FUNCTION__ , this->trdid );
                 mapper_release_page( mapper , index , page );
+                mapper_release_page( mapper , page );
                 page_clear_flag( page , PG_ALL );
                 req.ptr  = page;
 …
             // launch I/O operation to load page from file system
             error = mapper_updt_page( mapper , index , page );
+            error = vfs_move_page_to_mapper( page );
             if( error )
 …
                 printk("\n[ERROR] in %s : thread %x cannot load page from device\n",
                        __FUNCTION__ , this->trdid );
                 mapper_release_page( mapper , index , page );
+                mapper_release_page( mapper , page );
                 page_clear_flag( page , PG_ALL );
                 req.ptr  = page;
 …
 ///////////////////////////////////////////////
 error_t mapper_release_page( mapper_t * mapper,
-                             uint32_t   index,
                              page_t   * page )
+{
 …
     // lauch IO operation to update page to file system
     error = mapper_sync_page( mapper , index , page );
+    error = vfs_move_page_from_mapper( page );
     if( error )
 …
 }  // end mapper_release_page()
+////////////////////////////////////////////
+error_t mapper_updt_page( mapper_t * mapper,
+                          uint32_t   index,
+                          page_t   * page )
+{
+    uint32_t      type;
+    vfs_inode_t * inode;
+    error_t       error = 0;
+    if( page == NULL )
+    {
+        printk("\n[PANIC] in %s : page pointer is NULL\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
+    if( mapper == NULL )
+    {
+        printk("\n[PANIC] in %s : no mapper for this page\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
+    // get file system type and inode pointer
+    inode = mapper->inode;
+    type  = inode->ctx->type;
+    // get page lock
+    page_lock( page );
+    // get mapper lock in WRITE_MODE
+    rwlock_wr_lock( &mapper->lock );
+    // call proper I/O operation to update file system
+    if     ( type == FS_TYPE_FATFS ) error = fatfs_read_page( page );
+    else if( type == FS_TYPE_RAMFS ) error = ramfs_read_page( page );
+    else
+    {
+        printk("\n[PANIC] in %s : undefined file system type\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
+    // release mapper lock from WRITE_MODE
+    rwlock_wr_unlock( &mapper->lock );
+    // release page lock
+    page_unlock( page );
+    if( error )
+    {
+        printk("\n[PANIC] in %s : cannot access file system\n", __FUNCTION__ );
+        return EIO;
+    }
+    return 0;
+}  // end mapper_updt_page
+////////////////////////////////////////////
+error_t mapper_sync_page( mapper_t * mapper,
+                          uint32_t   index,
+                          page_t   * page )
+{
+    uint32_t      type;
+    vfs_inode_t * inode;
+    error_t       error = 0;
+    if( page == NULL )
+    {
+        printk("\n[PANIC] in %s : page pointer is NULL\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
+    if( mapper == NULL )
+    {
+        printk("\n[PANIC] in %s : no mapper for this page\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
+        if( page_is_flag( page , PG_DIRTY ) )
+        {
+        // get file system type and inode pointer
+        inode = mapper->inode;
+        type  = inode->ctx->type;
+        // get page lock
+        page_lock( page );
+        // get mapper lock in READ_MODE
+        rwlock_rd_lock( &mapper->lock );
+        // call proper I/O operation to update file system
+        if     ( type == FS_TYPE_FATFS ) error = fatfs_write_page( page );
+        else if( type == FS_TYPE_RAMFS ) error = ramfs_write_page( page );
+        else
+        {
+            printk("\n[PANIC] in %s : undefined file system type\n", __FUNCTION__ );
+            hal_core_sleep();
+        }
+        // release mapper lock from READ_MODE
+        rwlock_rd_unlock( &mapper->lock );
+        // release page lock
+        page_unlock( page );
+        if( error )
+        {
+            printk("\n[PANIC] in %s : cannot update file system\n", __FUNCTION__ );
+            return EIO;
+        }
+        // clear dirty bit
+                page_undo_dirty( page );
+     }
+    return 0;
+}  // end mapper_sync_page()
+///////////////////////////////////////////////////////////////////////////////////////
+// This static function is called by the mapper_move fragments() function.
+// It moves one fragment between an user buffer and the kernel mapper.
+// Implementation Note: It can require access to one or two pages in mapper:
+//  [max_page_index == min_page_index]     <=>  fragment fit in one mapper page
+//  [max_page index == min_page_index + 1] <=>  fragment spread on two mapper pages
+///////////////////////////////////////////////////////////////////////////////////////
+static error_t mapper_move_one_fragment( mapper_t   * mapper,
+                                         bool_t       to_buffer,
+                                         fragment_t * fragment )
+{
+    uint32_t   size;                 // number of bytes in fragment
+    cxy_t      buf_cxy;              // cluster identifier for user buffer
+    uint8_t  * buf_ptr;              // local pointer on first byte in user buffer
+    xptr_t     xp_buf;               // extended pointer on byte in user buffer
+    xptr_t     xp_map;               // extended pointer on byte in kernel mapper
+    uint32_t   min_file_offset;      // offset of first byte in file
+    uint32_t   max_file_offset;      // offset of last byte in file
+    uint32_t   first_page_index;     // index of first page in mapper
+    uint32_t   first_page_offset;    // offset of first byte in first page in mapper
+    uint32_t   first_page_size;      // offset of first byte in first page in mapper
+    uint32_t   second_page_index;    // index of last page in mapper
+    uint32_t   second_page_offset;   // offset of last byte in last page in mapper
+    uint32_t   second_page_size;     // offset of last byte in last page in mapper
+    page_t   * page;                 // pointer on one page descriptor in mapper
+    uint8_t  * map_ptr;              // local pointer on first byte in mapper
+    // get fragment attributes in user buffer
+    buf_cxy = fragment->buf_cxy;
+    buf_ptr = fragment->buf_ptr;
+    size    = fragment->size;
+    if( size > CONFIG_PPM_PAGE_SIZE )
+    {
+        printk("\n[PANIC] in %s : illegal fragment size = %d\n",
+               __FUNCTION__ , size );
+        return EINVAL;
+    }
+/////////////////////////////////////////
+error_t mapper_move( mapper_t  *  mapper,
+                     bool_t       to_buffer,
+                     uint32_t     file_offset,
+                     void      *  buffer,
+                     uint32_t     size )
+{
+    uint32_t   page_offset;    // first byte to move to/from a mapper page
+    uint32_t   page_count;     // number of bytes to move to/from a mapper page
+    uint32_t   index;          // current mapper page index
+    uint32_t   done;           // number of moved bytes
+    page_t   * page;           // current mapper page descriptor
+    uint8_t  * map_ptr;        // current mapper  address
+    uint8_t  * buf_ptr;        // current buffer  address
     // compute offsets of first and last bytes in file
     min_file_offset = fragment->file_offset;
     max_file_offset = min_file_offset + size;
+    uint32_t min_byte = file_offset;
+    uint32_t max_byte = file_offset + size -1;
     // compute indexes of pages for first and last byte in mapper
+    first_page_index  = min_file_offset >> CONFIG_PPM_PAGE_SHIFT;
+    second_page_index = max_file_offset >> CONFIG_PPM_PAGE_SHIFT;
+    if ( first_page_index == second_page_index )  // only one page in mapper
+    {
+        // compute offset and size for page in mapper
+        first_page_offset = min_file_offset & (1<<CONFIG_PPM_PAGE_SHIFT);
+        first_page_size   = size;
+        // get pointer on first page in mapper
+        page = mapper_get_page( mapper , first_page_index );
+    uint32_t first = min_byte >> CONFIG_PPM_PAGE_SHIFT;
+    uint32_t last  = max_byte >> CONFIG_PPM_PAGE_SHIFT;
+    done = 0;
+    // loop on pages in mapper
+    for( index = first ; index <= last ; index++ )
+    {
+        // compute page_offset
+        if( index == first ) page_offset = min_byte & CONFIG_PPM_PAGE_MASK;
+        else                 page_offset = 0;
+        // compute page_count
+        if      ( first == last  ) page_count = size;
+        else if ( index == first ) page_count = CONFIG_PPM_PAGE_SIZE - page_offset;
+        else if ( index == last  ) page_count = (max_byte & CONFIG_PPM_PAGE_MASK) + 1;
+        else                       page_count = CONFIG_PPM_PAGE_SIZE;
+        // get page descriptor
+        page = mapper_get_page( mapper , index );
         if ( page == NULL ) return EINVAL;
+        // compute pointer on fragment first byte in mapper
+        map_ptr = (uint8_t *)ppm_page2base( page ) + first_page_offset;
+        // compute extended pointers in mapper and in buffer
+        xp_map = XPTR( local_cxy , map_ptr );
+        xp_buf = XPTR( buf_cxy , buf_ptr );
+        // compute pointer in mapper
+        map_ptr = (uint8_t *)ppm_page2base( page ) + page_offset;
+        // compute pointer in buffer
+        buf_ptr = (uint8_t *)buffer + done;
         // move fragment
         if( to_buffer )
+        {
             hal_remote_memcpy( xp_buf , xp_map , first_page_size );
+            hal_copy_to_uspace( buf_ptr , map_ptr , page_count );
+        }
         else
+        {
             page_do_dirty( page );
+            hal_remote_memcpy( xp_map , xp_buf , first_page_size );
+        }
+    }
+    else                                        // two pages in mapper
+    {
+        // compute offset and size for first page in mapper
+        first_page_offset = min_file_offset & (1<<CONFIG_PPM_PAGE_SHIFT);
+        first_page_size   = CONFIG_PPM_PAGE_SIZE - first_page_offset;
+        // get pointer on first page descriptor in mapper
+        page = mapper_get_page( mapper , first_page_index );
+        if ( page == NULL ) return EINVAL;
+        // compute local pointer on first byte in first page in mapper
+        map_ptr = (uint8_t *)ppm_page2base(page) + first_page_offset;
+        // compute extended pointers
+        xp_map = XPTR( local_cxy , map_ptr );
+        xp_buf = XPTR( buf_cxy , buf_ptr );
+        // move fragment to/from first page
+        if( to_buffer )
+        {
+            hal_remote_memcpy( xp_buf , xp_map , first_page_size );
+        }
+        else
+        {
+            page_do_dirty( page );
+            hal_remote_memcpy( xp_map , xp_buf , first_page_size );
+        }
+        // compute offset and size for second page in mapper
+        second_page_offset = 0;
+        second_page_size   = size - first_page_size;
+        // get pointer on second page in mapper
+        page = mapper_get_page( mapper , second_page_index );
+        if ( page == NULL ) return EINVAL;
+        // compute local pointer on first byte in second page in mapper
+        map_ptr = (uint8_t *)ppm_page2base( page ) + second_page_offset;
+        // compute extended pointers
+        xp_map = XPTR( local_cxy , map_ptr );
+        xp_buf = XPTR( buf_cxy , buf_ptr + first_page_offset );
+        // move fragment to/from second page
+        if( to_buffer )
+        {
+            hal_remote_memcpy( xp_buf , xp_map , second_page_size );
+        }
+        else
+        {
+            page_do_dirty( page );
+            hal_remote_memcpy( xp_map , xp_buf , second_page_size );
+        }
+            hal_copy_from_uspace( map_ptr , buf_ptr , page_count );
+        }
+        done += page_count;
+    }
     return 0;
+}  // end mapper_move_one_fragment()
+/////////////////////////////////////////////////
+error_t mapper_move_fragments( mapper_t * mapper,
+                               bool_t     read,
+                               uint32_t   nb_frags,
+                               xptr_t     xp_frags )
+{
+        uint32_t     index;
+        error_t      error;
+    fragment_t   local_frags[CONFIG_MAPPER_MAX_FRAGMENTS];   // local copy of fragments array
+    fragment_t * frags_array;                                // pointer on fragments array
+    // check nb_frags
+    if( nb_frags > CONFIG_MAPPER_MAX_FRAGMENTS )
+    {
+        printk("\n[PANIC] in %s : number of fragments cannot be larger than %d\n",
+               __FUNCTION__ , CONFIG_MAPPER_MAX_FRAGMENTS );
+        return EINVAL;
+    }
+    // get client cluster and local pointer on fragments array
+    cxy_t        client_cxy   = GET_CXY( xp_frags );
+    fragment_t * client_frags = (fragment_t *)GET_PTR( xp_frags );
+    if ( local_cxy == client_cxy ) // use the local fragments array if possible
+    {
+        frags_array = client_frags;
+    }
+    else                           // make a local copy of fragments array
+    {
+        hal_remote_memcpy( XPTR( local_cxy , local_frags ) , xp_frags ,
+                           sizeof(fragment_t) * nb_frags );
+        frags_array = local_frags;
+    }
+    // loop on fragments
+    for( index = 0 ; index < nb_frags ; index ++ )
+    {
+        error = mapper_move_one_fragment( mapper , read , &frags_array[index] );
+        if ( error ) return error;
+    }
+    return 0;
+}  // end mapper_move_fragments()
+}  // end mapper_move()

trunk/kernel/mm/mapper.h

-                      r18
+                      r23
 /*******************************************************************************************
  * The mapper implements the kernel cache for a given file or directory.
  * There is one mapper per file. It is implemented as a three levels radix tree,
+ * 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.
  * - The fast retrieval key is the page index in the file.
 …
  * - The mapper is protected by a blocking "rwlock", to support several simultaneous
  *   readers, and only one writer. This lock implement a busy waiting policy.
  * - The two functions mapper_sync_page() and mapper_updt_page() define the generic API
  *   used to move pages to or from the relevant file system on IOC device.
  * - the mapper_move fragments() function is used to move data to or from a distributed
  *   user buffer.
+ * - The two functions vfs_move_page_to_mapper() and vfs_move_page_from_mapper() define
+ *   the generic API used to move pages to or from the relevant file system on IOC device.
+ * - the mapper_move() function is used to move data to or from a, possibly distributed
+ *   user buffer in user space.
  * - The mapper_get_page() function that return a page descriptor pointer from a page
  *   index in file is in charge of handling the miss on the mapper cache.
  * - In the present implementation the cache size increases on demand, and the
  *   allocated memory is only released when the mapper is destroyed.
+ *   allocated memory is only released when the mapper/inode is destroyed.
  ******************************************************************************************/
 …
 typedef struct mapper_s
+{
         struct vfs_inode_s * inode;           /*! owner file inode                                */
+        struct vfs_inode_s * inode;           /*! owner inode                                     */
         grdxt_t              radix;           /*! pages cache implemented as a radix tree         */
         rwlock_t             lock;        /*! several readers / only one writer               */
 …
     uint32_t    size;                /*! number of bytes in fragment                      */
     cxy_t       buf_cxy;             /*! user buffer cluster identifier                   */
     uint8_t   * buf_ptr;             /*! local pointer on first byte in user buffer       */
+    void      * buf_ptr;             /*! local pointer on first byte in user buffer       */
+}
 fragment_t;
 …
 /*******************************************************************************************
+ * This function moves all fragments covering a distributed user buffer between
+ * a mapper (associated to a local inode), and the user buffer.
+ * [See the fragment definition in the mapper.h file]
+ * It must be executed by a thread running in the cluster containing the mapper.
+ * The lock protecting the mapper must have been taken in WRITE_MODE or READ_MODE
+ * by the caller thread, depending on the transfer direction.
+ * This function move data between a kernel mapper and an user buffer.
+ * It must be called by a thread running in the cluster containing the mapper.
+ * It split the data in fragments : one fragment is a set of contiguous bytes
+ * stored in the same mapper page.
+ * It uses "hal_uspace" accesses to move fragments to/from the user buffer.
  * In case of write, the dirty bit is set for all pages written in the mapper.
  * The offset in the file descriptor is not modified by this function.
- * Implementation note:
- * For each fragment, this function makes ONE hal_remote_memcpy() when the fragment is
- * fully contained in one single page of the mapper. It makes TWO hal_remote_memcpy()
- * if the fragment spread on two contiguous pages in the mapper.
  *******************************************************************************************
+ * @ mapper    : local pointer on the local mapper.
+ * @ to_buffer : mapper to buffer if true / buffer to mapper if false.
+ * @ nb_frags  : number of fragments covering the user buffer (one per page).
+ * @ frags_xp  : extended pointer on array of fragments.
+FAT * returns O if success / returns EINVAL if error.
+ * @ mapper       : extended pointer on local mapper.
+ * @ to_buffer    : move data from mapper to buffer if true.
+ * @ file_offset  : first byte to move in file.
+ * @ buffer       : buffer address in user space.
+ * @ size         : number of bytes to move.
+ * returns O if success / returns EINVAL if error.
  ******************************************************************************************/
 error_t mapper_move_fragments( mapper_t * mapper,
                                bool_t     to_buffer,
                                uint32_t   nb_frags,
                                xptr_t     frags_xp );
+error_t mapper_move( mapper_t * mapper,
+                     bool_t     to_buffer,
+                     uint32_t   file_offset,
+                     void     * buffer,
+                     uint32_t   size );
 /*******************************************************************************************
 …
  *******************************************************************************************
  * @ mapper     : local pointer on the mapper.
- * @ index      : page index in file
  * @ page       : pointer on page to remove.
  * @ return 0 if success / return EIO if a dirty page cannot be copied to FS.
  ******************************************************************************************/
 error_t mapper_release_page( mapper_t      * mapper,
-                             uint32_t        index,
                              struct page_s * page );
 …
                                  uint32_t   index );
+/*******************************************************************************************
+ * This function makes an I/O operation to move one page from FS to mapper.
+ * Depending on the file system type, it calls the proper, FS specific function.
+ * It must be executed by a thread running in the cluster containing the mapper.
+ *******************************************************************************************
+ * @ mapper     : local pointer on the mapper.
+ * @ index      : page index in file.
+ * @ page   : local pointer on the page descriptor in mapper.
+ * @ returns 0 if success / return EINVAL if it cannot access the device.
+ ******************************************************************************************/
+error_t mapper_updt_page( mapper_t      * mapper,
+                          uint32_t        index,
+                          struct page_s * page );
+/*******************************************************************************************
+ * This function makes an I/0 operation to move one page from mapper to FS.
+ * Depending on the file system type, it calls the proper, FS specific function.
+ * It must be executed by a thread running in the cluster containing the mapper.
+ * It does nothing if the page is not dirty. If the page is dirty, it takes
+ * the page lock before launching the IO operation, clear the page dirty bit,
+ * and remove the page from the PPM dirty list. It does nothing if the page is not dirty.
+ *******************************************************************************************
+ * @ mapper     : local pointer on the mapper.
+ * @ index      : page index in file.
+ * @ page   : local pointer on the page descriptor in mapper.
+ * @ returns 0 if success / return EINVAL if it cannot access the device.
+ ******************************************************************************************/
+error_t mapper_sync_page( mapper_t      * mapper,
+                          uint32_t        index,
+                          struct page_s * page );
 #endif /* _MAPPER_H_ */

trunk/kernel/mm/page.c

-                      r22
+                      r23
+ *
  * Authors  Ghassan Almaless (2008,2009,2010,2011,2012)
  *          Alain Greiner    (2016)
+ *          Alain Greiner    (2016,2017)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
         page->flags    = 0;
         page->order    = 0;
+        page->mapper   = NULL;
         page->index    = 0;
+        page->mapper   = NULL;
+        page->private  = 0;
+        page->fork_nr  = 0;
         page->refcount = 0;
         spinlock_init( &page->lock );
         list_entry_init( &page->list );
+    xlist_root_init( XPTR( local_cxy , &page->wait_root ) );
+}
 ////////////////////////////////////////////
 inline void page_set_flag( page_t   * page,
                            uint16_t   value )
+                           uint32_t   value )
+{
         hal_atomic_or( (uint32_t *)&page->flags , (uint32_t)value );
 …
 //////////////////////////////////////////////
 inline void page_clear_flag( page_t   * page,
                              uint16_t   value )
+                             uint32_t   value )
+{
         hal_atomic_and( (uint32_t *)&page->flags , ~((uint32_t)value) );
 …
 //////////////////////////////////////////////
 inline bool_t page_is_flag( page_t   * page,
                             uint16_t   value )
+{
         return (bool_t)(page->flags & value);
+                            uint32_t   value )
+{
+    return ( (page->flags & value) ? 1 : 0 );
+}
 …
                 // sync the page
                 mapper_sync_page( mapper , index , page );
+                vfs_move_page_from_mapper( page );
                 // unlock the page
 …
 inline void page_refcount_up( page_t *page )
+{
         hal_atomic_inc( &page->refcount );
+    hal_atomic_add( &page->refcount , +1 );
+}
 …
 inline void page_refcount_down( page_t *page )
+{
         hal_atomic_dec( &page->refcount );
+    hal_atomic_add( &page->refcount , -1 );
+}

trunk/kernel/mm/page.h

-                      r22
+                      r23
 #define PG_DIRTY            0x0040     // page has been written
 #define PG_LOCKED       0x0080     // page is locked
+#define PG_COW          0x0100     // page is copy-on-write
 #define PG_ALL          0xFFFF     // All flags
 …
 /*************************************************************************************
  * This structure defines a physical page descriptor.
  * Size is 60 bytes for a 32 bits core...
+ * Size is 64 bytes for a 32 bits core...
  ************************************************************************************/
 typedef struct page_s
+{
+    uint16_t          flags;          /*! flags defined above                  (2)  */
+    uint16_t          order;          /*! log2( number of 4Kbytes pages)       (2)  */
+    uint32_t          flags;          /*! flags defined above                  (4)  */
+    uint32_t          order;          /*! log2( number of 4Kbytes pages)       (4)  */
     struct mapper_s * mapper;         /*! local pointer on associated mapper   (4)  */
     uint32_t          index;          /*! page index in mapper                 (4)  */
-        union                             /*!                                      (4)  */
+        {
-                uint32_t      private;        /*! TODO ??? [AG]                             */
-                void        * data;           /*! TODO ??? [AG]                             */
-                slist_entry_t root;           /*! TODO ??? [AG]                             */
-        };
         list_entry_t      list;           /*! for both dirty pages and free pages  (8)  */
     xlist_entry_t     wait_root;      /*! root of list of waiting threads      (16) */
         uint32_t          refcount;       /*! reference counter                    (4)  */
+        uint32_t          fork_nr;        /*! number of forked processes           (4)  */
         spinlock_t        lock;           /*! only used to set the PG_LOCKED flag  (16) */
+}
 …
 /*************************************************************************************
  * This function initializes one page descriptor.
+ *************************************************************************************
  * @ page    : pointer to page descriptor
  ************************************************************************************/
 …
 /*************************************************************************************
+ * This function sets one or several flags in page descriptor flags.
+ * This function atomically set one or several flags in page descriptor flags.
+ *************************************************************************************
  * @ page    : pointer to page descriptor.
  * @ value   : all non zero bits in value will be set.
  ************************************************************************************/
 inline void page_set_flag( page_t   * page,
                            uint16_t   value );
+                           uint32_t   value );
 /*************************************************************************************
+ * This function clears one or several flags in page descriptor flags.
+ * This function atomically reset one or several flags in page descriptor flags.
+ *************************************************************************************
  * @ page    : pointer to page descriptor.
  * @ value   : all non zero bits in value will be cleared.
  ************************************************************************************/
 inline void page_clear_flag( page_t   * page,
                              uint16_t   value );
+                             uint32_t   value );
 /*************************************************************************************
  * This function tests the value of one or several flags in page descriptor flags.
+ *************************************************************************************
  * @ page    : pointer to page descriptor.
  * @ value   : all non zero bits will be tested.
 …
  ************************************************************************************/
 inline bool_t page_is_flag( page_t   * page,
                             uint16_t   value );
+                            uint32_t   value );
 /*************************************************************************************
 …
  * This function sets the PG_DIRTY flag in the page descriptor,
  * and registers the page in the dirty list in PPM.
+ *************************************************************************************
  * @ page     : pointer on page descriptor.
  * @ returns true if page was not dirty / returns false if page was dirty
 …
  * This function resets the PG_DIRTY flag in the page descriptor,
  * and removes the page from the dirty list in PPM.
+ *************************************************************************************
  * @ page     : pointer on page descriptor.
  * @ returns true if page was dirty / returns false if page was not dirty
 …
 /*************************************************************************************
  * This function makes a local copy of the content of a src page to a dst page.
+ *************************************************************************************
  * @ dst      : pointer on destination page descriptor.
  * @ src      : pointer on source page descriptor.
 …
 /*************************************************************************************
  * This function resets to 0 all bytes in a given page.
+ *************************************************************************************
  * @ page     : pointer on page descriptor.
  ************************************************************************************/
 …
  * It deschedule if the page has already been locked by another thread,
  * and returns only when the flag has been successfully set.
+ *************************************************************************************
  * @ page     : pointer on page descriptor.
  ************************************************************************************/
 …
  * other waiting thread. If there is waiting thread(s), it activates the first
  * waiting thread without modifying the PG_LOCKED flag.
+ *************************************************************************************
  * @ page     : pointer on page descriptor.
  ************************************************************************************/
 …
 /*************************************************************************************
  * This blocking function atomically increments the page refcount.
+ *************************************************************************************
  * @ page     : pointer on page descriptor.
  ************************************************************************************/
 …
 /*************************************************************************************
  * This blocking function atomically decrements the page refcount.
+ *************************************************************************************
  * @ page     : pointer on page descriptor.
  ************************************************************************************/
 …
 /*************************************************************************************
  * This function display the values contained in a page descriptor.
+ *************************************************************************************
+ * @ page     : pointer on page descriptor.
  ************************************************************************************/
 void page_print( page_t * page );

trunk/kernel/mm/vmm.c

-                      r21
+                      r23
 #include <hal_gpt.h>
 #include <printk.h>
+#include <memcpy.h>
 #include <rwlock.h>
 #include <list.h>
 …
     // initialize local list of vsegs and radix-tree
+    vmm->vsegs_nr = 0;
         list_root_init( &vmm->vsegs_root );
-    vmm->vsegs_nr = 0;
     error = grdxt_init( &vmm->grdxt,
                         CONFIG_VMM_GRDXT_W1,
 …
 }  // end vmm_init()
+//////////////////////////////////////////
+error_t vmm_copy( process_t * dst_process,
+                  process_t * src_process )
+{
+    error_t error;
+    vmm_t * src_vmm = &src_process->vmm;
+    vmm_t * dst_vmm = &dst_process->vmm;
+    // take the src_vmm vsegs_lock
+    rwlock_wr_lock( &src_vmm->vsegs_lock );
+    // initialise dst_vmm vsegs_lock
+    rwlock_init( &dst_vmm->vsegs_lock );
+    // initialise the dst_vmm vsegs list and the radix tree
+    dst_vmm->vsegs_nr = 0;
+    list_root_init( &dst_vmm->vsegs_root );
+    error = grdxt_init( &dst_vmm->grdxt,
+                        CONFIG_VMM_GRDXT_W1,
+                        CONFIG_VMM_GRDXT_W2,
+                        CONFIG_VMM_GRDXT_W3 );
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot initialise radix tree for process %x\n",
+               __FUNCTION__ , dst_process->pid );
+        return ENOMEM;
+    }
+    // loop on src_vmm list of vsegs to create
+    // and register vsegs copies in dst_vmm
+    list_entry_t * iter;
+    vseg_t       * src_vseg;
+    vseg_t       * dst_vseg;
+    LIST_FOREACH( &src_vmm->vsegs_root , iter )
+    {
+        // get pointer on current src_vseg
+        src_vseg = LIST_ELEMENT( iter , vseg_t , list );
+        // allocate memory for a new dst_vseg
+        dst_vseg = vseg_alloc();
+        if( dst_vseg == NULL )
+        {
+            // release all allocated vsegs
+            LIST_FOREACH( &dst_vmm->vsegs_root , iter )
+            {
+                dst_vseg = LIST_ELEMENT( iter , vseg_t , list );
+                vseg_free( dst_vseg );
+            }
+            return ENOMEM;
+        }
+        // copy src_vseg to dst_vseg
+        vseg_init_from_ref( dst_vseg , XPTR( local_cxy , src_vseg ) );
+        // register dst_vseg in dst_vmm
+        vseg_attach( dst_vmm , dst_vseg );
+    }
+    // release the src_vmm vsegs_lock
+    rwlock_wr_unlock( &src_vmm->vsegs_lock );
+    // initialize generic page table
+    error = hal_gpt_create( &dst_vmm->gpt );
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot initialize page table\n", __FUNCTION__ );
+        return ENOMEM;
+    }
+    // initialize STACK allocator
+    dst_vmm->stack_mgr.bitmap   = 0;
+    dst_vmm->stack_mgr.vpn_base = CONFIG_VMM_STACK_BASE;
+    // initialize MMAP allocator
+    dst_vmm->mmap_mgr.vpn_base        = CONFIG_VMM_MMAP_BASE;
+    dst_vmm->mmap_mgr.vpn_size        = CONFIG_VMM_STACK_BASE - CONFIG_VMM_MMAP_BASE;
+    dst_vmm->mmap_mgr.first_free_vpn  = CONFIG_VMM_MMAP_BASE;
+    uint32_t i;
+    for( i = 0 ; i < 32 ; i++ ) list_root_init( &dst_vmm->mmap_mgr.zombi_list[i] );
+    // initialise instrumentation counters
+        dst_vmm->pgfault_nr    = 0;
+        dst_vmm->u_err_nr      = 0;
+        dst_vmm->m_err_nr      = 0;
+    // copy base addresses
+    dst_vmm->kent_vpn_base = src_vmm->kent_vpn_base;
+    dst_vmm->args_vpn_base = src_vmm->args_vpn_base;
+    dst_vmm->envs_vpn_base = src_vmm->envs_vpn_base;
+    dst_vmm->heap_vpn_base = src_vmm->heap_vpn_base;
+    dst_vmm->code_vpn_base = src_vmm->code_vpn_base;
+    dst_vmm->data_vpn_base = src_vmm->data_vpn_base;
+    dst_vmm->entry_point   = src_vmm->entry_point;
+    // HEAP TODO : new heap for child ???
+    dst_vmm->heap_vseg     = src_vmm->heap_vseg;
+    // initialize generic page table
+    error = hal_gpt_create( &dst_vmm->gpt );
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot initialize page table\n", __FUNCTION__ );
+        return ENOMEM;
+    }
+    // copy GPT content from src_vmm to dst_vmm, activating "Copy-On-Write"
+    // TODO register Copy-On_Write in page descriptors
+    bool_t cow = true;
+    hal_gpt_copy( &dst_vmm->gpt , &src_vmm->gpt , cow );
+    hal_wbflush();
+    return 0;
+}  // end vmm_copy()
 ///////////////////////////////////////
 …
     error_t   error;
     // this function must be called by in the reference cluster
     if( process->is_ref == false );
+    // this function must be called by a thread running in the reference cluster
+    if( GET_CXY( process->ref_xp ) != local_cxy );
+    {
         printk("\n[PANIC] in %s : not called in the reference cluster\n", __FUNCTION__ );
 …
                            paddr_t * paddr )
+{
+    uint32_t vaddr = (uint32_t)ptr;
+    thread_t  * this    = CURRENT_THREAD;
+    process_t * process = this->process;
+    process_t * process = CURRENT_THREAD->process;
     if( ident )  // identity mapping
+    {
         *paddr = (paddr_t)PADDR( local_cxy , vaddr );
+        *paddr = (paddr_t)PADDR( local_cxy , (lpa_t)ptr );
         return 0;
+    }
 …
     uint32_t offset;
     vpn    = (vpn_t)( vaddr >> CONFIG_PPM_PAGE_SHIFT );
     offset = (uint32_t)( vaddr & CONFIG_PPM_PAGE_MASK );
     if( process->is_ref )   // calling process is reference process
+    vpn    = (vpn_t)( (intptr_t)ptr >> CONFIG_PPM_PAGE_SHIFT );
+    offset = (uint32_t)( ((intptr_t)ptr) & CONFIG_PPM_PAGE_MASK );
+    if( local_cxy == GET_CXY( process->ref_xp) )   // calling process is reference process
+    {
         error = vmm_get_pte( process, vpn , &attr , &ppn );
+    }
     else                    // use a RPC
+    else                                           // use a RPC
+    {
         cxy_t       ref_cxy = GET_CXY( process->ref_xp );
 …
+    }
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot get physical address for vaddr = %x\n",
+               __FUNCTION__ , vaddr );
+        return error;
+    }
+    // return paddr
+    // set paddr
     *paddr = (((paddr_t)ppn) << CONFIG_PPM_PAGE_SHIFT) | offset;
+    return 0;
+    return error;
 }  // end vmm_v2p_translate()
+//////////////////////////////////////////////

trunk/kernel/mm/vmm.h

-                      r18
+                      r23
  * Authors   Ghassan Almaless (2008,2009,2010,2011, 2012)
  *           Mohamed Lamine Karaoui (2015)
  *           Alain Greiner (2016)
+ *           Alain Greiner (2016,2017)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
         rwlock_t       vsegs_lock;         /*! lock protecting the vsegs list & radix tree      */
         list_entry_t   vsegs_root;         /*! all vsegs in same process and same cluster       */
+        uint32_t       vsegs_nr;           /*! total number of vsegs                            */
+        uint32_t       vsegs_nr;           /*! total number of local vsegs                      */
         grdxt_t        grdxt;              /*! embedded generic vsegs radix tree (key is vpn)   */
 …
     stack_mgr_t    stack_mgr;          /*! embedded STACK vsegs allocator                   */
     mmap_mgr_t     mmap_mgr;           /*! embedded MMAP vsegs allocator                    */
 …
 /*********************************************************************************************
+ * This function copies the content of a source VMM to a destination VMM.
+ *********************************************************************************************
+ * @ dst_process   : pointer on destination process descriptor.
+ * @ src_process   : pointer on source process descriptor.
+ * @ return 0 if success / return ENOMEM if failure.
+ ********************************************************************************************/
+error_t vmm_copy( struct process_s * dst_process,
+                  struct process_s * src_process );
+/*********************************************************************************************
  * This function removes all vsegs registered in in a virtual memory manager,
  * and releases the memory allocated to the local generic page table.
  *********************************************************************************************
  * @ vmm   : pointer on process descriptor.
+ * @ process   : pointer on process descriptor.
  ********************************************************************************************/
 void vmm_destroy( struct process_s * process );
 …
 /*********************************************************************************************
  * This function is called by the architecture specific exception handler when a
  * page fault has been detected in a given cluster.
+ * This function is called by the generic exception handler when a page fault
+ * has been detected in a given cluster.
  * If the local cluster is not the reference cluster, it send a RPC_VMM_GET_PTE
  * to the reference cluster to get the missing PTE attributes and PPN, and update
 …
  * This function makes the virtual to physical address translation, using the calling
  * process page table. It uses identity mapping if required by the ident flag.
  * This address translation is required to configure the devices
  * that have a DMA capability, or to implement the software L2/L3 cache cohérence,
  * using the MMC device synchronisation primitives.
  * WARNING : the <ident> value must be defined by the CONFIG_KERNEL_IDENT parameter.
+ * This address translation is required to configure the peripherals having a DMA
+ * capability, or to implement the software L2/L3 cache cohérence, using the MMC device
+ * synchronisation primitives.
+ * WARNING : the <ident> value must be defined by the CONFIG_KERNEL_IDENTITY_MAP parameter.
  *********************************************************************************************
  * @ ident     : [in] uses identity mapping if true.
 …
 /*********************************************************************************************
- * Pas a sa place ici [AG]
- ********************************************************************************************/
-int sys_mmap( mmap_attr_t * mattr );
-/*********************************************************************************************
  ********************************************************************************************/
 int sys_madvise( void    * start,

trunk/kernel/syscalls/sys_alarm.c

-                      r1
+                      r23
 /*
  * kern/sys_alarm.c - timed sleep/wakeup
+ * sys_alarm.c - timed sleep/wakeup
+ *
+ * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
+ * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ * Author    Alain Greiner (2016,2017)
+*
+ * Copyright (c) UPMC Sorbonne Universites
+ *
  * This file is part of ALMOS-kernel.
+ * This file is part of ALMOS-MKH.
+ *
  * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
 #include <types.h>
+#include <hal_types.h>
 #include <thread.h>
+#include <printk.h>
 #include <cluster.h>
+#include <task.h>
+#include <time.h>
+#include <process.h>
 #include <scheduler.h>
+#include <cpu.h>
+#include <cpu-trace.h>
+#include <core.h>
+EVENT_HANDLER(sys_alarm_event_handler)
+////////////////////////////////
+int sys_alarm( uint64_t cycles )
+{
+        struct thread_s *thread;
+    thread_t  * this    = CURRENT_THREAD;
+    process_t * process = this->process;
+        thread = event_get_argument(event);
+        sched_wakeup(thread);
+        return 0;
+}
+int sys_alarm (unsigned nb_sec)
+{
+        struct thread_s *this;
+        struct event_s event;
+        struct alarm_info_s info;
+        if( nb_sec == 0)
+                return 0;
+        this = current_thread;
+        event_set_handler(&event, &sys_alarm_event_handler);
+        event_set_priority(&event, E_FUNC);
+        event_set_argument(&event,this);
+        info.event = &event;
+        alarm_wait(&info, nb_sec * 4);
+        sched_sleep(this);
+        return 0;
+    printk("\n[ERROR] in %s for thread %x in process %x : not implemented yet\n",
+           __FUNCTION__ , this->trdid , process->pid );
+    this->errno = EFAULT;
+    return -1;
+}

trunk/kernel/syscalls/sys_barrier.c

-                      r1
+                      r23
 /*
  * kern/sys_barrier.c - barrier service interface for userland
+ * sys_barrier.c - Access a POSIX barrier.
+ *
+ * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
+ * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ * authors       Alain Greiner (2016,2017)
+ *
  * This file is part of ALMOS-kernel.
+ * Copyright (c) UPMC Sorbonne Universites
+ *
+ * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * This file is part of ALMOS-MKH.
+ *
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
+#include <types.h>
+#include <hal_types.h>
+#include <hal_special.h>
 #include <errno.h>
 #include <thread.h>
+#include <task.h>
+#include <kmem.h>
+#include <printk.h>
 #include <vmm.h>
 #include <kmagics.h>
 #include <barrier.h>
+#include <syscalls.h>
+#include <remote_barrier.h>
+int sys_barrier(struct barrier_s **barrier, uint_t operation, uint_t count)
+//////////////////////////////////
+int sys_barrier( void     * vaddr,
+                 uint32_t   operation,
+                 uint32_t   count )
+{
+        kmem_req_t req;
+        struct barrier_s *ibarrier;
+        error_t err = EINVAL;
+        error_t      error;
+    paddr_t      paddr;
+        if((err = vmm_check_address("usr barrier ptr",
+                                    current_task,
+                                    barrier,
+                                    sizeof(struct barrier_s*))))
+                goto SYS_BARRIER_END;
+    thread_t   * this = CURRENT_THREAD;
+        if((err = cpu_copy_from_uspace(&ibarrier, barrier, sizeof(struct barrier_s *))))
+                goto SYS_BARRIER_END;
+    // check vaddr in user vspace
+        error = vmm_v2p_translate( false , vaddr , &paddr );
+        if( error )
+    {
+        printk("\n[ERROR] in %s : illegal barrier virtual address = %x\n",
+               __FUNCTION__ , (intptr_t)vaddr );
+        this->errno = error;
+        return -1;
+    }
+        switch(operation)
+    // execute requested operation
+        switch( operation )
+        {
+        case BARRIER_INIT_PRIVATE:
+        case BARRIER_INIT_SHARED:
+                req.type  = KMEM_BARRIER;
+                req.size  = sizeof(*ibarrier);
+                req.flags = AF_USER;
+        //////////////////
+            case BARRIER_INIT:
+        {
+            error = remote_barrier_create( (intptr_t)vaddr , count );
+                    if( error )
+            {
+                printk("\n[ERROR] in %s : cannot create barrier = %x\n",
+                       __FUNCTION__ , (intptr_t)vaddr );
+                this->errno = error;
+                return -1;
+            }
+                        break;
+        }
+        //////////////////
+            case BARRIER_WAIT:
+        {
+            xptr_t barrier_xp = remote_barrier_from_ident( (intptr_t)vaddr );
+                if((ibarrier = kmem_alloc(&req)) == NULL)
+                {
+                        err = ENOMEM;
+                        break;
+                }
+                if((err = barrier_init(ibarrier, count, operation)))
+                        break;
+                if((err = cpu_copy_to_uspace(barrier, &ibarrier, sizeof(struct barrier_s *))))
+                {
+                        req.ptr = ibarrier;
+                        kmem_free(&req);
+                }
+                break;
+            if( barrier_xp == XPTR_NULL )     // user error
+            {
+                printk("\n[ERROR] in %s : barrier %x not registered\n",
+                       __FUNCTION__ , (intptr_t)vaddr );
+                this->errno = EINVAL;
+                return -1;
+            }
+            else                          // success
+            {
+                remote_barrier_wait( barrier_xp );
+            }
+            break;
+        }
+        /////////////////////
+            case BARRIER_DESTROY:
+        {
+            xptr_t barrier_xp = remote_barrier_from_ident( (intptr_t)vaddr );
+        case BARRIER_WAIT:
+            if( barrier_xp == XPTR_NULL )     // user error
+            {
+                printk("\n[ERROR] in %s : barrier %x not registered\n",
+                       __FUNCTION__ , (intptr_t)vaddr );
+                this->errno = EINVAL;
+                return -1;
+            }
+            else                          // success
+            {
+                remote_barrier_destroy( barrier_xp );
+            }
+            break;
+        }
+        ////////
+            default:
+        {
+            printk("\n[PANIC] in %s : illegal operation type\n", __FUNCTION__ );
+            hal_core_sleep();
+        }
+        }  // end switch
+                if((err = vmm_check_object(ibarrier, struct barrier_s, BARRIER_ID)))
+                        break;
+        return 0;
+                err = barrier_wait(ibarrier);
+                break;
+}  // end sys_barrier()
-        case BARRIER_DESTROY:
-                if((err = vmm_check_object(ibarrier, struct barrier_s, BARRIER_ID)))
-                        break;
-                if((err = barrier_destroy(ibarrier)))
-                        break;
-                req.type = KMEM_BARRIER;
-                req.ptr  = ibarrier;
-                kmem_free(&req);
-                return 0;
-        default:
-                err = EINVAL;
+        }
-SYS_BARRIER_END:
-        current_thread->info.errno = err;
-        return err;
+}
-KMEM_OBJATTR_INIT(barrier_kmem_init)
+{
-        attr->type   = KMEM_BARRIER;
-        attr->name   = "KCM Barrier";
-        attr->size   = sizeof(struct barrier_s);
-        attr->aligne = 0;
-        attr->min    = CONFIG_BARRIER_MIN;
-        attr->max    = CONFIG_BARRIER_MAX;
-        attr->ctor   = NULL;
-        attr->dtor   = NULL;
-        return 0;
+}

trunk/kernel/syscalls/sys_chdir.c

-                      r11
+                      r23
 /*
  * sys_chdir: change process current work directory
+ * sys_chdir: change process current working directory
+ *
+ * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
+ * Author    Alain Greiner (2016,2017)
+ *
  * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ *
  * This file is part of ALMOS-kernel.
+ * This file is part of ALMOS-MKH.
+ *
  * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
+#include <cpu.h>
+#include <hal_types.h>
+#include <hal_uspace.h>
 #include <chdev.h>
-#include <driver.h>
 #include <rwlock.h>
 #include <vfs.h>
 #include <sys-vfs.h>
+#include <errno.h>
 #include <thread.h>
 #include <ku_transfert.h>
 #include <task.h>
+#include <printk.h>
+#include <process.h>
+int sys_chdir (char *pathname)
+/////////////////////////////////
+int sys_chdir ( char * pathname )
+{
         register error_t err = 0;
         register struct thread_s *this;
         register struct task_s *task;
         struct ku_obj ku_path;
+        error_t   error;
+    paddr_t   paddr;
+    uint32_t  length;
+    char      kbuf[CONFIG_VFS_MAX_PATH_LENGTH];
         this = current_thread;
         task = current_task;
+        thread_t  * this    = CURRENT_THREAD;
+    process_t * process = this->process;
+        if(!pathname)
+    // check pathname in user space
+    error = vmm_v2p_translate( false , pathname , &paddr );
+        if( error )
+        {
+                this->info.errno = EINVAL;
+        printk("\n[ERROR] in %s : user buffer unmapped  for thread %x in process %x\n",
+               __FUNCTION__ , this->trdid , process->pid );
+                this->errno = EINVAL;
                 return -1;
+        }
+        KU_BUFF(ku_path, pathname);
+        rwlock_wrlock(&task->cwd_lock);
+    // get pathname length
+    length = hal_strlen_from_uspace( pathname );
+    if( length >= CONFIG_VFS_MAX_PATH_LENGTH )
+    {
+        printk("\n[ERROR] in %s : pathname too long for thread %x in process %x\n",
+               __FUNCTION__ , this->trdid , process->pid );
+                this->errno = ENFILE;
+        return -1;
+    }
+        // get pathname copy in kernel space
+    hal_copy_from_uspace( kbuf, pathname, length );
+    // 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 );
+    // get extended pointer on cwd lock in reference process
+    xptr_t lock_xp = hal_remote_lwd( XPTR( ref_cxy , &ref_ptr->cwd_lock ) );
+        if((err = vfs_chdir(&ku_path, &task->vfs_cwd)))
+    // get cwd lock in read mode
+        remote_rwlock_rd_lock( lock_xp );
+    // call relevant VFS function
+        error = vfs_chdir( process->vfs_cwd_xp , kbuf );
+    // release cwd lock
+        remote_rwlock_rd_unlock( lock_xp );
+        if( error )
+        {
                 rwlock_unlock(&task->cwd_lock);
                 this->info.errno = (err < 0) ? -err : err;
+        printk("\n[ERROR] in %s : cannot change current directory\n", __FUNCTION__ );
+                this->errno = error;
                 return -1;
+        }
-        rwlock_unlock(&task->cwd_lock);
         return 0;
+}

trunk/kernel/syscalls/sys_chmod.c

-                      r11
+                      r23
 /*
  * sys_chmod: change file mode
+ * sys_chmod.c - Change file access rights.
+ *
+ * Author    Alain Greiner  (2016,2017)
+ *
  * Copyright (c) 2015 UPMC Sorbonne Universites
+ *
  * This file is part of ALMOS-kernel.
+ * This file is part of ALMOS-MKH.
+ *
  * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
+#include <cpu.h>
+#include <chdev.h>
+#include <driver.h>
+#include <rwlock.h>
+#include <hal_types.h>
+#include <hal_uspace.h>
 #include <vfs.h>
+#include <sys-vfs.h>
+#include <vmm.h>
+#include <printk.h>
 #include <thread.h>
+#include <ku_transfert.h>
+#include <task.h>
+#include <process.h>
+int sys_chmod (char *pathname, uint_t mode)
+//////////////////////////////////
+int sys_chmod( char    * pathname,
+               uint32_t  rights )
+{
+        register error_t err = 0;
+        register struct thread_s *this;
+        register struct task_s *task;
+        struct ku_obj ku_path;
+    error_t     error;
+    paddr_t     paddr;
+    uint32_t    length;
+    char        kbuf[CONFIG_VFS_MAX_PATH_LENGTH];
+        thread_t  * this    = CURRENT_THREAD;
+        process_t * process = this->process;
+        this = current_thread;
         task = current_task;
+    // check pathname in user space
+    error = vmm_v2p_translate( false , pathname , &paddr );
         if(!pathname || NOT_IN_USPACE(pathname))
+        if( error )
+        {
+                this->info.errno = EINVAL;
+        printk("\n[ERROR] in %s : user pathname unmapped for thread %x in process %x\n",
+               __FUNCTION__ , this->trdid , process->pid );
+                this->errno = EINVAL;
                 return -1;
+        }
+        KU_BUFF(ku_path, pathname);
+        rwlock_wrlock(&task->cwd_lock);
+        if((err = vfs_chmod(&ku_path, &task->vfs_cwd, mode)))
+    // get pathname length
+    length = hal_strlen_from_uspace( pathname );
+    if( length >= CONFIG_VFS_MAX_PATH_LENGTH )
+    {
+        printk("\n[ERROR] in %s : pathname too long\n", __FUNCTION__ );
+                this->errno = ENFILE;
+        return -1;
+    }
+        // get pathname copy in kernel space
+    hal_copy_from_uspace( kbuf, pathname, length );
+    // 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 );
+    // get extended pointer on cwd inode
+    xptr_t cwd_xp = hal_remote_lwd( XPTR( ref_cxy , &ref_ptr->vfs_cwd_xp ) );
+    // get the cwd lock in read mode from reference process
+        remote_rwlock_rd_lock( XPTR( ref_cxy , &ref_ptr->cwd_lock ) );
+    // call the relevant VFS function
+        error = vfs_chmod( cwd_xp,
+                       kbuf,
+                       rights );
+    // release the cwd lock
+        remote_rwlock_rd_unlock( XPTR( ref_cxy , &ref_ptr->cwd_lock ) );
+    if( error )
+        {
+                rwlock_unlock(&task->cwd_lock);
+                this->info.errno = (err < 0) ? -err : err;
+        printk("\n[ERROR] in %s : cannot remove directory %s\n",
+               __FUNCTION__ , kbuf );
+                this->errno = error;
                 return -1;
+        }
-        rwlock_unlock(&task->cwd_lock);
         return 0;
+}
+}  // end sys_chmod()

trunk/kernel/syscalls/sys_clock.c

-                      r1
+                      r23
 /*
  * sys_clock: get system current time
+ * sys_clock: get calling core cycles count
+ *
+ * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
+ * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ * Author    Alain Greiner (2016,2017)
+ *
+ * Copyright (c) UPMC Sorbonne Universites
+ *
  * This file is part of ALMOS-kernel.
+ * This file is part of ALMOS-MKH.
+ *
  * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
+#include <hal_types.h>
+#include <hal_uspace.h>
 #include <errno.h>
+#include <config.h>
+#include <cpu.h>
+#include <core.h>
 #include <thread.h>
+#include <process.h>
+#include <vmm.h>
+#include <printk.h>
+int sys_clock(uint64_t *val)
+//////////////////////////////////
+int sys_clock (uint64_t * cycles )
+{
+        error_t err;
+        uint64_t cycles;
+        error_t   error;
+    paddr_t   paddr;
+        uint64_t  k_cycles;
+        if((val == NULL) || NOT_IN_USPACE((uint_t)val))
+    thread_t  * this    = CURRENT_THREAD;
+    process_t * process = this->process;
+    // check buffer in user space
+    error = vmm_v2p_translate( false , cycles , &paddr );
+        if( error )
+        {
+                err = EINVAL;
+                goto fail_inval;
+        printk("\n[ERROR] in %s : user buffer unmapped for thread %x in process %x\n",
+               __FUNCTION__ , this->trdid , process->pid );
+        this->errno = EFAULT;
+                return -1;
+        }
+        cycles = cpu_get_cycles(current_cpu);
         err    = cpu_copy_to_uspace(val, &cycles, sizeof(cycles));
+    // call relevant core function
+        k_cycles = core_get_cycles( this->core );
+fail_inval:
+        current_thread->info.errno = err;
+        return err;
+}
+    // copy to user space
+        hal_copy_to_uspace( cycles , &k_cycles , sizeof(uint64_t) );
+        return 0;
+}  // end sys_clock()

trunk/kernel/syscalls/sys_close.c

-                      r11
+                      r23
 /*
  * sys_close.c  close a process open file
+ * sys_close.c  close an open file
+ *
+ * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
+ * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ * Author    Alain Greiner (2016,2017)
+ *
  * This file is part of ALMOS-kernel.
+ * Copyright (c) UPMC Sorbonne Universites
+ *
+ * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * This file is part of ALMOS-MKH.
+ *
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
 #include <cpu.h>
 #include <chdev.h>
 #include <driver.h>
+#include <kernel_config.h>
+#include <hal_types.h>
+#include <hal_special.h>
 #include <vfs.h>
-#include <sys-vfs.h>
 #include <process.h>
 #include <thread.h>
 #include <config.h>
+#include <printk.h>
 /////////////////////////////
 int sys_close ( uint32_t fd )
+//////////////////////////////////
+int sys_close ( uint32_t file_id )
+{
+        register process_t * process = current_process;
+        register thread_t  * this    = current_thread;
+        struct vfs_file_s  * file    = NULL;
+        error_t              err;
+        if(( fd >= CONFIG_TASK_FILE_MAX_NR ) || (process_fd_lookup( process , fd , &file )))
+    error_t     error;
+    xptr_t      file_xp;
+        thread_t  * this    = CURRENT_THREAD;
+        process_t * process = this->process;
+    // check file_id argument
+        if( file_id >= CONFIG_PROCESS_FILE_MAX_NR )
+        {
+                this->info.errno = EBADFD;
+        printk("\n[ERROR] in %s : illegal file descriptor index = %d\n",
+               __FUNCTION__ , file_id );
+                this->errno = EBADFD;
                 return -1;
+        }
+        err = vfs_close( file , NULL );
+        if( err )
+    // get extended pointer on remote file descriptor
+    file_xp = process_fd_get_xptr( process , file_id );
+    if( file_xp == XPTR_NULL )
+    {
+        printk("\n[ERROR] in %s : undefined file descriptor = %d\n",
+               __FUNCTION__ , file_id );
+                this->errno = EBADFD;
+                return -1;
+    }
+    // call the relevant VFS function
+        error = vfs_close( file_xp , file_id );
+        if( error )
+        {
+                this->info.errno = err;
+        printk("\n[ERROR] in %s : cannot close file descriptor = %d\n",
+               __FUNCTION__ , file_id );
+                this->errno = error;
                 return -1;
+        }
         process_fd_release( process , fd );
+        cpu_wbflush();
+        hal_wbflush();
         return 0;
+}

trunk/kernel/syscalls/sys_closedir.c

-                      r1
+                      r23
 /*
  * sys_closedir.c close a process open directory
+ * sys_closedir.c - Close an open directory.
+ *
+ * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
+ * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ * Author    Alain Greiner  (2016, 2017)
+ *
  * This file is part of ALMOS-kernel.
+ * Copyright (c) UPMC Sorbonne Universites
+ *
+ * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * This file is part of ALMOS-MKH.
+ *
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
+#include <hal_types.h>
 #include <vfs.h>
-#include <sys-vfs.h>
 #include <thread.h>
+#include <printk.h>
 #include <process.h>
 ////////////////////////////////
 int sys_closedir ( uint32_t fd )
+/////////////////////////////////////
+int sys_closedir ( uint32_t file_id )
+{
+        register thread_t  * this    = current-thread;
+        register process_t * process = current_process;
+        struct vfs_file_s  * file    = NULL;
+        error_t              err;
+        error_t        error;
+        xptr_t         file_xp;   // extended pointer on searched directory file descriptor
+        if(( fd >= CONFIG_TASK_FILE_MAX_NR ) || (process_fd_lookup( process , fd , &file )))
+        thread_t     * this     = CURRENT_THREAD;
+        process_t    * process  = this->process;
+    // check file_id argument
+        if( file_id >= CONFIG_PROCESS_FILE_MAX_NR )
+        {
+                this->info.errno = EBADFD;
+        printk("\n[ERROR] in %s : illegal file descriptor index %d\n",
+               __FUNCTION__ , file_id );
+        this->errno = EBADFD;
                 return -1;
+        }
+        err  = vfs_closedir( file , NULL );
+        if(err)
+    // get extended pointer on remote file descriptor
+    file_xp = process_fd_get_xptr( process , file_id );
+    if( file_xp == XPTR_NULL )
+    {
+        printk("\n[ERROR] in %s : undefined file descriptor index = %d\n",
+               __FUNCTION__ , file_id );
+                this->errno = EBADFD;
+                return -1;
+    }
+    // call relevant VFS function
+        error  = vfs_close( file_xp , file_id );
+        if( error )
+        {
+                this->info.errno = (err < 0) ? -err : err;
+        printk("\n[ERROR] in %s : cannot close the directory = %d\n",
+               __FUNCTION__ , file_id );
+                this->errno = error;
                 return -1;
+        }
-        process_fd_release( process , fd );
         return 0;
+}
+}  // end sys_closedir()

trunk/kernel/syscalls/sys_condvar.c

-                      r15
+                      r23
 /*
  * sys_cond_var: interface to access condition vraibles service
+ * sys_condvar.c - Access a POSIX condvar.
+ *
+ * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
+ * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ * Author    Alain Greiner  (2016,2017)
+ *
  * This file is part of ALMOS-kernel.
+ * Copyright (c) UPMC Sorbonne Universites
+ *
+ * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * This file is part of ALMOS-MKH.
+ *
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
+#include <types.h>
+#include <hal_types.h>
+#include <hal_special.h>
 #include <errno.h>
 #include <thread.h>
+#include <kmem.h>
+#include <task.h>
+#include <printk.h>
 #include <vmm.h>
+#include <kmagics.h>
+#include <semaphore.h>
+#include <cond_var.h>
+#include <syscalls.h>
+#include <remote_condvar.h>
+static inline bool_t isBadSem(struct semaphore_s *sem)
+{
+        return vmm_check_object(sem, struct semaphore_s, SEMAPHORE_ID);
+}
+////////////////////////////////////////
+int sys_condvar( void         * condvar,
+                 uint32_t       operation,
+                 void         * mutex )
+{
+        error_t    error;
+    paddr_t    paddr;
+    thread_t * this = CURRENT_THREAD;
+static inline bool_t isBadCV(struct cv_s *cv)
+{
+        return vmm_check_object(cv, struct cv_s, COND_VAR_ID);
+}
+    // check condvar in user vspace
+        error = vmm_v2p_translate( false , condvar , &paddr );
+        if( error )
+    {
+        printk("\n[ERROR] in %s : illegal condvar virtual address = %x\n",
+               __FUNCTION__ , (intptr_t)condvar );
+        this->errno = error;
+        return -1;
+    }
+int sys_cond_var(struct cv_s **cv, uint_t operation, struct semaphore_s **sem)
+{
+        kmem_req_t req;
+        struct cv_s *icv;
+        struct semaphore_s *isem;
+        error_t err = EINVAL;
+        if((err = vmm_check_address("usr cv ptr", current_task,cv,sizeof(struct cv_s*))))
+                goto SYS_COND_END;
+    // execute requested operation
+        switch( operation )
+        {
+        //////////////////
+        case CONDVAR_INIT:
+        {
+            error = remote_condvar_create( (intptr_t)condvar );
+                    if( error )
+            {
+                printk("\n[ERROR] in %s : cannot create condvar = %x\n",
+                       __FUNCTION__ , (intptr_t)condvar );
+                this->errno = error;
+                return -1;
+            }
+                    break;
+        }
+        //////////////////
+            case CONDVAR_WAIT:
+        {
+            // check mutex in user vspace
+                error = vmm_v2p_translate( false , mutex , &paddr );
+        if((err = cpu_copy_from_uspace(&icv, cv, sizeof(struct cv_s *))))
+                goto SYS_COND_END;
+                if( error )
+            {
+                printk("\n[ERROR] in %s : illegal condvar virtual address = %x\n",
+                       __FUNCTION__ , (intptr_t)condvar );
+                this->errno = error;
+                return -1;
+            }
+        switch(operation)
+        {
+        case CV_INIT:
+                req.type  = KMEM_CV;
+                req.size  = sizeof(*icv);
+                req.flags = AF_USER;
+            xptr_t condvar_xp = remote_condvar_from_ident( (intptr_t)condvar );
+            if( condvar_xp == XPTR_NULL )     // user error
+            {
+                printk("\n[ERROR] in %s : condvar %x not registered\n",
+                       __FUNCTION__ , (intptr_t)condvar );
+                this->errno = EINVAL;
+                return -1;
+            }
+                if((icv = kmem_alloc(&req)) == NULL)
+                {
+                        err = ENOMEM;
+                        break;
+            xptr_t mutex_xp = remote_condvar_from_ident( (intptr_t)condvar );
+            if( mutex_xp == XPTR_NULL )     // user error
+            {
+                printk("\n[ERROR] in %s : mutex %x not registered\n",
+                       __FUNCTION__ , (intptr_t)condvar );
+                this->errno = EINVAL;
+                return -1;
+            }
+            remote_condvar_wait( condvar_xp , mutex_xp );
+            break;
+        }
+        ////////////////////
+            case CONDVAR_SIGNAL:
+        {
+            xptr_t condvar_xp = remote_condvar_from_ident( (intptr_t)condvar );
+            if( condvar_xp == XPTR_NULL )     // user error
+            {
+                printk("\n[ERROR] in %s : condvar %x not registered\n",
+                       __FUNCTION__ , (intptr_t)condvar );
+                this->errno = EINVAL;
+                return -1;
+            }
+            remote_condvar_signal( condvar_xp );
+            break;
+        }
+        ///////////////////////
+            case CONDVAR_BROADCAST:
+        {
+            xptr_t condvar_xp = remote_condvar_from_ident( (intptr_t)condvar );
+            if( condvar_xp == XPTR_NULL )     // user error
+            {
+                printk("\n[ERROR] in %s : condvar %x not registered\n",
+                       __FUNCTION__ , (intptr_t)condvar );
+                this->errno = EINVAL;
+                return -1;
+            }
+            remote_condvar_broadcast( condvar_xp );
+            break;
+        }
+        /////////////////////
+            case CONDVAR_DESTROY:
+        {
+            xptr_t condvar_xp = remote_condvar_from_ident( (intptr_t)condvar );
+            if( condvar_xp == XPTR_NULL )     // user error
+            {
+                printk("\n[ERROR] in %s : condvar %x not registered\n",
+                       __FUNCTION__ , (intptr_t)condvar );
+                this->errno = EINVAL;
+                return -1;
+            }
+            remote_condvar_destroy( condvar_xp );
+            break;
+                }
+                if((err = cv_init(icv)))
+                        break;
+                if((err = cpu_copy_to_uspace(cv, &icv, sizeof(struct cv_s *))))
+                {
+                        req.ptr = icv;
+                        kmem_free(&req);
+                }
+        /////////
+            default:
+        {
+            printk("\n[PANIC] in %s : illegal operation type\n", __FUNCTION__ );
+            hal_core_sleep();
+        }
+        }   // end switch
                 break;
+        return 0;
+        case CV_WAIT:
+                err = vmm_check_address("usr sem ptr",
+                                        current_task,
+                                        sem, sizeof(struct semaphore_s*));
+}  // enc sys_condvar()
-                if(err) break;
-                if((err = cpu_copy_from_uspace(&isem, sem, sizeof(struct semaphore_s *))))
-                        break;
-                if(isBadSem(isem))
-                        break;
-                if(isBadCV(icv))
-                        break;
-                return cv_wait(icv, isem);
-        case CV_SIGNAL:
-                if(isBadCV(icv))
-                        break;
-                return cv_signal(icv);
-        case CV_BROADCAST:
-                if(isBadCV(icv))
-                        break;
-                return cv_broadcast(icv);
-        case CV_DESTROY:
-                if(isBadCV(icv))
-                        break;
-                if((err = cv_destroy(icv)))
-                        break;
-                req.type = KMEM_CV;
-                req.ptr  = icv;
-                kmem_free(&req);
-                return 0;
-        default:
-                err = EINVAL;
+        }
-SYS_COND_END:
-        current_thread->info.errno = err;
-        return err;
+}
-KMEM_OBJATTR_INIT(cv_kmem_init)
+{
-        attr->type   = KMEM_CV;
-        attr->name   = "KCM Condition Variable";
-        attr->size   = sizeof(struct cv_s);
-        attr->aligne = 0;
-        attr->min    = CONFIG_CONDTION_VAR_MIN;
-        attr->max    = CONFIG_CONDTION_VAR_MAX;
-        attr->ctor   = NULL;
-        attr->dtor   = NULL;
-        return 0;
+}

trunk/kernel/syscalls/sys_creat.c

-                      r1
+                      r23
 /*
  * kern/sys_creat.c - create a file
+ * sys_creat.c - create a file
+ *
+ * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
+ * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ * Author    Alain Greiner (2016,2017)
+ *
+ * Copyright (c) UPMC Sorbonne Universites
+ *
  * This file is part of ALMOS-kernel.
 …
  */
 #include <config.h>
+#include <hal_types.h>
 #include <vfs.h>
+#include <sys-vfs.h>
+#include <spinlock.h>
+#include <process.h>
+#include <thread.h>
+#include <syscalls.h>
 ////////////////////////////////////
 int sys_creat ( char     * pathname,
                 uint32_t   mode )
+int sys_creat( char     * pathname,
+               uint32_t   mode )
+{
         CPU_HW_TRACE(sys_creat);
+        uint32_t    flags = O_CREAT;
+        register error_t     err;
+        register uint32_t    flags;
+        register thread_t  * this    = durrent_thread;
+        register process_t * process = current_process;
+        struct vfs_file_s    file;
+        struct ku_obj        ku_path;
+        uint32_t             fd      = (uint32_t)-1;
+        if( process_fd_array_full( process ) )
+        {
+                this->info.errno = ENFILE;
+            CPU_HW_TRACE(sys_creat);
+        return fd;
+        }
+        flags = 0;
+        KU_BUFF( ku_path , pathname );
+    // get the cwd lock
+        rwlock_rdlock( &process->cwd_lock );
+        err = vfs_create( &process->vfs_cwd , &ku_path , flags , mode , &file );
+        if( err )
+        {
+                this->info.errno = (err < 0 ) ? -err : err;
+            rwlock_unlock( &process->cwd_lock );
+            CPU_HW_TRACE(sys_creat);
+            return fd;
+        }
+        err = process_fd_set( process , &file , &fd );
+        if( err )
+        {
+                vfs_close( &file , NULL );
+                this->info.errno = err;
+        }
+        rwlock_unlock( &process->cwd_lock );
+        CPU_HW_TRACE(sys_creat);
+        return fd;
+    return sys_open( pathname , flags , mode );
+}

trunk/kernel/syscalls/sys_exec.c

-                      r14
+                      r23
 /*
  * sys_exec.c - Kernel function implementing the "exec" syscall
+ * sys_exec.c - Kernel function implementing the "exec" system call.
+ *
+ * Authors    Mohamed Lamine Karaoui (2015)
+ *            Alain Greiner          (2016)
+ * Authors   Alain Greiner (2016,2017)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
 #include <kernel_config.h>
 #include <hal_types.h>
+#include <hal_uspace.h>
 #include <errno.h>
 #include <printk.h>
 …
     // get string length
+        hal_strlen_from_uspace( pathname , &length );
+        if( length > 255 )
+    {
+        printk(ERROR, "%s: elf file pathname larger than 255 bytes\n", __FUNCTION__ );
+        return EINVAL;
+    }
+        length = hal_strlen_from_uspace( pathname );
+        if( length >= CONFIG_VFS_MAX_PATH_LENGTH ) return EINVAL;
     // copy string to exec_info
 …
 // The max number of strings is 1024 (for both args and envs). The numbers of pages
 // to store the (args) and (envs) strings are configuration parameters.
 ////////////////////////////////////////////////i//////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////
 // @ exec_info : pointer on the exec_info structure.
 // @ is_args   : true if called for (args) / false if called for (envs).
 …
     uint32_t     found_null;  // NULL pointer found in array of pointers
     uint32_t     length;      // string length
-    uint32_t     strings;     // actual number of strings
     kmem_req_t   req;         // kmem request
     page_t     * page;        // page descriptor
     uint32_t     order;       // ln2( number of pages to store strings )
     char      ** k_pointers;  // base of kernel buffer containing array of pointers
     char       * buf_ptr;     // pointer on first empty slot in kernel strings buffer
     char       * buf_base;    // base address of the kernel strings buffer
+    char      ** k_pointers;  // base of kernel array of pointers
+    char       * k_buf_ptr;   // pointer on first empty slot in kernel strings buffer
+    char       * k_buf_base;  // base address of the kernel strings buffer
     // compute ln2( number of pages for kernel strings buffer )
     if( is_args ) order = CONFIG_PROCESS_ARGS_ORDER;
     else          order = CONFIG_PROCESS_ENVS_ORDER;
+    if( is_args ) order = bits_log2( CONFIG_VMM_ARGS_SIZE );
+    else          order = bits_log2( CONFIG_VMM_ENVS_SIZE );
         req.type   = KMEM_PAGE;
 …
     req.type   = 0;
     page       = kmem_alloc( &req );
+    if( page == NULL )
+    {
+        printk("ERROR in %s : cannot allocate memory for pointers\n", __FUNCTION__ );
+        return ENOMEM;
+    }
+    if( page == NULL ) return ENOMEM;
     k_pointers = ppm_page2base( page );
 …
     req.type   = order;
     page       = kmem_alloc( &req );
+    if( page == NULL )
+    {
+        printk("ERROR in %s : cannot allocate memory for strings\n", __FUNCTION__ );
+        return ENOMEM;
+    }
+    buf_base    = ppm_page2base( page );
+    if( page == NULL ) return ENOMEM;
+    k_buf_base = ppm_page2base( page );
     // copy the array of pointers to kernel buffer
 …
                           CONFIG_PPM_PAGE_SIZE );
     // scan local copy of array of pointers to copy the strings
+    // scan kernel array of pointers to copy the strings
     found_null = 0;
     buf_ptr    = buf_base;
+    k_buf_ptr  = k_buf_base;
     for( index = 0 ; index < 1024 ; index++ )
+    {
 …
         // compute string length
             hal_strlen_from_uspace( k_pointers[index] , &length );
+            length = hal_strlen_from_uspace( k_pointers[index] );
         // copy the user string to kernel buffer
         hal_copy_from_uspace( k_strings,
                               k_pointers[index];
+        hal_copy_from_uspace( k_buf_ptr,
+                              k_pointers[index],
                               length );
         // update k_pointer[index] entry
         k_pointers[index] = buf_ptr;
+        k_pointers[index] = k_buf_ptr;
         // increment pointer on kernel strings buffer
         buf_ptr += (length + 1);
+        k_buf_ptr += (length + 1);
+    }
 …
+    {
         exec_info->args_pointers  =  k_pointers;
         exec_info->args_buf_base  =  buf_base;
+        exec_info->args_buf_base  =  k_buf_base;
         exec_info->args_nr        =  index;
+    }
 …
+    {
         exec_info->envs_pointers  =  k_pointers;
         exec_info->envs_buf_base  =  buf_base;
         exec_info->envs_buf_free  =  buf_ptr;
+        exec_info->envs_buf_base  =  k_buf_base;
+        exec_info->envs_buf_free  =  k_buf_ptr;
         exec_info->envs_nr        =  index;
+    }
     else
+    {
-        printk("ERROR in %s : number of strings larger than 1024\n", __FUNCTION__ );
         return EINVAL;
+    }
 …
 } // end process_exec_get_strings()
-/////////////////////////////////////////////////////////////////////////////////////////
-// This function is executed in a "client" cluster by a process whose PID can belong
-// to another "server" cluster (defined by the MSB bits of the calling process PID).
-// A new process descriptor, and the associated main thread descriptor must be created
-// in the "server" cluster, using directly the process_make_exec() function if local,
-// or the rpc_process_exec_client() function if server is remote.
 /////////////////////////////////////////////////////////////////////////////////////////
 // Implementation note:
 …
 // It calls the static process_exec_get_path() and process_exec_get_strings() functions
 // to copy the .elf pathname, the main() arguments and the environment variables from
 // user buffers to the exec_info_t, and calls the static process_make_exec() function.
+// user buffers to the exec_info_t structure, and call the process_make_exec() function.
 /////////////////////////////////////////////////////////////////////////////////////////
 int sys_exec( char  * filename,     // .elf file pathname
               char ** argv,         // process arguments
               char ** envp )        // environment variables
+              char ** args,         // process arguments
+              char ** envs )        // environment variables
+{
     exec_info_t  exec_info;         // structure to pass to process_make_exec()
+    thread_t   * thread;            // pointer on thread created in server cluster
+        error_t      error   = 0;
+        process_t  * process = CURRENT_PROCESS;
+    // check arguments
+        if((filename == NULL) || (argv == NULL) || (envp == NULL))
+    {
+        printk("\n[ERROR] in %s : missing arguments / file = %x / argv = %x / envp = %x\n",
+               __FUNCTION__ , filename , argv , envp );
+        return EINVAL;
+        error_t      error;
+    paddr_t      paddr;
+    thread_t   * this    = CURRENT_THREAD;
+        process_t  * process = this->process;
+    // check argument fileme
+    error = vmm_v2p_translate( false , filename , &paddr );
+        if( error )
+    {
+        printk("\n[ERROR] in %s : filename unmapped\n", __FUNCTION__ );
+        this->errno = EINVAL;
+        return -1;
+    }
+    // check argument fileme
+    error = vmm_v2p_translate( false , args , &paddr );
+        if( error )
+    {
+        printk("\n[ERROR] in %s : args unmapped\n", __FUNCTION__ );
+        this->errno = EINVAL;
+        return -1;
+    }
+    // check argument fileme
+    error = vmm_v2p_translate( false , envs , &paddr );
+        if( error )
+    {
+        printk("\n[ERROR] in %s : envs unmapped\n", __FUNCTION__ );
+        this->errno = EINVAL;
+        return -1;
+    }
 …
                  cxy_client, cxy_server, hal_time_stamp());
-    // Change process's state to prevent any concurent access TODO ??? [AG]
     // initialize exec_info structure
     exec_info->pid      = process->pid;
     exec_info->ppid     = process->ppid;
     exec_info->fd_array = &process->fd_array;
     exec_info->vfs_root = &process->vfs_root;
     exec_info->vfs_cwd  = &process->vfs_cwd;
     exec_info->vfs_bin  = &process->vfs_bin;
+    exec_info.pid         = process->pid;
+    exec_info.ppid        = process->ppid;
+    exec_info.fd_array_xp = XPTR( local_cxy , &process->fd_array );
+    exec_info.vfs_root_xp = process->vfs_root_xp;
+    exec_info.vfs_cwd_xp  = process->vfs_cwd_xp;
+    exec_info.vfs_bin_xp  = process->vfs_bin_xp;
         // check pathname and store it in exec_info structure
         error = process_exec_get_path( &exec_info , filename );
+        if ( error ) return EINVAL;
+        // check and store argv in exec_info structure
+        error = process_exec_get_strings( &exec_info , true , argv );
+        if( error )  return EINVAL;
+        if ( error )
+    {
+        printk("\n[ERROR] in %s : elf pathname too long\n", __FUNCTION__ );
+        this->errno = error;
+        return -1;
+    }
+        // check and store args in exec_info structure
+        error = process_exec_get_strings( &exec_info , true , args );
+        if( error )
+    {
+        printk("\n[ERROR] in %s : cannot access args\n", __FUNCTION__ );
+        this->errno = error;
+        return -1;
+    }
+        // check and store envp in exec_info structure
+        error = process_exec_get_strings( &exec_info , false , envp );
+        if( error )  return EINVAL;
+        // check and store envs in exec_info structure
+        error = process_exec_get_strings( &exec_info , false , envs );
+        if( error )
+    {
+        printk("\n[ERROR] in %s : cannot access envs\n", __FUNCTION__ );
+        this->errno = error;
+        return -1;
+    }
+    if( is_local )  ////////////// local exec //////////////////////////
+    {
+        exec_dmsg("\n[INFO] %s starts local exec for process %x at cycle %d\n",
+                  __FUNCTION__, process->pid, hal_time_stamp());
+        // call directly the local process_make_exec() function
+        error = process_make_exec( &exec_info , &thread );
+        if error
+        {
+            printk("\n[ERROR] in %s : failed in local exec for process %x\n",
+                   __FUNCTION__ , process->pid );
+            return EINVAL;
+        }
+        exec_dmsg("\n[INFO] %s completes local exec for process %x at cycle %d\n",
+                  __FUNCTION__, process->pid , hal_time_stamp() );
+    }
+    else             ///////////// remote exec /////////////////////////
+    {
+        exec_dmsg("\n[INFO] %s starts remote exec for process %x at cycle %d\n",
+                  __FUNCTION__, process->pid, hal_time_stamp() );
+        // call the rpc_process_exec_client() function
+        rpc_process_exec_client( cxy_server , &exec_info , &thread , &error );
+        if( error )
+        {
+            printk("\n[ERROR] in %s : failed in remote exec for process %x\n",
+                   __FUNCTION__ , process->pid );
+            return EINVAL;
+        }
+        exec_dmsg("\n[INFO] %s completes remote exec for process %x at cycle %d\n",
+                  __FUNCTION__, process->pid , hal_time_stamp() );
+    }
+    // If no error, delete the current thread an process descriptors.
+    exec_dmsg("\n[INFO] %s starts exec for process %x at cycle %d\n",
+              __FUNCTION__, process->pid, hal_time_stamp() );
+    if( is_local )  error = process_make_exec( &exec_info );
+    else            rpc_process_exec_client( cxy_server , &exec_info , &error );
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot create new process %x\n",
+               __FUNCTION__ , process->pid );
+        this->errno = error;
+        return -1;
+    }
+    exec_dmsg("\n[INFO] %s completes exec for process %x at cycle %d\n",
+              __FUNCTION__, process->pid , hal_time_stamp() );
+    // delete the calling thread an process
     thread_kill( CURRENT_THREAD );
     process_kill( CURRENT_PROCESS );
+    process_kill( CURRENT_THREAD->process );
     return 0;
 } // end sys_exec()

trunk/kernel/syscalls/sys_fork.c

-                      r1
+                      r23
 /*
  * sys_fork.c - fork the current process
+ * sys_fork.c - Fork the current process.
+ *
+ * Authors  Ghassan Almaless (2008,2009,2010,2011,2012)
+ *          Mohamed Lamine Karaoui (2015)
+ *          Alain Greiner (2016)
+ * Authors  Alain Greiner  (2016,2017)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
  */
+#include <kernel_config.h>
+#include <hal_types.h>
+#include <hal_atomic.h>
 #include <errno.h>
 #include <config.h>
 #include <cpu.h>
+#include <printk.h>
+#include <core.h>
 #include <cluster.h>
-#include <event.h>
 #include <list.h>
 #include <thread.h>
 …
 #include <process.h>
+#if CONFIG_FORK_DEBUG
+#define fork_debug(...) printk(__VA_ARGS__)
+#else
+#define fork_debug(...) /**/
+#endif
+/***********************************************************************************************
+ * This kernel function implement the "fork" system call.
+ * The calling process descriptor (parent process), and the associated thread descriptor are
+ * replicated in the same cluster as the calling thread, but the new process (child process)
+ * is registered in another target cluster, that will become the process owner.
+ * The child process and the associated main thread will be migrated to the target cluster
+ * later, when the child process makes an "exec" or any other system call.
+ * The target cluster depends on the "fork_user" flag and "fork_cxy" variable that can be
+ * stored in the calling thread descriptor by the specific fork_place() system call.
+ * If not, the sys_fork() function makes a query to the DQDT to select the target cluster.
+ * @ returns child process PID if success / returns -1 if failure
+ **********************************************************************************************/
+int sys_fork();
+//////////////
+int sys_fork()
+{
         process_t          * parent_process;  // pointer on parent process descriptor
 …
         thread_t           * child_thread;    // pointer on child main thread descriptor
     trdid_t              child_trdid;     // child main thread identifier
-    core_t             * child_core;      // pointer on core for child main thread
     lid_t                child_core_lid;  // core local index for the child main thread
     cxy_t                target_cxy;      // final target cluster for forked child process
         error_t              error;
-    cluster_t          * parent_cluster = LOCAL_CLUSTER;
     // get pointers on parent process and thread
         parent_thread  = CURRENT_THREAD;
         parent_process = parent_thread->process;
+    parent_pid     = parent_process->pid;
     // check parent process children number
         if( hal_atomic_add( &parent_process->childs_nr , 1 ) >= CONFIG_PROCESS_CHILDS_MAX_NR )
+        {
             printk("ERROR in %s : too much children processes\n", __FUNCTION__);
             hal_atomic_add ( &parent_process->childs_nr , -1 );
         return EAGAIN;
+        }
         fork_debug("INFO : %s enters for process %d at cycle [%d]\n",
+        if( hal_atomic_add( &parent_process->children_nr , 1 ) >= CONFIG_PROCESS_MAX_CHILDREN )
+        {
+            printk("\n[ERROR] in %s : too much children processes\n", __FUNCTION__);
+            hal_atomic_add ( &parent_process->children_nr , -1 );
+        return EAGAIN;
+        }
+        fork_dmsg("\n[INFO] %s : enters for process %d at cycle [%d]\n",
                   __FUNCTION__, parent_process->pid, hal_time_stamp());
 …
+        {
                 hal_fpu_context_save( parent_thread );
                 fork_debug("INFO : %s save FPU\n", __FUNCTION__);
+                fork_dmsg("\n[INFO] %s : save FPU\n", __FUNCTION__);
+        }
     // Select target cluster for future migration of child process and main thread.
     // The placement can be specified by user. If placement is not user-defined,
     // the placement is defined by the DQDT.
+    // The two first processes ("init" and "sh") on boot cluster will not migrate.
         if( parent_threads->fork_user )
+    // If placement is not user-defined, the placement is defined by the DQDT.
+    // The two first processes ("init" and "sh") on boot cluster do not migrate.
+        if( parent_thread->fork_user )
+        {
         // user defined placement
+        target_cxy = parent->thread.fork_cxy;
+        parent->thread.fork_cxy = false;
+        }
+    else if( (LPID_FROM_PID(parent_process->pid) < 2 )
+             && ( parent_cluster->cxy == parent_cluster->boot_cxy ) )
+        target_cxy = parent_thread->fork_cxy;
+        parent_thread->fork_user = false;
+        }
+    else if( (LPID_FROM_PID(parent_process->pid) < 2)  && (local_cxy == 0) )
+    {
         // 2 first process stay in boot cluster
         target_cxy = parent_cluster->cxy;
+        target_cxy = local_cxy;
+    }
         else
 …
+        }
         fork_debug("INFO : %s select target_cluster = %x\n",
+        fork_dmsg("INFO : %s select target_cluster = %x\n",
               __FUNCTION__ , target_cxy );
     // allocates memory in local cluster for the child process descriptor
         child_process = process_alloc();
         if( child_process == NULL )
+        {
+            printk("ERROR in %s : cannot allocate memory for child process\n", __FUNCTION__ );
+            hal_atomic_add ( &parent_process->childs_nr , -1 );
+        return EAGAIN;
+        }
+    // get a new PID for child process
+    // it requires an RPC if target cluster is remote
+    xptr_t xp = XPTR( target_cxy , child_process );
+    if( target_cxy == parent_cluster->cxy )   // local cluster
+    {
+        error = process_pid_alloc( xp , &child_pid );
+    }
+    else                            // remote cluster
+    {
+        rpc_process_pid_alloc_server( target_cxy , xp , &error , &child_pid );
+    }
+            printk("\n[ERROR] in %s : cannot allocate child process\n", __FUNCTION__ );
+            hal_atomic_add ( &parent_process->children_nr , -1 );
+        return EAGAIN;
+        }
+    // get a new PID for child process,
+    if( target_cxy == local_cxy )                // target cluster is local
+    {
+        error = cluster_pid_alloc( XPTR( target_cxy , child_process ) , &child_pid );
+    }
+    else                                         // target cluster is remote
+    {
+        rpc_process_pid_alloc_client( target_cxy , child_process , &error , &child_pid );
+    }
     if( error )
+    {
             printk("ERROR in %s : cannot allocate PID\n", __FUNCTION__ );
             atomic_add ( &parent_process->childs_nr , -1 );
+            printk("\n[ERROR] in %s : cannot allocate PID\n", __FUNCTION__ );
+            hal_atomic_add ( &parent_process->children_nr , -1 );
         process_destroy( child_process );
         return EAGAIN;
 …
     // initialize and register the child process descriptor
+    error = process_reference_init( child_process , child_pid , parent_pid );
+    if( error )
+    {
+            printk("ERROR in %s : cannot initialise child process\n", __FUNCTION__ );
+            atomic_add ( &parent_process->childs_nr , -1 );
+        process_destroy( child_process );
+        return EAGAIN;
+    }
+        fork_debug("INFO : %s created child process : pid = %x / ppid = %x\n",
+    process_reference_init( child_process , child_pid , parent_pid );
+        fork_dmsg("\n[INFO] : %s created child process : pid = %x / ppid = %x\n",
               __FUNCTION__, child_pid , parent_pid );
-    // set IS_REFERENCE flag in child process descriptor
-    child_process->flags = PDF_IS_REFERENCE;
     // initialises child process standard files structures
     // ( root / cwd / bin ) from parent process descriptor
+        spinlock_lock( &parent_process->cwd_lock );
+        vfs_file_count_up( &parent_process->vfs_root );
+        child_process->vfs_root = parent_process->vfs_root;
+        vfs_file_count_up( &parent_process->vfs_cwd );
+        child_process->vfs_cwd  = parent_process->vfs_cwd;
+        vfs_file_count_up( &parent_process->vfs_bin );
+    child_process->vfs_bin = parent_process->vfs_bin;
+        spinlock_unlock( &parent_process->cwd_lock );
+        vfs_file_count_up( parent_process->vfs_root_xp );
+        child_process->vfs_root_xp = parent_process->vfs_root_xp;
+        vfs_file_count_up( parent_process->vfs_cwd_xp );
+        child_process->vfs_cwd_xp  = parent_process->vfs_cwd_xp;
+        vfs_file_count_up( parent_process->vfs_bin_xp );
+    child_process->vfs_bin_xp = parent_process->vfs_bin_xp;
+    // copy the parent process fd_array to the child process fd_array
+        process_fd_remote_copy( XPTR( local_cxy , &child_process->fd_array ),
+                            XPTR( local_cxy , &parent_process->fd_array ) );
+        fork_dmsg("\n[INFO] %s : duplicated child process from parent process\n",
+                  __FUNCTION__ );
+    // replicates virtual memory manager
+        error = vmm_copy( child_process , parent_process );
+        if( error )
+    {
+            printk("\n[ERROR] in %s : cannot duplicate VMM\n", __FUNCTION__ );
+            hal_atomic_add ( &parent_process->children_nr , -1 );
+        process_destroy( child_process );
+        return ENOMEM;
+    }
+    // copy the parent process fd_array to the child process fd_array
+        process_fd_fork( child_process , parent_process );
+    // initialise child process signal manager TODO ???
+        signal_manager_init( child_process );
+        fork_debug("INFO : %s duplicated child process from parent process\n",
+                  __FUNCTION__ );
+    // replicates virtual memory manager
+        error = vmm_dup( &child_process->vmm , &parent_process->vmm );
+        fork_dmsg("\n[INFO] %s : parent vmm duplicated in child process\n", __FUNCTION__ );
+    // create child main thread descriptor in local cluster
+    error = thread_user_fork( parent_process , &child_thread );
         if( error )
+    {
+            printk("ERROR in %s : cannot duplicate VMM\n", __FUNCTION__ );
+            atomic_add ( &parent_process->childs_nr , -1 );
+        process_destroy( child_process );
+        return EAGAIN;
+    }
+        fork_debug("INFO : %s: parent vmm duplicated in child process\n", __FUNCTION__ );
+    // create child main thread descriptor in local cluster TODO stack ???
+    error = thread_user_fork( &child_thread , process , parent_thread );
+        if( error )
+    {
+            printk("ERROR in %s : cannot duplicate thread\n", __FUNCTION__ );
+            atomic_add ( &parent_process->childs_nr , -1 );
+        process_destroy( child_process );
+        return EAGAIN;
+            printk("\n[ERROR] in %s : cannot duplicate thread\n", __FUNCTION__ );
+            hal_atomic_add( &parent_process->children_nr , -1 );
+        process_destroy( child_process );
+        return ENOMEM;
+    }
     // register child thread in child process, and get a TRDID
     spinlock_lock( &child->process->th_lock );
     error = process_register_thread( child->process, child->thread , &child_trdid );
     spinlock_unlock( &process->th_lock );
+    spinlock_lock( &child_process->th_lock );
+    error = process_register_thread( child_process, child_thread , &child_trdid );
+    spinlock_unlock( &child_process->th_lock );
     if( error )
+    {
         printk("ERROR in %s : cannot register thread\n", __FUNCTION__ );
             atomic_add ( &parent_process->childs_nr , -1 );
+        printk("\n[ERROR] in %s : cannot register thread\n", __FUNCTION__ );
+            hal_atomic_add ( &parent_process->children_nr , -1 );
         thread_destroy( child_thread );
         process_destroy( child_process );
 …
         // Update child thread descriptor
         child_thread->core    = process->core_tbl[child_core_lid];
+        child_thread->core    = &LOCAL_CLUSTER->core_tbl[child_core_lid];
         child_thread->process = child_process;
     child_thread->trdid   = chid_trdid;
         fork_debug("INFO : %s initialised child main thread\n", __FUNCTION__ );
+    child_thread->trdid   = child_trdid;
+        fork_dmsg("\n[INFO] %s : initialised child main thread\n", __FUNCTION__ );
     // register local child thread into local child process th_tbl[]
     // we don't use the th_lock because there is no concurrent access
     ltid_t ltid = LTID_FROM_TRDID( trdid );
         child_process->th_tbl[ltid] = XPTR( local_cxy , child_thread );
         child_process->threads_nr = 1;
+    ltid_t ltid = LTID_FROM_TRDID( child_trdid );
+        child_process->th_tbl[ltid] = child_thread;
+        child_process->th_nr = 1;
     // register child thread in scheduler
         sched_register( child_thread->core , child_thread );
+        sched_register_thread( child_thread->core , child_thread );
         fork_debug("INFO : %s registered main thread in scheduler\n", __FUNCTION__);
+        fork_dmsg("\n[INFO] %s : registered main thread in scheduler\n", __FUNCTION__);
         // update DQDT for the child thread
     dqdt_update_threads_number( 1 );
         fork_debug("INFO :%s completed / parent pid = %x / child pid = %x / at cycle [%d]\n",
+    dqdt_local_update_threads( 1 );
+        fork_dmsg("\n[INFO] %s : completed / parent pid = %x / child pid = %x / at cycle [%d]\n",
                   __FUNCTION__, parent_process->pid, child_process->pid, hal_time_stamp() );

trunk/kernel/syscalls/sys_getcwd.c

-                      r1
+                      r23
 /*
  * kern/sys_getcwd.c - get process current work directory
+ * sys_getcwd.c - get process current work directory
+ *
+ * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
+ * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ * Author    Alain Greiner (2016,2017)
+ *
  * This file is part of ALMOS-kernel.
+ * Copyright (c)  UPMC Sorbonne Universites
+ *
+ * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * This file is part of ALMOS-MKH.
+ *
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
+#include <libk.h>
+#include <kernel_config.h>
+#include <hal_types.h>
+#include <hal_uspace.h>
+#include <hal_special.h>
+#include <errno.h>
 #include <vfs.h>
+#include <sys-vfs.h>
+#include <task.h>
+#include <kmem.h>
+#include <ppm.h>
+#include <vmm.h>
+#include <process.h>
 #include <thread.h>
+#include <printk.h>
 /* TODO: user page need to be locked as long as its region */
+/* TODO: user page(s) need to be locked  [AG] */
+int sys_getcwd (char *buff, size_t size)
+////////////////////////////////
+int sys_getcwd ( char     * buf,
+                 uint32_t   nbytes )
+{
+        register struct thread_s *this;
+        register struct task_s *task;
+        register error_t err;
+        struct ku_obj ku_buff;
+        error_t    error;
+    paddr_t    paddr;
+    char       kbuf[CONFIG_VFS_MAX_PATH_LENGTH];
         this      = current_thread;
         task      = current_task;
+        thread_t  * this    = CURRENT_THREAD;
+    process_t * process = this->process;
+        if((size < VFS_MAX_NAME_LENGTH) || (!buff))
+    // check buffer size
+        if( nbytes < CONFIG_VFS_MAX_PATH_LENGTH )
+        {
+                err = ERANGE;
+                goto SYS_GETCWD_ERROR;
+        printk("\n[ERROR] in %s : buffer too small\n", __FUNCTION__ );
+                this->errno = ERANGE;
+        return -1;
+        }
+        if(vmm_check_address("usr cwd buffer", task, buff, size))
+    // check buffer in user space
+    error = vmm_v2p_translate( false , buf , &paddr );
+        if( error )
+        {
+                err = EFAULT;
+                goto SYS_GETCWD_ERROR;
+        printk("\n[ERROR] in %s : user buffer unmapped\n", __FUNCTION__ );
+                this->errno = EFAULT;
+        return -1;
+        }
+        KU_SZ_BUFF(ku_buff, buff, size);
+    // get reference process cluster and local pointer
+    xptr_t      ref_xp  = process->ref_xp;
+    cxy_t       ref_cxy = GET_CXY( ref_xp );
+    process_t * ref_ptr = (process_t *)GET_PTR( ref_xp );
+        rwlock_rdlock(&task->cwd_lock);
+    // get CWD lock in read mode
+        remote_rwlock_rd_lock( XPTR( ref_cxy , &ref_ptr->cwd_lock ) );
+        err = vfs_get_path(&task->vfs_cwd, &ku_buff);
+    // call relevant VFS function
+        error = vfs_get_path( XPTR( ref_cxy , &ref_ptr->vfs_cwd_xp ) ,
+                          kbuf , CONFIG_VFS_MAX_PATH_LENGTH );
+        rwlock_unlock(&task->cwd_lock);
+    // release CWD lock
+        remote_rwlock_rd_unlock( XPTR( ref_cxy , &ref_ptr->cwd_lock ) );
+    // copy kernel buffer to user space
+    hal_copy_to_uspace( buf , kbuf , CONFIG_VFS_MAX_PATH_LENGTH );
+SYS_GETCWD_ERROR:
+        this->info.errno = err;
+        return (int)buff;
+}
+    hal_wbflush();
+        return 0;
+}  // end sys_getcwd()

trunk/kernel/syscalls/sys_getpid.c

-                      r1
+                      r23
  * kern/sys_getpid.c - get process id
+ *
+ * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
+ * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ * Author     Alain Greiner  (2016,2017)
+ *
  * This file is part of ALMOS-kernel.
+ * Copyright (c) UPMC Sorbonne Universites
+ *
+ * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * This file is part of ALMOS-MKH.
+ *
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
-#include <task.h>
 #include <thread.h>
+////////////////
 int sys_getpid()
+{
         return current_task->pid;
+        return CURRENT_THREAD->process->pid;
+}

trunk/kernel/syscalls/sys_gettimeofday.c

-                      r1
+                      r23
 /*
+ * sys_gettimeofday: get current time
+ *
+ * Copyright (c) 2015 UPMC Sorbonne Universites
+ * sys_gettimeofday.c - Get current time
+ *
  * This file is part of ALMOS-kernel.
+ * Author    Alain Greiner (2016,2017)
+ *
+ * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * Copyright (c) UPMC Sorbonne Universites
+ *
+ * This file is part of ALMOS-MKH.
+ *
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
+#include <cpu.h>
+#include <hal_types.h>
+#include <hal_uspace.h>
 #include <thread.h>
+#include <printk.h>
+#include <errno.h>
+#include <process.h>
+#include <vmm.h>
+#include <core.h>
 #include <time.h>
+int sys_gettimeofday(struct timeval *tv, struct timezone *tz)
+///////////////////////////////////////////
+int sys_gettimeofday( struct timeval  * tv,
+                      struct timezone * tz )
+{
+        error_t err;
+        uint_t tm_ms, tm_us;
+        struct timeval time;
+        error_t        error;
+    paddr_t        paddr;
+        if((tv == NULL) || NOT_IN_USPACE(tv) || NOT_IN_USPACE(tv+sizeof(*tv)))
+        {
+                err = EINVAL;
+                goto fail_inval;
+        }
+        uint32_t       tm_s;
+    uint32_t       tm_us;
+        if(tz)
+                return ENOTSUPPORTED;
+        struct timeval k_tv;
+        cpu_get_time(current_cpu, &tm_ms, &tm_us);
+        time.tv_sec = tm_ms/1000;
+        time.tv_usec = ((tm_ms%1000)*1000)+tm_us;
+        thread_t  *    this    = CURRENT_THREAD;
+        process_t *    process = this->process;
+        //printk(INFO, "%s: [%d] (%u ms) sec %u, usec %u\n", __FUNCTION__,
+        //current_cpu->gid, tm_ms, (uint32_t)time.tv_sec, (uint32_t)time.tv_usec);
+    // check tz (non supported / must be null)
+    if( tz )
+    {
+        printk("\n[ERROR] in %s for thread %x in process %x : tz argument must be NULL\n",
+               __FUNCTION__ , this->trdid , process->pid );
+        this->errno = EINVAL;
+        return -1;
+    }
+    // check tv
+    error = vmm_v2p_translate( false , tv , &paddr );
+        err    = cpu_copy_to_uspace(tv, &time, sizeof(time));
+    if( error )
+    {
+        printk("\n[ERROR] in %s for thread %x in process %x : tv argument unmapped\n",
+        __FUNCTION__ , this->trdid , process->pid );
+        this->errno = EINVAL;
+        return -1;
+    }
+fail_inval:
+        current_thread->info.errno = err;
+        return err;
+}
+    // get time from calling core descriptor
+    core_get_time( this->core , &tm_s , &tm_us );
+        k_tv.tv_sec  = tm_s;
+        k_tv.tv_usec = tm_us;
+    // copy values to user space
+        hal_copy_to_uspace( tv , &k_tv , sizeof(struct timeval) );
+    hal_wbflush();
+        return 0;
+}  // end sys_timeofday()

trunk/kernel/syscalls/sys_lseek.c

-                      r1
+                      r23
  */
+#include <types.h>
+#include <kernel_config.h>
+#include <hal_types.h>
+#include <hal_uspace.h>
+#include <errno.h>
 #include <vfs.h>
+#include <vmm.h>
 #include <thread.h>
 #include <sys-vfs.h>
 #include <task.h>
+#include <printk.h>
+#include <process.h>
+int sys_lseek (uint_t fd, off_t offset, int whence)
+////////////////////////////////
+int sys_lseek (uint32_t file_id,
+               uint32_t offset,
+               uint32_t whence )
+{
+        error_t err = 0;
+        size_t new_offset;
+        struct thread_s *this;
+        struct task_s *task;
+        struct vfs_file_s *file;
+        error_t    error;
+    xptr_t     file_xp;
+    uint32_t   new_offset;
+        file = NULL;
+        this = current_thread;
+        task = current_task;
+        thread_t  * this    = CURRENT_THREAD;
+        process_t * process = this->process;
+    // check file_id argument
+        if( file_id >= CONFIG_PROCESS_FILE_MAX_NR )
+        {
+        printk("\n[ERROR] in %s : illegal file descriptor index = %d\n",
+               __FUNCTION__ , file_id );
+                this->errno = EBADFD;
+                return -1;
+        }
+    // get extended pointer on remote file descriptor
+    file_xp = process_fd_get_xptr( process , file_id );
+    if( file_xp == XPTR_NULL )
+    {
+        printk("\n[ERROR] in %s : undefined file descriptor index = %d\n",
+               __FUNCTION__ , file_id );
+                this->errno = EBADFD;
+                return -1;
+    }
         /* FIXME: file may be closed in parallel
          * of seek/read/write/mmap ..etc
          * so file may be NULL or invalid */
+        if((fd >= CONFIG_TASK_FILE_MAX_NR) || (task_fd_lookup(task, fd, &file)))
+    // call relevant VFS function
+        error = vfs_lseek( file_xp , offset , whence , &new_offset );
+        if( error )
+        {
+                this->info.errno = EBADFD;
+                return -1;
+        }
+        if((err = vfs_lseek(file, offset, whence, &new_offset)))
+        {
+                this->info.errno = (err < 0) ? -err : err;
+        printk("\n[ERROR] in %s : cannot seek file = %d\n",
+               __FUNCTION__ , file_id );
+                this->errno = error;
                 return -1;
+        }

trunk/kernel/syscalls/sys_mkdir.c

-                      r1
+                      r23
 /*
  * kern/sys_mkdir.c - creates new directory
+ * sys_mkdir.c - Create a new directory
+ *
+ * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
+ * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ * Author    Alain Greiner (2016,2017)
+ *
  * This file is part of ALMOS-kernel.
+ * Copyright (c) UPMC Sorbonne Universites
+ *
+ * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * This file is part of ALMOS-MKH.
+ *
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
+#include <hal_types.h>
+#include <hal_uspace.h>
 #include <vfs.h>
+#include <sys-vfs.h>
+#include <task.h>
+#include <vmm.h>
+#include <errno.h>
+#include <process.h>
 #include <thread.h>
+#include <printk.h>
+int sys_mkdir (char *pathname, uint_t mode)
+///////////////////////////////////
+int sys_mkdir( char     * pathname,
+               uint32_t   mode )
+{
+        register error_t err = 0;
+        struct task_s *task = current_task;
+        struct ku_obj ku_path;
+        error_t        error;
+    paddr_t        paddr;
+    uint32_t       length;
+    char           kbuf[CONFIG_VFS_MAX_PATH_LENGTH];
         KU_BUFF(ku_path, pathname);
         rwlock_rdlock(&task->cwd_lock);
+        thread_t     * this     = CURRENT_THREAD;
+        process_t    * process  = this->process;
+        if((err = vfs_mkdir(&task->vfs_cwd, &ku_path, mode)))
+    // check pathname in user space
+    error = vmm_v2p_translate( false , pathname , &paddr );
+        if( error )
+        {
+                current_thread->info.errno = (err < 0) ? -err : err;
+                rwlock_unlock(&task->cwd_lock);
+        printk("\n[ERROR] in %s : user buffer unmapped  for thread %x in process %x\n",
+               __FUNCTION__ , this->trdid , process->pid );
+                this->errno = EINVAL;
+                return -1;
+        }
+    // check fd_array not full
+        if( process_fd_array_full() )
+        {
+        printk("\n[ERROR] in %s : file descriptor array full for process %x\n",
+               __FUNCTION__ , process->pid );
+                this->errno = ENFILE;
+        return -1;
+        }
+    // get pathname length
+    length = hal_strlen_from_uspace( pathname );
+    if( length >= CONFIG_VFS_MAX_PATH_LENGTH )
+    {
+        printk("\n[ERROR] in %s : pathname too long\n", __FUNCTION__ );
+                this->errno = ENFILE;
+        return -1;
+    }
+        // get pathname copy in kernel space
+    hal_copy_from_uspace( kbuf, pathname, length );
+    // 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 );
+    // get extended pointer on cwd inode
+    xptr_t cwd_xp = hal_remote_lwd( XPTR( ref_cxy , &ref_ptr->vfs_cwd_xp ) );
+    // get the cwd lock in read mode from reference process
+        remote_rwlock_rd_lock( XPTR( ref_cxy , &ref_ptr->cwd_lock ) );
+    // call the relevant VFS function
+        error = vfs_mkdir( cwd_xp,
+                       kbuf,
+                       mode );
+    // release the cwd lock
+        remote_rwlock_rd_unlock( XPTR( ref_cxy , &ref_ptr->cwd_lock ) );
+    if( error )
+        {
+        printk("\n[ERROR] in %s : cannot create directory %s\n",
+               __FUNCTION__ , kbuf );
+                this->errno = error;
                 return -1;
+        }
-        rwlock_unlock(&task->cwd_lock);
         return 0;
+}

trunk/kernel/syscalls/sys_mkfifo.c

-                      r1
+                      r23
 /*
  * kern/sys_mkfifo.c - creates a FIFO named file
+ * sys_mkfifo.c - creates a named FIFO file.
+ *
+ * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
+ * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ * Author    Alain Greiner (2016,2017)
+ *
  * This file is part of ALMOS-kernel.
+ * Copyright (c) UPMC Sorbonne Universites
+ *
+ * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * This file is part of ALMOS-MKH.
+ *
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
+#include <kdmsg.h>
+#include <hal_types.h>
+#include <hal_uspace.h>
+#include <printk.h>
 #include <vfs.h>
+#include <sys-vfs.h>
+#include <task.h>
+#include <process.h>
 #include <thread.h>
+int sys_mkfifo (char *pathname, uint_t mode)
+////////////////////////////////////
+int sys_mkfifo ( char    * pathname,
+                 uint32_t  mode )
+{
         register error_t err = 0;
+        struct task_s *task = current_task;
         struct ku_obj ku_path;
+    error_t        error;
+    uint32_t       length;                           // pathname length (bytes)
+    char           kbuf[CONFIG_VFS_MAX_PATH_LENGTH];
         current_thread->info.errno = ENOSYS;
         return -1;
+    thread_t  * this    = CURRENT_THREAD;
+        process_t * process = this->process;
+        KU_BUFF(ku_path, pathname);
+        rwlock_rdlock(&task->cwd_lock);
+        if((err = vfs_mkfifo(&task->vfs_cwd, &ku_path, mode)))
+        if( pathname == NULL )
+        {
+                printk(INFO, "INFO: sys_mkfifo: Thread %x, CPU %d, Error Code %d\n",
                        current_thread,
                        cpu_get_id(),
                        err);
+        printk("\n[ERROR] in %s : pathname is NULL\n", __FUNCTION__ );
+                this->errno = EINVAL;
+                return -1;
+        }
+                rwlock_unlock(&task->cwd_lock);
+    // check fd_array not full
+        if( process_fd_array_full() )
+        {
+        printk("\n[ERROR] in %s : file descriptor array full for process %x\n",
+               __FUNCTION__ , process->pid );
+                this->errno = ENFILE;
+        return -1;
+        }
+    // get pathname length
+    length = hal_strlen_from_uspace( pathname );
+    if( length >= CONFIG_VFS_MAX_PATH_LENGTH )
+    {
+        printk("\n[ERROR] in %s : pathname too long\n", __FUNCTION__ );
+                this->errno = ENFILE;
+        return -1;
+    }
+        // get pathname copy in kernel space
+    hal_copy_from_uspace( kbuf, pathname, length );
+    // 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 );
+    // get extended pointer on cwd inode
+    xptr_t cwd_xp = hal_remote_lwd( XPTR( ref_cxy , &ref_ptr->vfs_cwd_xp ) );
+    // get the cwd lock in read mode from reference process
+        remote_rwlock_rd_lock( XPTR( ref_cxy , &ref_ptr->cwd_lock ) );
+    // call the relevant VFS function
+        error = vfs_mkfifo( cwd_xp,
+                        kbuf,
+                        mode );
+    // release the cwd lock
+        remote_rwlock_rd_unlock( XPTR( ref_cxy , &ref_ptr->cwd_lock ) );
+    if( error )
+        {
+        printk("\n[ERROR] in %s : cannot create named FIFO %s\n",
+               __FUNCTION__ , kbuf );
+                this->errno = error;
                 return -1;
+        }
-        rwlock_unlock(&task->cwd_lock);
         return 0;
+}
+} // end sys_mkfifo()

trunk/kernel/syscalls/sys_mmap.c

-                      r1
+                      r23
 /*
+ * kern/sys_mmap.c - map files, memory or devices into process's
+ *                   virtual address space
+ * sys_mmap.c - map files, memory or devices into process virtual address space
+ *
  * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
  * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ * Authors       Ghassan Almaless (2008,2009,2010,2011,2012)
+ *               Alain Greiner (2016,2017)
+ *
  * This file is part of ALMOS-kernel.
+ * Copyright (c) UPMC Sorbonne Universites
+ *
+ * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * This file is part of ALMOS-MKH.
+ *
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
+#include <hal_types.h>
 #include <errno.h>
 #include <thread.h>
+#include <printk.h>
 #include <vfs.h>
-#include <sys-vfs.h>
 #include <process.h>
 #include <vmm.h>
 ///////////////////////////////////
 int sys_mmap( mmap_attr_t * mattr )
+int sys_mmap( mmap_attr_t * attr )
+{
+    printk("\n[WARNING] function %s not implemented\n", __FUNCTION__ );
+    return 0;
+/*
         error_t err;
         uint_t count;
 …
         file = NULL;
         if((err = cpu_copy_from_uspace(&attr, mattr, sizeof(mmap_attr_t))))
+        if((err = cpu_copy_from_uspace(&attr, attr, sizeof(mmap_attr_t))))
+        {
                 printk(INFO, "%s: failed, copying from uspace @%x\n",
                        __FUNCTION__,
                        mattr);
+                       attr);
                 this->info.errno = EFAULT;
 …
         else
+        {
                 /* FIXEME: possible concurent delete of file from another bugy thread closing it */
+                // FIXME: possible concurent delete of file from another bugy thread closing it
                 if((attr.fd >= CONFIG_TASK_FILE_MAX_NR) || (process_fd_lookup(process, attr.fd, &file)))
+                {
 …
         return (int)VM_FAILED;
+}
+*/
+}  // end sys_mmap()

trunk/kernel/syscalls/sys_mutex.c

-                      r15
+                      r23
 /*
  * kern/sys_rwlock.c - interface to access Read-Write locks service
+ * sys_mutex.c - Access a POSIX mutex.
+ *
+ * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
+ * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ * Author    Alain Greiner (2016,2017)
+ *
  * This file is part of ALMOS-kernel.
+ * Copyright (c) UPMC Sorbonne Universites
+ *
+ * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * This file is part of ALMOS-MKH.
+ *
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
+#include <types.h>
+#include <hal_types.h>
+#include <hal_special.h>
 #include <errno.h>
 #include <thread.h>
+#include <kmem.h>
+#include <task.h>
+#include <printk.h>
 #include <vmm.h>
 #include <kmagics.h>
 #include <rwlock.h>
+#include <syscalls.h>
+#include <remote_mutex.h>
+static inline bool_t isBadLock(struct rwlock_s *rwlock)
+{
+        return vmm_check_object(rwlock, struct rwlock_s, RWLOCK_ID);
+}
+/////////////////////////////////
+int sys_mutex( void     * vaddr,
+               uint32_t   operation,
+               uint32_t   attr )
+{
+        error_t    error;
+    paddr_t    paddr;
+int sys_rwlock(struct rwlock_s **rwlock, uint_t operation)
+{
+        kmem_req_t req;
+        struct rwlock_s *irwlock;
+        error_t err;
+        err = vmm_check_address("usr rwlock ptr",
+                                current_task,
+                                rwlock,
+                                sizeof(struct rwlock_s*));
+        if(err)
+                goto SYS_RWLOCK_END;
+    thread_t * this = CURRENT_THREAD;
+        if((err = cpu_copy_from_uspace(&irwlock, rwlock, sizeof(struct rwlock_s *))))
                 goto SYS_RWLOCK_END;
+        switch(operation)
+        {
+        case RWLOCK_INIT:
                 req.type  = KMEM_RWLOCK;
                 req.size  = sizeof(*irwlock);
+                req.flags = AF_USER;
+    // check vaddr in user vspace
+        error = vmm_v2p_translate( false , vaddr , &paddr );
+        if( error )
+    {
+        printk("\n[ERROR] in %s : illegal virtual address = %x\n",
+               __FUNCTION__ , (intptr_t)vaddr );
+        this->errno = error;
+        return -1;
+    }
+                if((irwlock = kmem_alloc(&req)) == NULL)
+                {
+                        err = ENOMEM;
+                        break;
+    // execute requested operation
+        switch( operation )
+        {
+        ////////////////
+            case MUTEX_INIT:
+        {
+            if( attr != 0 )
+            {
+                printk("\n[ERROR] in %s : mutex attributes non supported yet\n",
+                       __FUNCTION__ );
+                this->errno = error;
+                return -1;
+            }
+            error = remote_mutex_create( (intptr_t)vaddr );
+            if( error )
+            {
+                printk("\n[ERROR] in %s : cannot create mutex\n",
+                       __FUNCTION__ );
+                this->errno = error;
+                return -1;
+            }
+                    break;
+                }
+                if((err = rwlock_init(irwlock)))
+                        break;
+                if((err = cpu_copy_to_uspace(rwlock, &irwlock, sizeof(struct rwlock_s *))))
+                {
+                        req.ptr = irwlock;
+                        kmem_free(&req);
+                }
+                break;
+        ///////////////////
+            case MUTEX_DESTROY:
+        {
+            xptr_t mutex_xp = remote_mutex_from_ident( (intptr_t)vaddr );
+        case RWLOCK_WRLOCK:
+                if(isBadLock(irwlock))
+                        break;
+                return rwlock_wrlock(irwlock);
+            if( mutex_xp == XPTR_NULL )     // user error
+            {
+                printk("\n[ERROR] in %s : mutex %x not registered\n",
+                       __FUNCTION__ , (intptr_t)vaddr );
+                this->errno = EINVAL;
+                return -1;
+            }
+            else                          // success
+            {
+                remote_mutex_destroy( mutex_xp );
+            }
+            break;
+        }
+        ////////////////
+            case MUTEX_LOCK:
+        {
+            xptr_t mutex_xp = remote_mutex_from_ident( (intptr_t)vaddr );
+        case RWLOCK_RDLOCK:
+                if(isBadLock(irwlock))
+                        break;
+                return rwlock_rdlock(irwlock);
+            if( mutex_xp == XPTR_NULL )     // user error
+            {
+                printk("\n[ERROR] in %s : mutex %x not registered\n",
+                       __FUNCTION__ , (intptr_t)vaddr );
+                this->errno = EINVAL;
+                return -1;
+            }
+            else                          // success
+            {
+                remote_mutex_lock( mutex_xp );
+            }
+            break;
+        }
+        //////////////////
+            case MUTEX_UNLOCK:
+        {
+            xptr_t mutex_xp = remote_mutex_from_ident( (intptr_t)vaddr );
+        case RWLOCK_TRYWRLOCK:
+                if(isBadLock(irwlock))
+                        break;
+                return rwlock_trywrlock(irwlock);
+        case RWLOCK_TRYRDLOCK:
+                if(isBadLock(irwlock))
+                        break;
+                return rwlock_tryrdlock(irwlock);
+        case RWLOCK_UNLOCK:
+                if(isBadLock(irwlock))
+                        break;
+                if((err = rwlock_unlock(irwlock)))
+                        break;
+        case RWLOCK_DESTROY:
+                if(isBadLock(irwlock))
+                        break;
+                if((err = rwlock_destroy(irwlock)))
+                        break;
+                req.type = KMEM_RWLOCK;
+                req.ptr  = irwlock;
+                kmem_free(&req);
+                return 0;
+        default:
+                err = EINVAL;
+            if( mutex_xp == XPTR_NULL )     // user error
+            {
+                printk("\n[ERROR] in %s : mutex %x not registered\n",
+                       __FUNCTION__ , (intptr_t)vaddr );
+                this->errno = EINVAL;
+                return -1;
+            }
+            else                          // success
+            {
+                remote_mutex_unlock( mutex_xp );
+            }
+            break;
+        }
+        ////////
+            default:
+        {
+            printk("\n[PANIC] in %s : illegal operation type\n", __FUNCTION__ );
+                    hal_core_sleep();
+        }
+        }
+SYS_RWLOCK_END:
+        current_thread->info.errno = err;
+        return err;
+}
+        return 0;
+KMEM_OBJATTR_INIT(rwlock_kmem_init)
+{
+        attr->type   = KMEM_RWLOCK;
+        attr->name   = "KCM RWLOCK";
+        attr->size   = sizeof(struct rwlock_s);
+        attr->aligne = 0;
+        attr->min    = CONFIG_RWLOCK_MIN;
+        attr->max    = CONFIG_RWLOCK_MAX;
+        attr->ctor   = NULL;
+        attr->dtor   = NULL;
+        return 0;
+}
+}  // end sys_mutex()

trunk/kernel/syscalls/sys_open.c

-                      r1
+                      r23
 /*
  * kern/sys_open.c - open a named file
+ * sys_open.c - open a file.
+ *
+ * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
+ * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ * Author        Alain Greiner (2016,2017)
+ *
  * This file is part of ALMOS-kernel.
+ * Copyright (c) UPMC Sorbonne Universites
+ *
+ * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * This file is part of ALMOS-MKH.
+ *
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
+#include <kernel_config.h>
+#include <hal_types.h>
+#include <hal_uspace.h>
 #include <errno.h>
 #include <thread.h>
+#include <printk.h>
 #include <vfs.h>
-#include <sys-vfs.h>
 #include <process.h>
 #include <spinlock.h>
 #include <cpu-trace.h>
+#include <remote_spinlock.h>
+#include <remote_rwlock.h>
 ///////////////////////////////////
 …
                uint32_t   mode )
+{
-        CPU_HW_TRACE(sys_open);
+        error_t            err;
+        struct vfs_file_s  file;
+        struct ku_obj      ku_path;
+        thread_t         * this     = current_thread;
+        process_t        * process  = current_process;
+        uint32_t           fd       = (uint32_t)-1;
+        error_t        error;
+        xptr_t         file_xp;                          // extended pointer on vfs_file_t
+        uint32_t       file_id;                          // file descriptor index
+    uint32_t       length;                           // pathname length (bytes)
+    char           kbuf[CONFIG_VFS_MAX_PATH_LENGTH];
+        cpu_trace_write(current_cpu, sys_open);
+        thread_t     * this     = CURRENT_THREAD;
+        process_t    * process  = this->process;
         if( process_fd_aray_full( process ) )
+        if( pathname == NULL )
+        {
+                this->info.errno = ENFILE;
+        CPU_HW_TRACE(sys_open);
+        return fd;
+        printk("\n[ERROR] in %s : pathname is NULL\n", __FUNCTION__ );
+                this->errno = EINVAL;
+                return -1;
+        }
+    // check fd_array not full
+        if( process_fd_array_full() )
+        {
+        printk("\n[ERROR] in %s : file descriptor array full for process %x\n",
+               __FUNCTION__ , process->pid );
+                this->errno = ENFILE;
+        return -1;
+        }
+        if( VFS_IS( flags , VFS_O_DIRECTORY ) ) VFS_SET( flags , VFS_DIR );
+    // get pathname length
+    length = hal_strlen_from_uspace( pathname );
+        KU_BUFF( ku_path , pathname );
+    if( length >= CONFIG_VFS_MAX_PATH_LENGTH )
+    {
+        printk("\n[ERROR] in %s : pathname too long\n", __FUNCTION__ );
+                this->errno = ENFILE;
+        return -1;
+    }
+        // get pathname copy in kernel space
+    hal_copy_from_uspace( kbuf, pathname, length );
+    // get the cwd lock
+        rwlock_rdlock( &process->cwd_lock );
+    // 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 );
+    // get extended pointer on cwd inode
+    xptr_t cwd_xp = hal_remote_lwd( XPTR( ref_cxy , &ref_ptr->vfs_cwd_xp ) );
+        err = vfs_open( &process->vfs_cwd , &ku_path , flags , mode , &file );
+        if( err )
+    // get the cwd lock in read mode from reference process
+        remote_rwlock_rd_lock( XPTR( ref_cxy , &ref_ptr->cwd_lock ) );
+    // call the relevant VFS function
+        error = vfs_open( cwd_xp,
+                      kbuf,
+                      flags,
+                      mode,
+                      &file_xp,
+                      &file_id );
+    // release the cwd lock
+        remote_rwlock_rd_unlock( XPTR( ref_cxy , &ref_ptr->cwd_lock ) );
+        if( error )
+        {
+                this->info.errno = (err < 0 ) ? -err : err;
+            rwlock_unlock( &process->cwd_lock );
+            CPU_HW_TRACE(sys_open);
+            return fd;
+        }
+        err = process_fd_set( process , &file , &fd );
+        if( err )
+        {
+                vfs_close(&file, NULL);
+                this->info.errno = err;
+        printk("\n[ERROR] in %s : cannot create file descriptor\n", __FUNCTION__ );
+                this->errno = ENFILE;
+            return -1;
+        }
+        rwlock_unlock( &process->cwd_lock );
+        CPU_HW_TRACE(sys_open);
+        return fd;
+    // update local fd_array
+    remote_spinlock_lock( XPTR( local_cxy , &process->fd_array.lock ) );
+        process->fd_array.array[file_id] = file_xp;
+    remote_spinlock_unlock( XPTR( local_cxy , &process->fd_array.lock ) );
+        return file_id;
+}

trunk/kernel/syscalls/sys_opendir.c

-                      r1
+                      r23
 /*
  * kern/sys_opendir.c - open a directory
+ * sys_opendir.c - open a directory.
+ *
+ * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
+ * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ * Author        Alain Greiner (2016,2017)
+ *
  * This file is part of ALMOS-kernel.
+ * Copyright (c) UPMC Sorbonne Universites
+ *
+ * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * This file is part of ALMOS-MKH.
+ *
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
+#include <hal_types.h>
 #include <vfs.h>
+#include <sys-vfs.h>
+#include <process.h>
+#include <thread.h>
+#include <spinlock.h>
+#include <syscalls.h>
 ///////////////////////////////////
 int sys_opendir ( char * pathname )
+{
+        error_t             err;
+        struct vfs_file_s   file;
+        struct ku_obj       ku_path;
+        thread_t          * this    = current_thread;
+        process_t         * process = current_process;
+        uint32_t            fd        = (uint32_t)-1;
+        uint32_t            mode      = 0;
+        if( process_fd_array_full( process ) )
+        {
+                this->info.errno = ENFILE;
+            return fd;
+        }
+        uint32_t   mode  = 0;
+    uint32_t   flags = O_DIR;
+        KU_BUFF(ku_path, pathname);
+        rwlock_rdlock( &process->cwd_lock );
+        err = vfs_opendir( &process->vfs_cwd , &ku_path , mode , &file );
+        if( err )
+        {
+                this->info.errno = (err < 0 ) ? -err : err;
+            rwlock_unlock( &process->cwd_lock );
+            return fd;
+        }
+        err = process_fd_set( process , &file , &fd);
+        if( err )
+        {
+                vfs_close(&file, NULL);
+                this->info.errno = err;
+        }
+        rwlock_unlock( &process->cwd_lock );
+        return fd;
+    return sys_open( pathname , flags , mode );
+}

trunk/kernel/syscalls/sys_pipe.c

-                      r1
+                      r23
 /*
  * kern/sys_pipe.c - open a pipe communication channel
+ * sys_pipe.c - open a pipe communication channel
+ *
+ * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
+ * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ * Author    Alain Greiner  (2016,1017)
+ *
  * This file is part of ALMOS-kernel.
+ * Copyright (c)  UPMC Sorbonne Universites
+ *
+ * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * This file is part of ALMOS-MKH.
+ *
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
+#include <hal_types.h>
 #include <vfs.h>
+#include <sys-vfs.h>
+#include <task.h>
+#include <process.h>
 #include <thread.h>
 #include <spinlock.h>
+#include <printk.h>
+int sys_pipe (uint_t *pipefd)
+//////////////////////////////////////
+int sys_pipe ( uint32_t * file_fd[2] )
+{
+        current_thread->info.errno = ENOSYS;
+        return -1;
+    thread_t * this = CURRENT_THREAD;
+    printk("\n[ERROR] in %d : not implemented yet\n", __FUNCTION__ );
+    this->errno = ENOSYS;
+    return -1;
+}

trunk/kernel/syscalls/sys_read.c

-                      r1
+                      r23
 /*
  * kern/sys_read.c - read bytes from an opened file
+ * sys_read.c - read bytes from a file
+ *
+ * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
+ * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ * Author     Alain Greiner (2016,2017)
+ *
  * This file is part of ALMOS-kernel.
+ * Copyright (c) UPMC Sorbonne Universites
+ *
+ * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * This file is part of ALMOS-MKH.
+ *
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
+#include <kernel_config.h>
+#include <hal_types.h>
+#include <hal_uspace.h>
+#include <hal_special.h>
 #include <errno.h>
+#include <vfs.h>
+#include <vmm.h>
 #include <thread.h>
+#include <vfs.h>
+#include <sys-vfs.h>
+#include <task.h>
+#include <printk.h>
+#include <process.h>
+int sys_read (uint_t fd, void *buf, size_t count)
+/* TODO: user page(s) need to be locked  [AG] */
+/////////////////////////////////
+int sys_read( uint32_t   file_id,
+              void     * buf,
+              uint32_t   count )
+{
+        struct ku_obj kub;
+        ssize_t err;
+        struct thread_s *this;
+        struct task_s *task;
+        struct vfs_file_s *file;
+    error_t      error;
+    paddr_t      paddr;
+    char         kbuf[CONFIG_VFS_KBUF_SIZE];
+        file = NULL;
+        this = current_thread;
+        task = current_task;
+        xptr_t       file_xp;     // remote file extended pointer
+    uint32_t     nbytes;      // number of bytes in one iteration
+        if((fd >= CONFIG_TASK_FILE_MAX_NR) || (task_fd_lookup(task, fd, &file)))
+        thread_t  *  this    = CURRENT_THREAD;
+        process_t *  process = this->process;
+    // check file_id argument
+        if( file_id >= CONFIG_PROCESS_FILE_MAX_NR )
+        {
+                this->info.errno = EBADFD;
+        printk("\n[ERROR] in %s : illegal file descriptor index = %d\n",
+               __FUNCTION__ , file_id );
+                this->errno = EBADFD;
                 return -1;
+        }
+        KU_SLICE_BUFF(kub, buf, count);
+        if((err = vfs_read(file, &kub)) < 0)
+    // check user buffer in user space
+    error = vmm_v2p_translate( false , buf , &paddr );
+    if ( error )
+    {
+        printk("\n[ERROR] in %s : user buffer unmapped = %x\n",
+               __FUNCTION__ , (intptr_t)buf );
+                this->errno = EINVAL;
+                return -1;
+    }
+    // get extended pointer on remote file descriptor
+    file_xp = process_fd_get_xptr( process , file_id );
+    if( file_xp == XPTR_NULL )
+    {
+        printk("\n[ERROR] in %s : undefined file descriptor index = %d\n",
+               __FUNCTION__ , file_id );
+        this->errno = EBADFD;
+        return -1;
+    }
+    // get file descriptor cluster and local pointer
+    vfs_file_t * file_ptr = (vfs_file_t *)GET_PTR( file_xp );
+    cxy_t        file_cxy = GET_CXY( file_xp );
+    // check file readable
+    uint32_t attr = hal_remote_lw( XPTR( file_cxy , &file_ptr->attr ) );
+    if( (attr & FD_ATTR_READ_ENABLE) == 0 )
+        {
+                this->info.errno = -err;
+                printk(INFO, "INFO: sys_read: Error %d\n", this->info.errno);
+        printk("\n[ERROR] in %s : file %d not readable\n",
+               __FUNCTION__ , file_id );
+                this->errno = EBADFD;
                 return -1;
+        }
+        return err;
+}
+    // transfer at most CONFIG_VFS_KBUF_SIZE bytes per iteration
+    while( count )
+    {
+        if( count <= CONFIG_VFS_KBUF_SIZE )
+        {
+            nbytes = count;
+            count  = 0;
+        }
+        else
+        {
+            nbytes = CONFIG_VFS_KBUF_SIZE;
+            count  = count - CONFIG_VFS_KBUF_SIZE;
+        }
+        // transfer nbytes to kernel buffer
+        error = vfs_move( true,               // read => (to_buffer = true)
+                          file_xp ,
+                          kbuf ,
+                          nbytes );
+        if( error )
+        {
+            printk("\n[ERROR] in %s cannot read data from file %d\n",
+                   __FUNCTION__ , file_id );
+            this->errno = error;
+            return -1;
+        }
+        // copy kernel buffer to user space
+        hal_copy_to_uspace( buf , kbuf , nbytes );
+    }
+    hal_wbflush();
+        return 0;
+}  // end sys_read()

trunk/kernel/syscalls/sys_readdir.c

-                      r1
+                      r23
 /*
+ * sys_read.c: read entries from an opened directory
+ *
+ * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
+ * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ * sys_readdir.c - Read one entry from an open directory.
+ *
  * This file is part of ALMOS-kernel.
+ * Author    Alain Greiner (2016,2017)
+ *
+ * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * Copyright (c) UPMC Sorbonne Universites
+ *
+ * This file is part of ALMOS-MKH.
+ *
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
+#include <kernel_config.h>
+#include <hal_types.h>
+#include <hal_uspace.h>
+#include <errno.h>
+#include <thread.h>
+#include <printk.h>
 #include <vfs.h>
+#include <sys-vfs.h>
+#include <task.h>
+#include <thread.h>
+#include <process.h>
+#include <syscalls.h>
+/* FIXEME: reading dirent from user without any protection */
+//////////////////////////////////////////
+int sys_readdir ( uint32_t       file_id,
+                  vfs_dirent_t * dirent )
+{
+        error_t        error;
+    paddr_t        paddr;
+        xptr_t         file_xp;    // extended pointer on searched directory file descriptor
+    vfs_dirent_t   k_dirent;   // kernel copy of dirent
+int sys_readdir (uint_t fd, struct vfs_usp_dirent_s *dirent)
+{
+        error_t err;
+        struct ku_obj dir;
+        struct task_s *task;
+        struct thread_s *this;
+        struct vfs_file_s *file;
+        file = NULL;
+        task = current_task;
+        this = current_thread;
+        thread_t     * this     = CURRENT_THREAD;
+        process_t    * process  = this->process;
+        if((dirent == NULL)                ||
+           (fd >= CONFIG_TASK_FILE_MAX_NR) ||
+           (task_fd_lookup(task, fd, &file)))
+    // check file_id argument
+        if( file_id >= CONFIG_PROCESS_FILE_MAX_NR )
+        {
+                this->info.errno = EBADFD;
+        printk("\n[ERROR] in %s : illegal file descriptor index\n", __FUNCTION__ );
+        this->errno = EBADFD;
                 return -1;
+        }
+        KU_OBJ(dir, dirent);
+        if((err = vfs_readdir(file, &dir)))
+    // check dirent structure in user space
+    error = vmm_v2p_translate( false , dirent , &paddr );
+    if ( error )
+    {
+        printk("\n[ERROR] in %s : user buffer for dirent unmapped = %x\n",
+               __FUNCTION__ , (intptr_t)dirent );
+                this->errno = EFAULT;
+                return -1;
+    }
+    // get extended pointer on remote file descriptor
+    file_xp = process_fd_get_xptr( process , file_id );
+    if( file_xp == XPTR_NULL )
+    {
+        printk("\n[ERROR] in %s : undefined file descriptor index = %d\n",
+               __FUNCTION__ , file_id );
+            this->errno = EBADFD;
+        return -1;
+    }
+    // call the relevant VFS function
+        error = vfs_readdir( file_xp , &k_dirent );
+        if( error )
+        {
+                this->info.errno = (err < 0) ? -err : err;
+        printk("\n[ERROR] in %s : cannot access directory %d\n",
+               __FUNCTION__ , file_id );
+                this->errno = error;
                 return -1;
+        }
+    // copy dirent to user space
+    hal_copy_to_uspace( dirent , &k_dirent , sizeof(vfs_dirent_t) );
         return 0;
+}
+}  // end sys_readdir()

trunk/kernel/syscalls/sys_rmdir.c

-                      r1
+                      r23
 /*
+ * sys_rmdir: remove a directory
+ * sys_rmdir.c - Remove a directory from file system.
+ *
+ * Author    Alain Greiner (2016,2017)
+ *
  * Copyright (c) 2015 UPMC Sorbonne Universites
+ *
  * This file is part of ALMOS-kernel.
+ * This file is part of ALMOS-MKH.
+ *
  * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
+#include <cpu.h>
+#include <hal_types.h>
+#include <hal_uspace.h>
+#include <printk.h>
+#include <errno.h>
 #include <vfs.h>
 #include <sys-vfs.h>
+#include <vmm.h>
 #include <thread.h>
 #include <task.h>
+#include <process.h>
+////////////////////////////////
+int sys_rmdir( char * pathname )
+{
+    error_t     error;
+    paddr_t     paddr;
+    uint32_t    length;
+    char        kbuf[CONFIG_VFS_MAX_PATH_LENGTH];
+        thread_t  * this    = CURRENT_THREAD;
+        process_t * process = this->process;
+int sys_rmdir (char *pathname)
+{
+        register struct thread_s *this;
+        register struct task_s *task;
+        struct ku_obj ku_path;
+        error_t err = 0;
+        this = current_thread;
+        task = current_task;
+    // check pathname in user space
+    error = vmm_v2p_translate( false , pathname , &paddr );
         if(!pathname)
+        if( error )
+        {
+                this->info.errno = EINVAL;
+        printk("\n[ERROR] in %s : user buffer unmapped  for thread %x in process %x\n",
+               __FUNCTION__ , this->trdid , process->pid );
+                this->errno = EINVAL;
+                return -1;
+        }
+    // get pathname length
+    length = hal_strlen_from_uspace( pathname );
+    if( length >= CONFIG_VFS_MAX_PATH_LENGTH )
+    {
+        printk("\n[ERROR] in %s : pathname too long\n", __FUNCTION__ );
+                this->errno = ENFILE;
+        return -1;
+    }
+        // get pathname copy in kernel space
+    hal_copy_from_uspace( kbuf, pathname, length );
+    // 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 );
+    // get extended pointer on cwd inode
+    xptr_t cwd_xp = hal_remote_lwd( XPTR( ref_cxy , &ref_ptr->vfs_cwd_xp ) );
+    // get the cwd lock in read mode from reference process
+        remote_rwlock_rd_lock( XPTR( ref_cxy , &ref_ptr->cwd_lock ) );
+    // call the relevant VFS function
+        error = vfs_rmdir( cwd_xp,
+                       kbuf );
+    // release the cwd lock
+        remote_rwlock_rd_unlock( XPTR( ref_cxy , &ref_ptr->cwd_lock ) );
+    if( error )
+        {
+        printk("\n[ERROR] in %s : cannot remove directory %s\n",
+               __FUNCTION__ , kbuf );
+                this->errno = error;
                 return -1;
+        }
+        return 0;
+        KU_BUFF(ku_path, pathname);
+        rwlock_wrlock(&task->cwd_lock);
+        if((err = vfs_rmdir(&current_task->vfs_cwd, &ku_path)))
+        {
+                current_thread->info.errno = (err < 0) ? -err : err;
+                rwlock_unlock(&task->cwd_lock);
+                return -1;
+        }
+        rwlock_unlock(&task->cwd_lock);
+        return 0;
+}
+}  // end sys_rmdir()

trunk/kernel/syscalls/sys_sem.c

-                      r1
+                      r23
  * sys_sem.c - Acces a POSIX unamed semaphore.
+ *
+ * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
+ * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ * Authors     Alain Greiner (2016,2017)
+ *
  * This file is part of ALMOS-kernel.
+ * Copyright (c) UPMC Sorbonne Universites
+ *
+ * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * This file is part of ALMOS-MKH.
+ *
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
 #include <hal_types.h>
+#include <hal_uspace.
+#include <hal_uspace.h>
+#include <errno.h>
+#include <thread.h>
+#include <printk.h>
+#include <vmm.h>
 #include <remote_sem.h>
+#include <syscalls.h>
 //////////////////////////////////
 …
+{
         uint32_t             data;
+        error_t              error;
+        paddr_t              paddr;
+    error_t              error;
+    thread_t           * this      = CURRENT_THREAD;
+        process_t          * process   = CURRENT_PROCESS;
+    thread_t           * this = CURRENT_THREAD;
     // check vaddr in user vspace
         error = vmm_check_address( process , vaddr , sizeof(unsigned long) );
         if( error )
+        error = vmm_v2p_translate( false , vaddr , &paddr );
+        if( error )
+    {
+        printk("\n[ERROR] in %s : illegal semaphore virtual address = %x\n",
+               __FUNCTION__ , (intptr_t)vaddr );
         this->errno = error;
         return -1;
 …
     // check value in user vspace
     error = vmm_check_address( process , value , sizeof(int*) );
         if( error )
+        error = vmm_v2p_translate( false , value , &paddr );
+        if( error )
+    {
+        printk("\n[ERROR] in %s : illegal argument virtual address = %x\n",
+               __FUNCTION__ , (intptr_t)value );
         this->errno = error;
         return -1;
 …
             // call init function
             error = remote_sem_init( (intptr_t)vaddr , data );
+            error = remote_sem_create( (intptr_t)vaddr , data );
             if ( error )
+            {
+                printk("\n[ERROR] in %s : cannot create semaphore = %x\n",
+                       __FUNCTION__ , (intptr_t)value );
                 this->errno = error;
                 return -1;
 …
             if( sem_xp == XPTR_NULL )     // user error
+            {
+                printk("\n[ERROR] in %s : semaphore %x not registered\n",
+                       __FUNCTION__ , (intptr_t)value );
                 this->errno = EINVAL;
                 return -1;
 …
             if( sem_xp == XPTR_NULL )     // user error
+            {
+                printk("\n[ERROR] in %s : semaphore %x not registered\n",
+                       __FUNCTION__ , (intptr_t)value );
                 this->errno = EINVAL;
                 return -1;
 …
             if( sem_xp == XPTR_NULL )     // user error
+            {
+                printk("\n[ERROR] in %s : semaphore %x not registered\n",
+                       __FUNCTION__ , (intptr_t)value );
                 this->errno = EINVAL;
                 return -1;
 …
             if( sem_xp == XPTR_NULL )     // user error
+            {
+                printk("\n[ERROR] in %s : semaphore %x not registered\n",
+                       __FUNCTION__ , (intptr_t)value );
                 this->errno = EINVAL;
                 return -1;
 …
             default:  // undefined operation
+        {
                     this->errno = EINVAL;
             return -1;
+            printk("\n[PANIC] in %s : illegal operation type\n", __FUNCTION__ );
+            hal_core_sleep();
+        }
+        }

trunk/kernel/syscalls/sys_signal.c

-                      r1
+                      r23
 /*
  * sys_sem.c: interface to access signal service
+ * sys_signal.c - associate a specific signal handler to a given signal.
+ *
+ * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
+ * Copyright (c) 2011,2012,2013,2014,2015 UPMC Sorbonne Universites
+ * Authors   Ghassan Almaless (2008,2009,2010,2011,2012)
+ *           Alain Greiner (2016,2017)
+ *
+ * Copyright (c) UPMC Sorbonne Universites
+ *
  * This file is part of ALMOS-kernel.
 …
  */
 #include <types.h>
+#include <hal_types.h>
 #include <errno.h>
 #include <thread.h>
+#include <task.h>
+#include <pid.h>
+#include <printk.h>
 #include <signal.h>
+//////////////////////////////////
+int sys_signal( uint32_t   sig_id,
+                void     * handler )
+{
+        thread_t  * this = CURRENT_THREAD;
+int sys_signal(uint_t sig, sa_handler_t *handler)
+{
+        register struct thread_s *this;
+        int retval;
+        this = current_thread;
+        if((sig == 0) || (sig >= SIG_NR) || (sig == SIGKILL) || (sig == SIGSTOP))
+        if((sig_id == 0) || (sig_id >= SIG_NR) || (sig_id == SIGKILL) || (sig_id == SIGSTOP))
+        {
+                this->info.errno = EINVAL;
+                return SIG_ERROR;
+        printk("\n[ERROR] in %s : illega signal index = %d\n", __FUNCTION__ , sig_id );
+                this->errno = EINVAL;
+                return -1;
+        }
         retval = (int) this->task->sig_mgr.sigactions[sig];
         this->task->sig_mgr.sigactions[sig] = handler;
+        // register handler in signal manager for the calling process
+        this->process->sig_mgr.sigactions[sig_id] = handler;
+        sig_dmsg(1, "%s: handler @%x has been registred for signal %d\n",
+               __FUNCTION__,
+               handler,
+               sig);
+        signal_dmsg("\n[INFO] %s : handler @%x has been registred for signal %d\n",
+                    __FUNCTION__ , handler , sig_id );
-        return retval;
+}
-int sys_sigreturn_setup(void *sigreturn_func)
+{
-        struct thread_s *this;
-        this = current_thread;
-        this->info.attr.sigreturn_func = sigreturn_func;
-        cpu_context_set_sigreturn(&this->pws, sigreturn_func);
         return 0;
+}
-int sys_kill(pid_t pid, uint_t sig)
+{
-        cid_t   location;
-        error_t err;
-        if((sig == 0) || (sig >= SIG_NR))
+        {
-                err = EINVAL;
+        }
-        else
+        {
-                if ( PID_GET_CLUSTER(pid) == current_cid )
-                        location = current_cid;
-                else
-                        location = task_whereis(pid);
-                err = signal_rise(pid, location, sig);
-                /* No error, return 0 */
-                if (!err)
-                        return 0;
+        }
-        /* Error. Set errno and return */
-        current_thread->info.errno = err;
-        return -1;
+}

trunk/kernel/syscalls/sys_stat.c

-                      r1
+                      r23
 /*
  * kern/sys_stat.c - stats a file or directory
+ * sys_stat.c - Return statistics on a file or directory.
+ *
+ * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
+ * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ * Author    Alain Greiner  (2016,2017)
+ *
  * This file is part of ALMOS-kernel.
+ * Copyright (c) UPMC Sorbonne Universites
+ *
+ * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * This file is part of ALMOS-MKH.
+ *
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
+#include <hal_types.h>
+#include <hal_uspace.h>
+#include <hal_special.h>
 #include <errno.h>
 #include <thread.h>
+#include <printk.h>
 #include <vfs.h>
+#include <sys-vfs.h>
+#include <task.h>
+#include <spinlock.h>
+#include <cpu-trace.h>
+#include <vmm.h>
+#include <process.h>
+//////////////////////////////////////////
+int sys_stat( uint32_t            file_id,
+              struct vfs_stat_s * stat )
+{
+    error_t           error;
+    paddr_t           paddr;
+    struct vfs_stat_s k_stat;
+    xptr_t            file_xp;
+        thread_t  * this    = CURRENT_THREAD;
+        process_t * process = this->process;
+int sys_stat(char *pathname, struct vfs_stat_s *buff, int fd)
+{
+        CPU_HW_TRACE(sys_stat);
+        struct thread_s *this;
+        register error_t err = 0;
+        struct vfs_file_s *file;
+        struct ku_obj ku_path;
+        struct task_s *task;
+    // check stat structure in user space
+    error = vmm_v2p_translate( false , stat , &paddr );
+        file = NULL;
+        this = current_thread;
+        task = current_task;
+        if( error )
+        {
+        printk("\n[ERROR] in %s : stat structure unmapped  for thread %x in process %x\n",
+               __FUNCTION__ , this->trdid , process->pid );
+                this->errno = EINVAL;
+                return -1;
+        }
+        if((buff == NULL) || ((pathname == NULL) && (fd == -1)))
+    // get extended pointer on remote file descriptor
+    file_xp = process_fd_get_xptr( process , file_id );
+    if( file_xp == XPTR_NULL )
+    {
+        printk("\n[ERROR] in %s : undefined file descriptor for thread %x in process %x\n",
+               __FUNCTION__ , this->trdid , process->pid );
+        this->errno = EBADFD;
+        return -1;
+    }
+    // call the relevant VFS function
+    error = vfs_stat( file_xp,
+                      &k_stat );
+    if( error )
+        {
+                this->info.errno = EINVAL;
+                CPU_HW_TRACE(sys_stat);
+        printk("\n[ERROR] in %s : cannot access file %d for thread %x in process %x\n",
+               __FUNCTION__ , file_id , this->trdid , process->pid );
+                this->errno = error;
                 return -1;
+        }
+    // copy stat to user space
+    hal_copy_to_uspace( stat , &k_stat , sizeof(struct vfs_stat_s) );
+        if(NOT_IN_USPACE((uint_t)buff))
+        {
+                this->info.errno = EPERM;
+                CPU_HW_TRACE(sys_stat);
+                return -1;
+        }
+    hal_wbflush();
-        if(pathname == NULL)
+        {
-                if((fd >= CONFIG_TASK_FILE_MAX_NR) || (task_fd_lookup(task, fd, &file)))
+                {
-                        CPU_HW_TRACE(sys_stat);
-                        return EBADFD;
+                }
-                err = vfs_stat(&task->vfs_cwd, NULL, buff, file);
+        }
-        else
+        {
-                KU_BUFF(ku_path, pathname);
-                rwlock_rdlock(&task->cwd_lock);
-                err = vfs_stat(&task->vfs_cwd, &ku_path, buff, NULL);
-                rwlock_unlock(&task->cwd_lock);
+        }
-        this->info.errno = err;
-        CPU_HW_TRACE(sys_stat);
         return 0;
+}
+}  // end sys_stat()

trunk/kernel/syscalls/sys_thread_create.c

-                      r14
+                      r23
  * sys_thread_create.c - creates a new user thread
+ *
+ * Author  Ghassan Almaless (2008,2009,2010,2011,2012)
+ *         Mohamed lamine Karaoui (2015)
+ *         Alain Greiner (2016)
+ * Author     Alain Greiner (2016,2017)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
 #include <kernel_config.h>
 #include <hal_types.h>
+#include <hal_uspace.h>
 #include <printk.h>
 #include <errno.h>
 …
 #include <spinlock.h>
 #include <dqdt.h>
+#include <rpc.h>
 …
                         pthread_attr_t * user_attr,     // [in] argument
                         void           * start_func,    // [in] argument
                         void           * start_args )   // [in] argument
+                        void           * start_arg )    // [in] argument
+{
         pthread_attr_t   attr;             // copy of pthread attributes in kernel space
+        pthread_attr_t   k_attr;           // copy of pthread attributes in kernel space
         thread_t       * parent;           // pointer on thread executing the pthread_create
     xptr_t           xp_parent;        // extended pointer on created thread
     thread_t       * child;            // pointer on created child thread
     xptr_t           xp_child;         // extended pointer on created thread
+    xptr_t           parent_xp;        // extended pointer on created thread
+    thread_t       * child_ptr;        // pointer on created child thread
+    xptr_t           child_xp;         // extended pointer on created thread
     trdid_t          trdid;            // created thread identifier
     process_t      * process;          // pointer on local process descriptor
+    paddr_t          paddr;            // unused, required by vmm_v2p_translate()
     error_t          error;
 …
     // get parent thead pointer, extended pointer, and process pointer
         parent     = CURRENT_THREAD;
     xp_parent  = XPTR( local_cxy , parent );
+    parent_xp  = XPTR( local_cxy , parent );
         process    = parent->process;
+    // check user_attr & start_func arguments
+        if( user_attr == NULL )
+    // check user_attr in user space
+    error = vmm_v2p_translate( false , user_attr , &paddr );
+        if( error )
+        {
+                printk("\n[ERROR] in %s : user_attr is NULL\n", __FUNCTION__ );
+                return EINVAL;
+        }
+        if( start_func== NULL )
+        {
+                printk("\n[ERROR] in %s : start_func is NULL\n", __FUNCTION__ );
+                return EINVAL;
+                printk("\n[ERROR] in %s : user_attr unmapped\n", __FUNCTION__ );
+                parent->errno = EINVAL;
+        return -1;
+        }
+    // copy user_attr structure to kernel space
+        hal_copy_from_uspace( &attr , user_attr , sizeof(pthread_attr_t) );
+    // check start_func in user space
+    error = vmm_v2p_translate( false , start_func , &paddr );
+        if( error )
+        {
+                printk("\n[ERROR] in %s : start_func unmapped\n", __FUNCTION__ );
+                parent->errno = EINVAL;
+        return -1;
+        }
+    // check start_arg in user space
+    if( start_arg != NULL ) error = vmm_v2p_translate( false , start_arg , &paddr );
+        if( error )
+        {
+                printk("\n[ERROR] in %s : start_arg unmapped\n", __FUNCTION__ );
+                parent->errno = EINVAL;
+        return -1;
+        }
+    // copy user_attr structure from user space to kernel space
+        hal_copy_from_uspace( &k_attr , user_attr , sizeof(pthread_attr_t) );
     // check/set "cxy" attribute
         if( attr.flags & PT_FLAG_CLUSTER_DEFINED )
+        if( k_attr.attributes & PT_ATTR_CLUSTER_DEFINED )
+    {
         if( cluster_is_undefined( attr.cxy ) )
+        if( cluster_is_undefined( k_attr.cxy ) )
+        {
+                    printk("\n[ERROR] in %s : illegal target cluster = %x\n",
+                   __FUNCTION__ , attr.cxy );
+                    return = EINVAL;
+                    printk("\n[ERROR] in %s : illegal target cluster attribute = %x\n",
+                   __FUNCTION__ , k_attr.cxy );
+                    parent->errno = EINVAL;
+            return -1;
+        }
+    }
     else
+    {
         attr.cxy = dqdt_get_cluster_for_process();
+        k_attr.cxy = dqdt_get_cluster_for_process();
+    }
-    // set "pid", "start_func" & "start_args" attributes
-    attr.pid        = process->pid;
-    attr.start_func = start_func;
-    attr.start_args = start_args;
     // create the thread, using a RPC if required
+    // this returns "error", "child", and "xp_child"
+    if( attr.cxy == local_cxy )                 // target cluster is local
+    // this returns "error", "child", and "child_xp"
+    if( k_attr.cxy == local_cxy )                         // target cluster is local
+    {
-        // allocate a stack from local VMM
-        vseg_t * vseg = vmm_create_vseg( process,
-,
-,
-                                         VSEG_TYPE_STACK,
-                                         local_cxy );
-        if( vseg == NULL )
+        {
-                    printk("\n[ERROR] in %s for : cannot create stack vseg\n", __FUNCTION__ );
-                    return = EINVAL;
+        }
         // create thread in local cluster
+        error = thread_user_create( &child,
+                                    &attr,
+                                    vseg->min,
+                                    vseg->max - vseg->min );
+        error = thread_user_create( process->pid,
+                                    start_func,
+                                    start_arg,
+                                    &k_attr,
+                                    &child_ptr );
         xp_child = XPTR( local_cxy , thread );
+        child_xp = XPTR( local_cxy , child_ptr );
+    }
     else                                                 // target cluster is remote
+    {
+        rpc_thread_user_create( attr.cxy , &attr , &error , &xp_child );
+        child = (thread_t *)GET_PTR( xp_child );
+        rpc_thread_user_create_client( k_attr.cxy,
+                                       process->pid,
+                                       start_func,
+                                       start_arg,
+                                       &k_attr,
+                                       &child_xp,
+                                       &error );
+        child_ptr = (thread_t *)GET_PTR( child_xp );
+    }
 …
     // returns trdid to user space
     trdid = hal_remote_lw( XPTR( attr.cxy , &child->trdid ) );
+    trdid = hal_remote_lw( XPTR( k_attr.cxy , &child_ptr->trdid ) );
         hal_copy_to_uspace( new_thread , &trdid , sizeof(pthread_t) );
     // register new-thread in parent-thread children list if required
+    if( attr.flags & PT_FLAG_DETACH == 0 ) thread_child_parent_link( xp_parent , xp_child );
+    if( (k_attr.attributes & PT_ATTR_DETACH) == 0 )
+        thread_child_parent_link( parent_xp , child_xp );
         tm_end = hal_time_stamp();
 …
         thread_dmsg("\n[INFO] %s created thread %x for process %x in cluster %x\n"
                 "  start_cycle = %d / end_cycle = %d\n",
                    trdid , process->pid , attr.cxy , tm_start , tm_end );
+                   trdid , process->pid , k_attr.cxy , tm_start , tm_end );
         return 0;

trunk/kernel/syscalls/sys_thread_detach.c

-                      r1
+                      r23
 /*
  * kern/sys_thread_detach.c - detach a joinable thread
+ * sys_thread_detach.c - detach a joinable thread
+ *
+ * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
+ * Authors   Alain Greiner (2016,2017)
+ *
  * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ *
  * This file is part of ALMOS-kernel.
+ * This file is part of ALMOS-MKH.
+ *
  * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
+#include <list.h>
+#include <hal_types.h>
+#include <hal_remote.h>
+#include <hal_special.h>
 #include <thread.h>
-#include <kmem.h>
-#include <kmagics.h>
 #include <errno.h>
+#include <task.h>
+#include <spinlock.h>
+#include <printk.h>
+int sys_thread_detach (pthread_t tid)
+//////////////////////////////////////
+int sys_thread_detach( trdid_t trdid )
+{
+        register struct task_s *task;
+        struct thread_s *target_th;
+        uint_t state;
+        error_t err;
+    xptr_t       target_xp;
+        thread_t   * target_ptr;
+    cxy_t        target_cxy;
+    ltid_t       target_ltid;
+    uint32_t     flags;
+        task = current_task;
+        thread_t   * this    = CURRENT_THREAD;
+    process_t  * process = this->process;
+        if(tid > task->max_order)
+    // get target thread ltid and cxy
+    target_ltid = LTID_FROM_TRDID( trdid );
+    target_cxy  = CXY_FROM_TRDID( trdid );
+    // check trdid argument
+        if( (target_ltid >= CONFIG_THREAD_MAX_PER_CLUSTER) || cluster_is_undefined( target_cxy ) )
+        {
+                err = EINVAL;
+                goto fail_arg;
+        }
+        spinlock_lock(&task->th_lock);
+        target_th = task->th_tbl[tid];
+        if((target_th == NULL)                 ||
+           (target_th->signature != THREAD_ID) ||
+           (target_th->info.attr.key != tid))
+        {
+                err = ESRCH;
+                goto fail_srch;
+        }
+        if(!(thread_isJoinable(target_th)))
+        {
+                err = EINVAL;
+                goto fail_not_joinable;
+        }
+        err = 0;
+        spinlock_lock(&target_th->lock);
+        thread_clear_joinable(target_th);
+        if((target_th->info.join == NULL) &&
+           !(state = wait_queue_isEmpty(&target_th->info.wait_queue)))
+        {
+                wakeup_one(&target_th->info.wait_queue, WAIT_ANY);
+        printk("\n[ERROR] in %s : illegal trdid argument\n", __FUNCTION__ );
+                this->errno = EINVAL;
+                return -1;
+        }
+        spinlock_unlock(&target_th->lock);
+fail_not_joinable:
+fail_srch:
+        spinlock_unlock(&task->lock);
+    // get extended pointer on target thread
+        target_xp  = thread_get_xptr( process->pid , trdid );
+fail_arg:
+        current_thread->info.errno = err;
+        return err;
+}
+    if( target_xp == XPTR_NULL )
+    {
+        printk("\n[ERROR] in %s : target thread not found\n", __FUNCTION__ );
+        this->errno = ESRCH;
+        return -1;
+    }
+    // get local pointer on target thread
+    target_ptr = (thread_t *)GET_PTR( target_xp );
+    // get target thread flags
+    flags = hal_remote_lw( XPTR( target_cxy , &target_ptr->flags ) );
+    // check target thread joinable
+    if( flags & THREAD_FLAG_DETACHED )
+    {
+        printk("\n[ERROR] in %s : target thread not joinable\n", __FUNCTION__ );
+        this->errno = EINVAL;
+        return -1;
+    }
+    // atomically set the thread DETACHED flag
+    hal_remote_atomic_or( XPTR( target_cxy , &target_ptr->flags ) , THREAD_FLAG_DETACHED );
+        return 0;
+}  // end sys_thread_detach()

trunk/kernel/syscalls/sys_thread_exit.c

-                      r16
+                      r23
 /*
  * kern/sys_thread_exit.c - terminates the execution of current thread
+ * sys_thread_exit.c - terminates the execution of current thread
+ *
  * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
  * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ * Authors       Ghassan Almaless (2008,2009,2010,2011,2012)
+ *               Alain Greiner (2016,2017)
+ *
  * This file is part of ALMOS-kernel.
+ * Copyright (c) UPMC Sorbonne Universites
+ *
+ * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * This file is part of ALMOS-MKH.
+ *
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
+#include <list.h>
+#include <hal_types.h>
+#include <hal_irqmask.h>
 #include <thread.h>
+#include <core.h>
 #include <scheduler.h>
+#include <wait_queue.h>
+#include <cluster.h>
+#include <dqdt.h>
+#include <process.h>
+#include <printk.h>
+///////////////////////////////////////
+int sys_thread_exit ( void * exit_val )
+////////////////////////////////////////
+int sys_thread_exit( void * exit_value )
+{
         thread_t  * this = CURRENT_THREAD;
     core_t    * core = this->core;
-        bool_t      isEmpty;
-        bool_t      isReleased;
     uint32_t    irq_state;
+        // update DQDT TODO must be done by thread destroy
         if(this->process->pid != 1) dqdt_local_update_threads( -1 );
+    // register the exit_value in thread descriptor
+    this->exit_value = exit_value;
+        spinlock_lock( &this->lock );
+    // we enter the join loop to wait the join
+    // only if thread is joinable
+    if( (this->flags & THREAD_FLAG_DETACHED) == 0 )
+    {
+            while( 1 )
+            {
+            // take the lock protecting the flags
+                remote_spinlock_lock( XPTR( local_cxy, &this->flags_lock ) );
+        if(!(thread_isJoinable(this)))
+        {
+                goto exit_dead;
+            // check the JOIN flag
+            if( this->flags & THREAD_FLAG_JOIN )       // parent made a join
+            {
+                // unblock the parent thread
+                thread_unblock( this->parent , THREAD_BLOCKED_JOIN );
+                // release the lock protecting the flags
+                    remote_spinlock_unlock( XPTR( local_cxy, &this->flags_lock ) );
+                // exit while
+                break;
+            }
+            else                                       // no join done by parent thread
+            {
+                // set the EXIT flag
+                this->flags |= THREAD_FLAG_EXIT;
+                // block this thread
+                thread_block( this , THREAD_BLOCKED_EXIT );
+                // release the lock protecting the flags
+                    remote_spinlock_unlock( XPTR( local_cxy, &this->flags_lock ) );
+                // deschedule
+                sched_yield();
+            }
+        }
+        }
-        // Check if there's a thread waiting the end of calling thread
-        isEmpty = wait_queue_isEmpty(&this->info.wait_queue);
-        if(isEmpty)
+        {
-                this->info.exit_value = exit_val;
-                wait_on(&this->info.wait_queue, WAIT_ANY);
-                spinlock_unlock_nosched(&this->lock);
-                sched_sleep(this);
+        }
-        else
+        {
-                this->info.join->info.exit_value = exit_val;
-                wakeup_one(&this->info.wait_queue, WAIT_ANY);
-                spinlock_unlock_nosched(&this->lock);
+        }
-exit_dead:
-        isReleased = false;
         // Release FPU if required
         hal_disable_irq( &irq_state );
+        if(core->fpu_owner == this)
+        {
+                core->fpu_owner = NULL;
+                isReleased = true;
+        }
+        if( core->fpu_owner == this )  core->fpu_owner = NULL;
         hal_restore_irq( irq_state );
+        if(isReleased)
+        {
+                thread_dmsg(1, "INFO: Thread %x has released FPU on CPU %d\n",
+                       this,
+                       current_cpu->gid);
+        }
+        // suicide
+    thread_kill( this );
+        return 0;
+        sched_exit(this);
+        PANIC ("Thread %x, CPU %d must never return", this, current_cpu->gid);
+        return -1;              /* Fake return ! */
+}
+}  // end sys_thread_exit()

trunk/kernel/syscalls/sys_thread_join.c

-                      r1
+                      r23
 /*
  * kern/sys_thread_join.c - passive wait on the end of a given thread
+ * sys_thread_join.c - passive wait on the end of a given thread.
+ *
+ * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
+ * Authors    Alain Greiner (2016,2017)
+ *
  * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ *
  * This file is part of ALMOS-kernel.
+ * This file is part of ALMOS-MKH.
+ *
  * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
+#include <list.h>
+#include <hal_types.h>
+#include <hal_remote.h>
+#include <hal_special.h>
 #include <thread.h>
+#include <vmm.h>
 #include <scheduler.h>
-#include <kmem.h>
 #include <errno.h>
 #include <task.h>
 #include <spinlock.h>
+#include <printk.h>
+#include <remote_spinlock.h>
+int sys_thread_join (pthread_t tid, void **thread_return)
+///////////////////////////////////////
+int sys_thread_join ( trdid_t    trdid,
+                      void    ** exit_value )
+{
+        register struct task_s *task;
+        register struct thread_s *this;
+        register struct thread_s *target_th;
+        register uint_t state = 0;
+        void *retval;
+        int err;
+    xptr_t        target_xp;
+    thread_t    * target_ptr;
+    cxy_t         target_cxy;
+    ltid_t        target_ltid;
+    uint32_t      flags;        // target thread flags
+    intptr_t      value;        // value returned by target thread
+    paddr_t       paddr;        // required for vmm_v2p_translate()
+        this   = current_thread;
+        task   = this->task;
+        retval = 0;
+        thread_t  * this    = CURRENT_THREAD;
+    process_t * process = this->process;
+        if((tid > task->max_order) ||
+           ((thread_return != NULL) &&
+            (NOT_IN_USPACE((uint_t)thread_return + sizeof(void*)))))
+    // get target thread ltid and cxy
+    target_ltid = LTID_FROM_TRDID( trdid );
+    target_cxy  = CXY_FROM_TRDID( trdid );
+    // check trdid argument
+        if( (target_ltid >= CONFIG_THREAD_MAX_PER_CLUSTER) || cluster_is_undefined( target_cxy ) )
+        {
+                err = EINVAL;
+                goto fail_arg;
+        printk("\n[ERROR] in %s : illegal trdid argument\n", __FUNCTION__ );
+                this->errno = EINVAL;
+                return -1;
+        }
+        /* try to write to userland address */
         if(thread_return)
+    // check exit_value argument
+        if( (exit_value != NULL) && (vmm_v2p_translate( false , exit_value , &paddr ) != 0 ) )
+        {
+                if((err = cpu_copy_to_uspace(thread_return, &retval, sizeof(void *))))
+                        goto fail_uspace_ret;
+        printk("\n[ERROR] in %s : illegal exit_value argument\n", __FUNCTION__ );
+                this->errno = EINVAL;
+                return -1;
+        }
+        spinlock_lock(&task->th_lock);
+        target_th = task->th_tbl[tid];
+    // check target thread != this thread
+    if( this->trdid == trdid )
+    {
+        printk("\n[ERROR] in %s : this thread == target thread\n", __FUNCTION__ );
+        this->errno = EDEADLK;
+        return -1;
+    }
+        if((target_th == NULL)                 ||
+           (target_th->signature != THREAD_ID) ||
+           (target_th->info.attr.key != tid))
+        {
+                err = ESRCH;
+                goto fail_srch;
+        }
+    // get extended pointer on target thread
+        target_xp  = thread_get_xptr( process->pid , trdid );
+        if(target_th == this)
+        {
+                err = EDEADLK;
+                goto fail_deadlock;
+        }
+    if( target_xp == XPTR_NULL )
+    {
+        printk("\n[ERROR] in %s : target thread not found\n", __FUNCTION__ );
+        this->errno = ESRCH;
+        return -1;
+    }
+        if(!(thread_isJoinable(target_th)))
+        {
+                err = EINVAL;
+                goto fail_joinable;
+        }
+        spinlock_lock(&target_th->lock);
+        if(target_th->info.join != NULL)
+        {
+                spinlock_unlock(&target_th->lock);
+                err = EINVAL;
+                goto fail_joined;
+        }
+    // get cluster and local pointer on target thread
+    target_ptr = (thread_t *)GET_PTR( target_xp );
+        // Get the exit code of the target thread
+        if ((state=wait_queue_isEmpty(&target_th->info.wait_queue)))
+        {
+                target_th->info.join = this;
+                wait_on(&target_th->info.wait_queue, WAIT_ANY);
+                spinlock_unlock(&target_th->lock);
+                spinlock_unlock_nosched(&task->th_lock);
+                sched_sleep(this);
+                retval = this->info.exit_value;
+        }
+        else
+        {
+                retval = target_th->info.exit_value;
+                wakeup_one(&target_th->info.wait_queue, WAIT_ANY);
+                spinlock_unlock(&target_th->lock);
+                spinlock_unlock(&task->th_lock);
+        }
+    // check target thread joinable
+    flags = hal_remote_lw( XPTR( target_cxy , &target_ptr->flags ) );
+    if( flags & THREAD_FLAG_DETACHED )
+    {
+        printk("\n[ERROR] in %s : target thread not joinable\n", __FUNCTION__ );
+        this->errno = EINVAL;
+        return -1;
+    }
+        /* Probably will not fail */
         if(thread_return)
+        {
+                if((err = cpu_copy_to_uspace(thread_return, &retval, sizeof(void *))))
                         goto fail_uspace;
+        }
+    // check kernel stack overflow
+    if( target_ptr->signature != THREAD_SIGNATURE )
+    {
+        printk("\n[PANIC] in %s : kernel stack overflow\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
+        return 0;
+    // wait target thread exit
+    while( 1 )
+    {
+        // take the target thread lock protecting flags
+        remote_spinlock_lock( XPTR( target_cxy , &target_ptr->flags_lock ) );
+fail_joined:
+fail_joinable:
+fail_deadlock:
+fail_srch:
+        spinlock_unlock(&task->th_lock);
+        // get the remote thread flags
+        flags = hal_remote_lw( XPTR( target_cxy , &target_ptr->flags ) );
+fail_uspace:
+fail_uspace_ret:
+fail_arg:
+        this->info.errno = err;
+        return err;
+}
+        // check the EXIT flag
+        if( flags & THREAD_FLAG_EXIT )   // target made an exit
+        {
+            // unblock the target thread
+            thread_unblock( target_xp , THREAD_BLOCKED_EXIT );
+            // release the target thread lock protecting flags
+            remote_spinlock_unlock( XPTR( target_cxy , &target_ptr->flags_lock ) );
+            // exit while
+            break;
+        }
+        else                             // no exit done by target thread
+        {
+            // set the JOIN flag in target thread
+            hal_remote_atomic_or( XPTR( target_xp , &target_ptr->flags ) ,
+                                  THREAD_BLOCKED_JOIN );
+            // block this thread
+            thread_block( this , THREAD_BLOCKED_JOIN );
+            // release the target thread lock protecting flags
+                remote_spinlock_unlock( XPTR( target_cxy , &target_ptr->flags_lock ) );
+            // deschedule
+            sched_yield();
+        }
+    }
+    // return exit_value from target thread descriptor
+    value = (intptr_t)hal_remote_lpt( XPTR( target_cxy , &target_ptr->exit_value ) );
+    *exit_value = (void *)value;
+    return 0;
+}  // end sys_thread_join()

trunk/kernel/syscalls/sys_thread_sleep.c

-                      r1
+                      r23
 /*
  * kern/sys_thread_sleep.c - puts the current thread in sleep state
+ * sys_thread_sleep.c - put the calling thread in sleep state
+ *
+ * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
+ * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ * Author    Alain Greiner (2016,2017)
+ *
  * This file is part of ALMOS-kernel.
+ * Copyright (c) UPMC Sorbonne Universites
+ *
+ * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * This file is part of ALMOS-MKH.
+ *
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
+#include <hal_special.h>
 #include <scheduler.h>
 #include <thread.h>
 #include <task.h>
+#include <printk.h>
+//////////////////////
 int sys_thread_sleep()
+{
         struct thread_s *this;
+    thread_t * this = CURRENT_THREAD;
+        this = current_thread;
+    thread_dmsg("\n[INFO] %s : thread %x in process %x goes to sleep at cycle %d\n",
+                __FUNCTION__ , this->trdid , this->process->pid , hal_time_stamp() );
+        if(this->info.isTraced == true)
+        {
+                printk(INFO, "%s: cpu %d, pid %d, tid %d, asked to go sleep [%d]\n",
+                       __FUNCTION__,
+                       cpu_get_id(),
+                       this->task->pid,
+                       this->info.order,
+                       cpu_time_stamp());
+        }
+    thread_block( CURRENT_THREAD , THREAD_BLOCKED_GLOBAL );
+    sched_yield();
+        thread_set_cap_wakeup(this);
+        sched_sleep(this);
+        if(this->info.isTraced == true)
+        {
+                printk(INFO, "%s: cpu %d, pid %d, tid %d, resuming [%d]\n",
+                       __FUNCTION__,
+                       cpu_get_id(),
+                       this->task->pid,
+                       this->info.order,
+                       cpu_time_stamp());
+        }
+    thread_dmsg("\n[INFO] %s : thread %x in process %x resume at cycle\n",
+                __FUNCTION__ , this->trdid , this->process->pid , hal_time_stamp() );
         return 0;
+}
+}  // end sys_thread_sleep()

trunk/kernel/syscalls/sys_thread_wakeup.c

-                      r1
+                      r23
 /*
  * kern/sys_thread_wakeup.c - wakeup all indicated threads
+ * sys_thread_wakeup.c - wakeup all indicated threads
+ *
+ * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
+ * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ * Author    Alain Greiner (2016,2017)
+ *
  * This file is part of ALMOS-kernel.
+ * Copyright (c) UPMC Sorbonne Universites
+ *
+ * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * This file is part of ALMOS-MKH.
+ *
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
+#include <hal_types.h>
+#include <thread.h>
+#include <printk.h>
+#include <process.h>
 #include <errno.h>
-#include <kmagics.h>
-#include <cpu.h>
-#include <kdmsg.h>
-#include <cluster.h>
-#include <task.h>
-#include <scheduler.h>
-#include <thread.h>
+/*
+ * FIXME: define spinlock_rdlock() so all locking on task->th_lock
+ * becoms rdlock but on join/detach/destroy
+ */
+int sys_thread_wakeup(pthread_t tid, pthread_t *tid_tbl, uint_t count)
+//////////////////////////////////////
+int sys_thread_wakeup( trdid_t trdid )
+{
+        struct task_s *task;
+        struct thread_s *this;
+        struct thread_s *target;
+        pthread_t tbl[100];
+        void *listner;
+        uint_t event;
+        sint_t i;
+        error_t err;
+        thread_t  * this    = CURRENT_THREAD;
+    process_t * process = this->process;
+        this = current_thread;
         task = this->task;
         i = -1;
+    // get target thread ltid and cxy
+    ltid_t   target_ltid = LTID_FROM_TRDID( trdid );
+    cxy_t    target_cxy  = CXY_FROM_TRDID( trdid );
+        if(tid_tbl != NULL)
+    // check trdid argument
+        if( (target_ltid >= CONFIG_THREAD_MAX_PER_CLUSTER) || cluster_is_undefined( target_cxy ) )
+        {
+                if((NOT_IN_USPACE((uint_t)tid_tbl + (count*sizeof(pthread_t)))) ||
+                   (count == 0) || (count > 100))
+                {
+                        err = -1;
+                        goto fail_tid_tbl;
+                }
+                if((err = cpu_copy_from_uspace(&tbl[0], tid_tbl, sizeof(pthread_t*) * count)))
+                        goto fail_usapce;
+                if(tbl[0] != tid)
+                {
+                        err = -2;
+                        goto fail_first_tid;
+                }
+        }
+        else
+        {
+                count = 1;
+                tbl[0] = tid;
+        printk("\n[ERROR] in %s : illegal trdid argument\n", __FUNCTION__ );
+                this->errno = EINVAL;
+                return -1;
+        }
+        for(i = 0; i < count; i++)
+        {
+                tid = tbl[i];
+    // get extended pointer on target thread
+    xptr_t thread_xp = thread_get_xptr( process->pid , trdid );
+                if(tid > task->max_order)
+                {
+                        err = -3;
+                        goto fail_tid;
+                }
+    if( thread_xp == XPTR_NULL )
+    {
+        printk("\n[ERROR] in %s : cannot find thread %x in process %x/n",
+               __FUNCTION__ , trdid , CURRENT_THREAD->process->pid );
+        CURRENT_THREAD->errno = EINVAL;
+        return -1;
+    }
+                target = task->th_tbl[tid];
+                if((target == NULL) || (target->signature != THREAD_ID))
+                {
+                        err = -4;
+                        goto fail_target;
+                }
+    // unblock target thread
+    thread_unblock( thread_xp , THREAD_BLOCKED_GLOBAL );
+                listner = sched_get_listner(target, SCHED_OP_UWAKEUP);
+                event = sched_event_make(target,SCHED_OP_UWAKEUP);
+                if(this->info.isTraced == true)
+                {
+                        printk(INFO,"%s: tid %d --> tid %d [%d][%d]\n",
+                               __FUNCTION__,
+                               this->info.order,
+                               tid,
+                               cpu_time_stamp(),
+                               i);
+                }
+                sched_event_send(listner,event);
+                cpu_wbflush();
+        }
+        return 0;
+fail_target:
+fail_tid:
+fail_first_tid:
+fail_usapce:
+fail_tid_tbl:
+        printk(INFO, "%s: cpu %d, pid %d, tid %x, i %d, count %d, ttid %x, request has failed with err %d [%d]\n",
+               __FUNCTION__,
+               cpu_get_id(),
+               task->pid,
+               this,
+               i,
+               count,
+               tid,
+               err,
+               cpu_time_stamp());
+        this->info.errno = EINVAL;
+        return -1;
+}
+    return 0;
+}  // end sys_thread_wakeup()

trunk/kernel/syscalls/sys_thread_yield.c

-                      r1
+                      r23
 /*
  * kern/sys_thread_yield.c - calls the scheduler to yield current CPU
+ * sys_thread_yield.c - calls the scheduler to yield
+ *
+ * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
+ * Authors       Ghassan Almaless (2008,2009,2010,2011,2012)
+ *               Alain Greiner (2016,2017)
+ *
  * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ *
  * This file is part of ALMOS-kernel.
+ * This file is part of ALMOS-MKH.
+ *
  * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
-#include <thread.h>
 #include <scheduler.h>
 int sys_thread_yield()
+{
+        return sched_yield(current_thread);
+        sched_yield();
+        return 0;
+}

trunk/kernel/syscalls/sys_trace.c

-                      r15
+                      r23
 /*
  * kern/sys_ps.c - show kernel active processes and threads
+ * sys_trace.c - show kernel active processes and threads
+ *
+ * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
+ * Copyright (c) 2011,2012,2013,2014,2015 UPMC Sorbonne Universites
+ * Author    Alain Greiner (c) (2016,2017)
+ *
  * This file is part of ALMOS-kernel.
+ * Copyright (c) UPMC Sorbonne Universites
+ *
+ * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * This file is part of ALMOS-MKH.
+ *
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
 #include <types.h>
 #include <task.h>
 #include <pid.h>
+#include <hal_types.h>
+#include <hal_special.h>
+#include <printk.h>
 #include <thread.h>
-#include <vmm.h>
 #include <errno.h>
+#include <utils.h>
+#include <rpc.h>
+#include <cluster.h>
+#include <syscalls.h>
+extern error_t ps_func(void *param);
+//////////////////////////////////
+int sys_trace( uint32_t operation,
+               pid_t    pid,
+               uint32_t trdid )
+{
+    // get extended pointer on target thread
+    xptr_t thread_xp = thread_get_xptr( pid , trdid );
+/* TODO: add remote support. */
+static error_t sys_ps_check_thread(pid_t pid, uint_t tid, struct thread_s **th_ptr)
+{
+        struct task_s *task;
+        struct thread_s *thread;
+        cid_t  location;
+    if( thread_xp == XPTR_NULL )
+    {
+        printk("\n[ERROR] in %s : undefined thread for PID = %x / TRDID = %x\n",
+               __FUNCTION__ , pid , trdid );
+        CURRENT_THREAD->errno = EINVAL;
+        return -1;
+    }
+        if(pid == PID_MIN_LOCAL)
+                return EINVAL;
+    if( operation == TRACE_OFF )
+    {
+        // desactivate thread trace TODO
+        location = task_whereis(pid);
+            printk("\n[INFO] %s : trace OFF  for thread %x in process %x\n",
+               __FUNCTION__ , trdid , pid );
+    }
+    else if( operation == TRACE_ON )
+    {
+        // activate thread trace TODO
+            printk("\n[INFO] %s : trace ON for thread %x in process %x\n",
+               __FUNCTION__ , trdid , pid );
+    }
+    else
+    {
+        printk("\n[ERROR] in %s : undefined operation\n", __FUNCTION__ );
+        CURRENT_THREAD->errno = EINVAL;
+        return -1;
+    }
+        tasks_manager_lock();
+        if ( location == current_cid )
+        {
+                task = task_lookup(pid)->task;
+    hal_wbflush();
+                if((task == NULL) || (tid > task->max_order))
+                        return EINVAL;
+    return 0;
+                thread = task->th_tbl[tid];
+                if((thread == NULL)                 ||
+                   (thread->signature != THREAD_ID) ||
+                   (thread->info.attr.key != tid))
+                {
+                        return ESRCH;
+                }
+                *th_ptr = thread;
+                return 0;
+        }
+        else
+        {
+                printk(WARNING, "%s: cluster %u can't execute this function on remote task (pid %u on cluster %u)\n",   \
+                                __FUNCTION__, current_cid, pid, location);
+                return ENOSYS;
+        }
+        tasks_manager_unlock();
+}
+/*TODO: use RPC_ARG_NULL instead of sending a useless variable.
+ * It's not urgent, it's a minor change.
+ */
+RPC_DECLARE(__ps_func,                                  \
+                RPC_RET( RPC_RET_PTR(error_t, err) ),   \
+                RPC_ARG( RPC_ARG_PTR(error_t, foo) )    \
+           )
+{
+        *err = ps_func(NULL);
+}
+int sys_ps(uint_t cmd, pid_t pid, uint_t tid)
+{
+        cid_t next;
+        error_t err;
+        struct thread_s *thread;
+        struct kernel_iter_s *kernel_iter;
+        err = 0;
+        switch(cmd)
+        {
+        case TASK_PS_TRACE_OFF:
+                err = sys_ps_check_thread(pid, tid, &thread);
+                if(err) goto fail_trace_off;
+                thread->info.isTraced = false;
+                cpu_wbflush();
+                printk(INFO,"INFO: pid %d, tid %x, tracing is turned [OFF]\n", pid, tid);
+                break;
+        case TASK_PS_TRACE_ON:
+                err = sys_ps_check_thread(pid, tid, &thread);
+                if(err) goto fail_trace_on;
+                thread->info.isTraced = true;
+                cpu_wbflush();
+                printk(INFO,"INFO: pid %d, tid %x, tracing is turned [ON]\n", pid, tid);
+                break;
+        case TASK_PS_SHOW:
+                kernel_foreach_backward(kernel_iter, next)
+                {
+                        RCPC( next, RPC_PRIO_PS, __ps_func,
+                              RPC_RECV( RPC_RECV_OBJ(err) ),
+                              RPC_SEND( RPC_SEND_OBJ(err) )
+                           );
+                }
+                break;
+        }
+fail_trace_on:
+fail_trace_off:
+        current_thread->info.errno = err;
+        return err;
+}
+}  // end sys_trace()

trunk/kernel/syscalls/sys_undefined.c

-                      r15
+                      r23
 /*
  * kern/sys_dma_memcpy.c - exported DMA access to user process
+ * sys_undefined.c - function executed for an undefined syscall.
+ *
+ * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
+ * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ * Author    Alain Greiner (2016,2017)
+ *
  * This file is part of ALMOS-kernel.
+ * Copyright (c) UPMC Sorbonne Universites
+ *
+ * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * This file is part of ALMOS-MKH.
+ *
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
 #include <errno.h>
-#include <types.h>
-#include <event.h>
-#include <chdev.h>
-#include <driver.h>
-#include <kmem.h>
-#include <kdmsg.h>
-#include <dma.h>
-#include <kcm.h>
 #include <thread.h>
 #include <cluster.h>
 #include <kcm.h>
+#include <process.h>
+#include <printk.h>
+///////////////////
+int sys_undefined()
+{
+    thread_t  * this    = CURRENT_THREAD;
+    process_t * process = this->process;
+KMEM_OBJATTR_INIT(dma_kmem_request_init)
+{
+        attr->type = KMEM_DMA_REQUEST;
+        attr->name = "KCM Dev-Request";
+        attr->size = sizeof(dev_request_t);
+        attr->aligne = 0;
+        attr->min  = CONFIG_DMA_RQ_KCM_MIN;
+        attr->max  = CONFIG_DMA_RQ_KCM_MAX;
+        attr->ctor = NULL;
+        attr->dtor = NULL;
+        return 0;
+    printk("\n[ERROR] in %s : undefined syscall calle by thread %x in process %x\n",
+           __FUNCTION__ , this->trdid , process->pid );
+    this->errno = EINVAL;
+    return -1;
+}
-static EVENT_HANDLER(dma_async_request_event)
+{
-        kmem_req_t req;
-        error_t err;
-        if((err=event_get_error(event)) != 0)
-                printk(ERROR, "ERROR: dma_async_request_event: DMA transfare is not well completed, remaining %d\n", err);
-        req.type = KMEM_DMA_REQUEST;
-        req.ptr  = event_get_argument(event);
-        assert(req.ptr != NULL && "Corrupted argument, expected the address of request");
-        kmem_free(&req);
-        return 0;
+}
-static inline error_t dma_do_async_request(void *dst, void *src, size_t size)
+{
-        kmem_req_t req;
-        dev_request_t *rq;
-        req.type  = KMEM_DMA_REQUEST;
-        req.size  = sizeof(*rq);
-        req.flags = AF_KERNEL;
-        if((rq = kmem_alloc(&req)) == NULL)
-                return ENOMEM;
-        memset(rq, 0, sizeof(*rq));
-        rq->src   = src;
-        rq->dst   = dst;
-        rq->count = size;
-        rq->flags = DEV_RQ_NOBLOCK;
-        event_set_priority(&rq->event, E_FUNC);
-        event_set_handler(&rq->event, &dma_async_request_event);
-        event_set_argument(&rq->event, rq);
-        return __sys_dma->op.dev.write(__sys_dma, rq);
+}
-static inline error_t dma_do_sync_request(void *dst, void *src, size_t size)
+{
-        dev_request_t rq;
-        rq.src   = src;
-        rq.dst   = dst;
-        rq.count = size;
-        rq.flags = 0;
-        return __sys_dma->op.dev.write(__sys_dma, &rq);
+}
-error_t dma_memcpy(void *dst, void *src, size_t size, uint_t isAsync)
+{
-        if(isAsync == DMA_ASYNC)
-                return dma_do_async_request(dst, src, size);
-        else
-                return dma_do_sync_request(dst, src, size);
+}
-int sys_dma_memcpy(void *src, void *dst, size_t size)
+{
-        return dma_do_sync_request(dst, src, size);
+}

trunk/kernel/syscalls/sys_unlink.c

-                      r1
+                      r23
 /*
  * kern/sys_unlink.c - file unlink
+ * sys_unlink.c - file unlink
+ *
  * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
 …
  */
+#include <hal_types.h>
+#include <hal_uspace.h>
 #include <vfs.h>
+#include <sys-vfs.h>
+#include <task.h>
+#include <process.h>
 #include <thread.h>
+#include <printk.h>
+int sys_unlink (char *pathname)
+//////////////////////////////////
+int sys_unlink ( char * pathname )
+{
+        error_t err = 0;
+        struct ku_obj ku_path;
+        error_t   error;
+    uint32_t  length;
+    char      kbuf[CONFIG_VFS_MAX_PATH_LENGTH];
+        KU_BUFF(ku_path, pathname);
+        if((err = vfs_unlink(&current_task->vfs_cwd, &ku_path)))
+        thread_t     * this     = CURRENT_THREAD;
+        process_t    * process  = this->process;
+    // get pathname length
+    length = hal_strlen_from_uspace( pathname );
+    if( length >= CONFIG_VFS_MAX_PATH_LENGTH )
+    {
+        printk("\n[ERROR] in %s : pathname too long\n", __FUNCTION__ );
+                this->errno = ENFILE;
+        return -1;
+    }
+        // get pathname copy in kernel space
+    hal_copy_from_uspace( kbuf, pathname, length );
+    // 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 );
+    // get the cwd lock in read mode from reference process
+        remote_rwlock_rd_lock( XPTR( ref_cxy , &ref_ptr->cwd_lock ) );
+    // get extended pointer on cwd inode
+    xptr_t cwd_xp = hal_remote_lwd( XPTR( ref_cxy , &ref_ptr->vfs_cwd_xp ) );
+    // call relevant VFS function
+    error  = vfs_unlink( cwd_xp , kbuf );
+    // release the cwd lock in reference process
+        remote_rwlock_rd_unlock( XPTR( ref_cxy , &ref_ptr->cwd_lock ) );
+        if( error )
+        {
+                current_thread->info.errno = (err < 0) ? -err : err;
+                return -1;
+        printk("\n[ERROR] in %s : cannot unlink file/dir %s\n",
+               __FUNCTION__ , pathname );
+                this->errno = ENFILE;
+            return -1;
+        }
         return 0;
+}
+} // end sys_unlink()

trunk/kernel/syscalls/sys_utls.c

-                      r1
+                      r23
  * kern/sys_utls.c - User Thread Local Storage
+ *
  * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
  * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ * Author    Ghassan Almaless (2008,2009,2010,2011,2012)
+ *           Alain Greiner (2016,2017)
+ *
  * This file is part of ALMOS-kernel.
+ * Copyright (c) UPMC Sorbonne Universites
+ *
+ * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * This file is part of ALMOS-MKH.
+ *
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
 #include <types.h>
+#include <hal_types.h>
 #include <errno.h>
 #include <thread.h>
+#include <kmem.h>
+#include <kmagics.h>
+#include <semaphore.h>
+#include <printk.h>
+#include <syscalls.h>
+#define UTLS_SET       1
+#define UTLS_GET       2
+#define UTLS_GET_ERRNO 3
+int sys_utls(uint_t operation, uint_t value)
+/////////////////////////////////
+int sys_utls( uint32_t operation,
+              uint32_t value )
+{
         struct thread_s *this = current_thread;
+    thread_t * this = CURRENT_THREAD;
         switch(operation)
+        {
         case UTLS_SET:
                 this->info.usr_tls = value;
+            case UTLS_SET:
+                this->utls = value;
                 return 0;
         case UTLS_GET:
                 return this->info.usr_tls;
+            case UTLS_GET:
+                return this->utls;
         case UTLS_GET_ERRNO:
                 return this->info.errno;
+            case UTLS_GET_ERRNO:
+                return this->errno;
+        default:
+                this->info.errno = EINVAL;
+            default:
+        printk("\n[ERROR] in %s : illegal utls operation\n", __FUNCTION__ );
+                this->errno = EINVAL;
                 return -1;
+        }
+}
+}  // end sys_utls()

trunk/kernel/syscalls/sys_write.c

-                      r1
+                      r23
 /*
  * kern/sys_write.c - write bytes to a file
+ * sys_write.c - write bytes to a file
+ *
+ * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
+ * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ * Author        Alain Greiner (2016,2017)
+ *
  * This file is part of ALMOS-kernel.
+ * Copyright (c) UPMC Sorbonne Universites
+ *
+ * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * This file is part of ALMOS-MKH.
+ *
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
+#include <kernel_config.h>
+#include <hal_types.h>
+#include <hal_uspace.h>
+#include <hal_special.h>
 #include <errno.h>
-#include <thread.h>
 #include <vfs.h>
 #include <thread.h>
 #include <sys-vfs.h>
 #include <task.h>
+#include <printk.h>
+#include <process.h>
+int sys_write (uint_t fd, void *buf, size_t count)
+/* TODO: user page(s) need to be locked  [AG] */
+//////////////////////////////////
+int sys_write( uint32_t   file_id,
+               void     * buf,
+               uint32_t   count )
+{
         ssize_t err = 0;
         struct thread_s *this;
         struct task_s *task;
         struct vfs_file_s *file;
+        struct ku_obj kub;
+    error_t      error;
+    paddr_t      paddr;
+    char         kbuf[CONFIG_VFS_KBUF_SIZE];
+        xptr_t       file_xp;                       // remote file extended pointer
+    uint32_t     nbytes;                        // number of bytes in one iteration
+        file = NULL;
+        this = current_thread;
+        task = current_task;
+        thread_t   * this = CURRENT_THREAD;
+        process_t  * process = this->process;
+        if((fd >= CONFIG_TASK_FILE_MAX_NR) || (task_fd_lookup(task, fd, &file)))
+    // check file_id argument
+        if( file_id >= CONFIG_PROCESS_FILE_MAX_NR )
+        {
+                this->info.errno = EBADFD;
+        printk("\n[ERROR] in %s : illegal file descriptor index\n", __FUNCTION__ );
+        this->errno = EBADFD;
                 return -1;
+        }
+        KU_SLICE_BUFF(kub, buf, count);
+        if((err = vfs_write(file, &kub)) < 0)
+    // check user buffer in user space
+    error = vmm_v2p_translate( false , buf , &paddr );
+    if ( error )
+    {
+        printk("\n[ERROR] in %s : user buffer unmapped = %x\n",
+               __FUNCTION__ , (intptr_t)buf );
+                this->errno = EINVAL;
+                return -1;
+    }
+    // get extended pointer on remote file descriptor
+    file_xp = process_fd_get_xptr( process , file_id );
+    if( file_xp == XPTR_NULL )
+    {
+        printk("\n[ERROR] in %s : undefined file descriptor index = %d\n",
+               __FUNCTION__ , file_id );
+                this->errno = EBADFD;
+                return -1;
+    }
+    // get file descriptor cluster and local pointer
+    vfs_file_t * file_ptr = (vfs_file_t *)GET_PTR( file_xp );
+    cxy_t        file_cxy = GET_CXY( file_xp );
+    // check file writable
+    uint32_t attr = hal_remote_lw( XPTR( file_cxy , &file_ptr->attr ) );
+    if( (attr & FD_ATTR_WRITE_ENABLE) == 0 )
+        {
+                this->info.errno = (err < 0) ? -err : err;
+        printk("\n[ERROR] in %s : file %d not writable\n",
+               __FUNCTION__ , file_id );
+                this->errno = EBADFD;
                 return -1;
+        }
+        return err;
+}
+    // transfer at most CONFIG_VFS_KBUF_SIZE bytes per iteration
+    while( count )
+    {
+        if( count <= CONFIG_VFS_KBUF_SIZE )
+        {
+            nbytes = count;
+            count  = 0;
+        }
+        else
+        {
+            nbytes = CONFIG_VFS_KBUF_SIZE;
+            count  = count - CONFIG_VFS_KBUF_SIZE;
+        }
+        // copy user buffer to kernel buffer
+        hal_copy_to_uspace( buf , kbuf , nbytes );
+        // transfer nbytes from kernel buffer
+        error = vfs_move( false,               // write => (to_buffer = false)
+                          file_xp,
+                          kbuf ,
+                          nbytes );
+        if( error )
+        {
+            printk("\n[ERROR] in %s cannot read data from file %d\n",
+                   __FUNCTION__ , file_id );
+            this->errno = error;
+            return -1;
+        }
+    }
+    hal_wbflush();
+        return 0;
+}  // end sys_write()

trunk/kernel/syscalls/syscalls.h

-                      r16
+                      r23
  * syscalls.h - kernel services definition
+ *
+ * Author  Ghassan Almaless (2007,2008,2009,2010,2011,2012)
+ *         Alain Greiner    (2016)
+ * Author     Alain Greiner (2016,2017)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
 #define _SYSCALLS_H_
+#include <hal_types.h>
+#include <time.h>
+/*****   Forward declarations  *****/
+struct thread_s;                  // defined in thread.h
+struct pthread_attr_s;            // defined in thread.h
+struct vfs_stat_s;                // defined in vfs.h
+struct vfs_dirent_s;              // defined in vfs.h
+struct mmap_attr_s;               // defined in vmm.h
 /******************************************************************************************
  * This enum defines the mnemonics for the syscall indexes.
 …
 enum
+{
+        SYS_EXIT,          /* 0  */
+        SYS_MMAP,          /* 1  */
+        SYS_CREATE,        /* 2  */
+        SYS_JOIN,          /* 3  */
+        SYS_DETACH,        /* 4  */
+        SYS_YIELD,         /* 5  */
+        SYS_SEMAPHORE,     /* 6  */
+        SYS_COND_VAR,      /* 7  */
+        SYS_BARRIER,       /* 8  */
+        SYS_RWLOCK,        /* 9  */
+        SYS_SLEEP,         /* 10 */
+        SYS_WAKEUP,        /* 11 */
+        SYS_OPEN,          /* 12 */
+        SYS_CREAT,         /* 13 */
+        SYS_READ,          /* 14 */
+        SYS_WRITE,         /* 15 */
+        SYS_LSEEK,         /* 16 */
+        SYS_CLOSE,         /* 17 */
+        SYS_UNLINK,        /* 18 */
+        SYS_PIPE,          /* 19 */
+        SYS_CHDIR,         /* 20 */
+        SYS_MKDIR,         /* 21 */
+        SYS_MKFIFO,        /* 22 */
+        SYS_OPENDIR,       /* 23 */
+        SYS_READDIR,       /* 24 */
+        SYS_CLOSEDIR,      /* 25 */
+        SYS_GETCWD,        /* 26 */
+        SYS_CLOCK,         /* 27 */
+        SYS_ALARM,         /* 28 */
+        SYS_DMA_MEMCPY,    /* 29 */
+        SYS_UTLS,          /* 30 */
+        SYS_SIGRETURN,     /* 31 */
+        SYS_SIGNAL,        /* 32 */
+        SYS_SET_SIGRETURN, /* 33 */
+        SYS_KILL,          /* 34 */
+        SYS_GETPID,        /* 35 */
+        SYS_FORK,          /* 36 */
+        SYS_EXEC,          /* 37 */
+        SYS_GETATTR,       /* 38 */
+        SYS_PS,            /* 39 */
+        SYS_MADVISE,       /* 40 */
+        SYS_PAGEINFO,      /* 41 */
+        SYS_STAT,          /* 42 */
+        SYS_MIGRATE,       /* 43 */
+        SYS_SBRK,          /* 44 */
+        SYS_RMDIR,         /* 45 */
+        SYS_FTIME,         /* 46 */
+        SYS_CHMOD,         /* 47 */
+        SYS_FSYNC,         /* 48 */
+        SYS_GET_TOD,       /* 49 */
+        SYS_TIMES,         /* 50 */
+        SYSCALLS_NR,
+        SYS_THREAD_EXIT    = 0,
+        SYS_MMAP           = 1,
+        SYS_THREAD_CREATE  = 2,
+        SYS_THREAD_JOIN    = 3,
+        SYS_THREAD_DETACH  = 4,
+        SYS_THREAD_YIELD   = 5,
+        SYS_SEM            = 6,
+        SYS_CONDVAR        = 7,
+        SYS_BARRIER        = 8,
+        SYS_MUTEX          = 9,
+        SYS_SLEEP          = 10,
+        SYS_WAKEUP         = 11,
+        SYS_OPEN           = 12,
+        SYS_CREAT          = 13,
+        SYS_READ           = 14,
+        SYS_WRITE          = 15,
+        SYS_LSEEK          = 16,
+        SYS_CLOSE          = 17,
+        SYS_UNLINK         = 18,
+        SYS_PIPE           = 19,
+        SYS_CHDIR          = 20,
+        SYS_MKDIR          = 21,
+        SYS_MKFIFO         = 22,
+        SYS_OPENDIR        = 23,
+        SYS_READDIR        = 24,
+        SYS_CLOSEDIR       = 25,
+        SYS_GETCWD         = 26,
+        SYS_CLOCK          = 27,
+        SYS_ALARM          = 28,
+        SYS_RMDIR          = 29,
+        SYS_UTLS           = 30,
+        SYS_CHMOD          = 31,
+        SYS_SIGNAL         = 32,
+        SYS_TIMEOFDAY      = 33,
+        SYS_KILL           = 34,
+        SYS_GETPID         = 35,
+        SYS_FORK           = 36,
+        SYS_EXEC           = 37,
+        SYS_STAT           = 38,
+        SYS_TRACE          = 39,
+        SYSCALLS_NR        = 40,
 };
 /********************************************************************************************/
 /********************   Process related system calls  ***************************************/
+/********************    system calls    ****************************************************/
 /********************************************************************************************/
+/*********************************************************************************************
+ * [0] This function TODO
+ ********************************************************************************************/
+int sys_thread_exit( void * );
+/*********************************************************************************************
+ * [1] This function TODO
+ ********************************************************************************************/
+int sys_mmap();
+/*********************************************************************************************
+ * [2] This function TODO
+ ********************************************************************************************/
+int sys_thread_create();
+/*********************************************************************************************
+ * [3] This function TODO
+ ********************************************************************************************/
+int sys_thread_join();
+/*********************************************************************************************
+ * [4] This function TODO
+ ********************************************************************************************/
+int sys_thread_detach();
+/*********************************************************************************************
+ * [5] This function TODO
+/*********************************************************************************************
+ * [0] This function terminates the execution of the calling user thread value,
+ * and makes the exit_value pointer available to any successful pthread_join() with the
+ * terminating thread.
+ *********************************************************************************************
+ * @ exit_vallue  : [out] pointer to to the parrent thread if attached.
+ * @ return 0 if success / return -1 if failure.
+ ********************************************************************************************/
+int sys_thread_exit( void * exit_value );
+/*********************************************************************************************
+ * [1] This function map physical memory (or a file) in the calling thread virtual space.
+ * The <attr> argument is a pointer on a structure containing arguments, defined in vmm.h.
+ * TODO not implemented yet...
+ *********************************************************************************************
+ * @ attr       : pointer on attributes structure.
+ * @ return 0 if success / return -1 if failure.
+ ********************************************************************************************/
+int sys_mmap( struct mmap_attr_s * attr );
+/*********************************************************************************************
+ * [2] This function creates a new user thread. The <user_attr> argument is a pointer
+ * on astructure containing the thread attributes, defined in thread.h file.
+ *********************************************************************************************
+ * @ new_thread  : [out] local pointer on created thread descriptor.
+ * @ user_attr   : [in]  pointer on thread attributes structure.
+ * @ start_func  : [in]  pointer on start function.
+ * @ start_args  : [in]  pointer on start function arguments.
+ * @ return 0 if success / return -1 if failure.
+ ********************************************************************************************/
+int sys_thread_create( struct thread_s        * new_thread,
+                       struct pthread_attr_s  * user_attr,
+                       void                   * start_func,
+                       void                   * start_args );
+/*********************************************************************************************
+ * [3] This blocking function suspend execution of the calling thread until completion
+ * of another target thread identified by the <trdid> argument.
+ * If the <exit_value> argument is not NULL, the value passed to pthread_exit() by the
+ * target thread is stored in the location referenced by exit_value.
+ *********************************************************************************************
+ * @ trdid     : [in]  target thread identifier.
+ * @ thread    : [out] buffer for exit_value returned by target thread.
+ * @ return 0 if success / return -1 if failure.
+ ********************************************************************************************/
+int sys_thread_join( trdid_t    trdid,
+                     void    ** exit_value );
+/*********************************************************************************************
+ * [4] This function detach a joinable thread.
+ *********************************************************************************************
+ * @ trdid   : thread identifier.
+ * @ return 0 if success / return -1 if failure.
+ ********************************************************************************************/
+int sys_thread_detach( trdid_t  trdid );
+/*********************************************************************************************
+ * [5] This function calls the scheduler for the core running the calling thread.
+ *********************************************************************************************
+ * @ return always 0.
  ********************************************************************************************/
 int sys_thread_yield();
 /*********************************************************************************************
+ * [6] This function TODO
+ ********************************************************************************************/
+int sys_sem();
+/*********************************************************************************************
+ * [7] This function TODO
+ ********************************************************************************************/
+int sys_cond_var();
+/*********************************************************************************************
+ * [8] This function TODO
+ ********************************************************************************************/
+int sys_barrier();
+/*********************************************************************************************
+ * [9] This function TODO
+ ********************************************************************************************/
+int sys_rwlock();
+/*********************************************************************************************
+ * [10] This function TODO
+ * [6] This function implement all operations on a POSIX unnamed semaphore,
+ * that can be shared by threads running in different clusters.
+ * The kernel structure representing a remote semaphore is in the remote_sem.h file,
+ * and the code implementing the operations is in the remore_sem.c file.
+ *********************************************************************************************
+ * @ vaddr     : semaphore virtual address in user space == identifier.
+ * @ operation : SEM_INIT / SEM_DESTROY / SEM_GETVALUE / SEM_POST / SEM_WAIT.
+ * @ value     : pointer on in/out argument in user space.
+ * @ return 0 if success / return -1 if failure.
+ ********************************************************************************************/
+int sys_sem( void       * vaddr,
+             uint32_t     operation,
+             uint32_t   * value );
+typedef enum
+{
+        SEM_INIT,
+        SEM_DESTROY,
+        SEM_GETVALUE,
+        SEM_WAIT,
+        SEM_POST,
+}
+sem_operation_t;
+/*********************************************************************************************
+ * [7] This function implement all operations on a POSIX condition variable.
+ * The kernel structure representing a cond_var is defined in the remote_cv.h file,
+ * The code implementing the operations is defined in the remote_cv.c file.
+ *********************************************************************************************
+ * @ vaddr     : condvar virtual address in user space == identifier.
+ * @ operation : operation type (see below).
+ * @ attr      : mutex virtual address in user space == identifier.
+ * @ return 0 if success / return -1 if failure.
+ ********************************************************************************************/
+int sys_condvar( void     * condvar,
+                 uint32_t   operation,
+                 void     * mutex );
+typedef enum
+{
+        CONDVAR_INIT,
+        CONDVAR_DESTROY,
+    CONDVAR_WAIT,
+    CONDVAR_SIGNAL,
+    CONDVAR_BROADCAST,
+}
+condvar_operation_t;
+/*********************************************************************************************
+ * [8] This function implement all operations on a POSIX barrier.
+ * The kernel structure representing a barrier is defined in the remote_barrier.h file.
+ * The code implementting the operations is defined in the remote_barrier.c file.
+ *********************************************************************************************
+ * @ vaddr     : barrier virtual address in user space == identifier.
+ * @ operation : BARRIER_INIT / BARRIER_DESTROY / BARRIER_WAIT.
+ * @ count     : number of expected threads (only used by BARRIER_INIT operation).
+ * @ return 0 if success / return -1 if failure.
+ ********************************************************************************************/
+int sys_barrier( void     * vaddr,
+                 uint32_t   operation,
+                 uint32_t   count );
+typedef enum
+{
+        BARRIER_INIT,
+        BARRIER_DESTROY,
+        BARRIER_WAIT,
+}
+barrier_operation_t;
+/*********************************************************************************************
+ * [9] This function implement all operations on a POSIX mutex.
+ * The kernel structure representing a barrier is defined in the remote_barrier.h file.
+ * The code implementting the operations is defined in the remote_barrier.c file.
+ *********************************************************************************************
+ * @ vaddr     : mutex virtual address in user space == identifier.
+ * @ operation : MUTEX_INIT / MUTEX_DESTROY / MUTEX_LOCK / MUTEX_UNLOCK
+ * @ attr      : mutex attributes (non supported yet => must be 0).
+ * @ return 0 if success / return -1 if failure.
+ ********************************************************************************************/
+int sys_mutex( void     * vaddr,
+               uint32_t   operation,
+               uint32_t   count );
+typedef enum
+{
+        MUTEX_INIT,
+        MUTEX_DESTROY,
+        MUTEX_LOCK,
+        MUTEX_UNLOCK,
+}
+mutex_operation_t;
+/*********************************************************************************************
+ * [10] This function block the calling thread on the THREAD_BLOCKED_GLOBAL condition,
+ * and deschedule.
+ *********************************************************************************************
+ * @ return 0 if success / returns -1 if failure.
  ********************************************************************************************/
 int sys_thread_sleep();
 /*********************************************************************************************
+ * [11] This function TODO
+ * [11] This function unblock the thread identified by its <trdid> from the
+ * THREAD_BLOCKED_GLOBAL condition.
+ *********************************************************************************************
+ * @ trdid  : target thread identifier.
+ * @ return 0 if success / return -1 if failure.
  ********************************************************************************************/
 int sys_thread_wakeup();
 /*********************************************************************************************
+ * [12] This function TODO
+ ********************************************************************************************/
+int sys_open();
+/*********************************************************************************************
+ * [13] This function TODO
+ ********************************************************************************************/
+int sys_creat();
+/*********************************************************************************************
+ * [14] This function TODO
+ ********************************************************************************************/
+int sys_read();
+/*********************************************************************************************
+ * [15] This function TODO
+ ********************************************************************************************/
+int sys_write();
+/*********************************************************************************************
+ * [16] This function TODO
+ ********************************************************************************************/
+int sys_lseek();
+/*********************************************************************************************
+ * [17] This function TODO
+ ********************************************************************************************/
+int sys_close();
+/*********************************************************************************************
+ * [18] This function TODO
+ ********************************************************************************************/
+int sys_unlink();
+/*********************************************************************************************
+ * [19] This function TODO
+ ********************************************************************************************/
+int sys_pipe();
+/*********************************************************************************************
+ * [20] This function TODO
+ ********************************************************************************************/
+int sys_chdir();
+/*********************************************************************************************
+ * [21] This function TODO
+ ********************************************************************************************/
+int sys_mkdir();
+/*********************************************************************************************
+ * [22] This function TODO
+ ********************************************************************************************/
+int sys_mkfifo();
+/*********************************************************************************************
+ * [23] This function TODO
+ ********************************************************************************************/
+int sys_opendir();
+/*********************************************************************************************
+ * [24] This function TODO
+ ********************************************************************************************/
+int sys_readdir();
+/*********************************************************************************************
+ * [25] This function TODO
+ ********************************************************************************************/
+int sys_closedir();
+/*********************************************************************************************
+ * [26] This function TODO
+ ********************************************************************************************/
+int sys_getcwd();
+/*********************************************************************************************
+ * [27] This function TODO
+ ********************************************************************************************/
+int sys_clock();
+/*********************************************************************************************
+ * [28] This function TODO
+ ********************************************************************************************/
+int sys_alarm();
+/*********************************************************************************************
+ * [29] This function TODO
+ ********************************************************************************************/
+int sys_dma_memcpy();
+/*********************************************************************************************
+ * [30] This function TODO
+ ********************************************************************************************/
+int sys_utls();
+/*********************************************************************************************
+ * [31] This function TODO
+ ********************************************************************************************/
+int sys_notAvailable();
+/*********************************************************************************************
+ * [32] This function TODO
+ ********************************************************************************************/
+int sys_signal();
+/*********************************************************************************************
+ * [33] This function TODO
+ ********************************************************************************************/
+int sys_sigreturn_setup();
+ * [12] This function open or create a file.
+ *********************************************************************************************
+ * @ pathname   : pathname (can be relative or absolute).
+ * @ flags      : bit vector attributes (see below).
+ * @ mode       : access rights.
+ * @ return file descriptor index in fd_array if success / return -1 if failure.
+ ********************************************************************************************/
+int sys_open( char    * pathname,
+              uint32_t  flags,
+              uint32_t  mode );
+typedef enum
+{
+    O_RDONLY   = 0x0010000,    /*! open file in read-only mode                              */
+    O_WRONLY   = 0x0020000,    /*! open file in write-only mode                             */
+    O_RDWR     = 0x0030000,    /*! open file in read/write mode                             */
+    O_NONBLOCK = 0x0040000,    /*! do not block if data non available                       */
+    O_APPEND   = 0x0080000,    /*! append on each write                                     */
+    O_CREAT    = 0x0100000,    /*! create file if it does not exist                         */
+    O_TRUNC    = 0x0200000,    /*! file length is forced to 0                               */
+    O_EXCL     = 0x0400000,    /*! error if VFS_O_CREAT and file exist                      */
+    O_SYNC         = 0x0800000,    /*! synchronize File System on each write                    */
+    O_CLOEXEC  = 0x1000000,    /*! set the close-on-exec flag in file descriptor            */
+    O_DIR      = 0x2000000,    /*! new file descriptor is for a directory                   */
+}
+open_attributes_t;
+/*********************************************************************************************
+ * [13] This function creates a new file as specified by the arguments.
+ * This function is obsolete, you should use open() with 0_CREATE.
+ *********************************************************************************************
+ * @ pathname   : pathname (can be relative or absolute).
+ * @ mode       : access rights.
+ ********************************************************************************************/
+int sys_creat( char     * pathname,
+               uint32_t   mode );
+/*********************************************************************************************
+ * [14] This function read bytes from an open file identified by its file descriptor.
+ * This file can be a regular file or character oriented device.
+ *********************************************************************************************
+ * @ file_id  : open file index in fd_array.
+ * @ buf      : buffer virtual address in user space.
+ * @ count    : number of bytes.
+ * @ return number of bytes actually read if success / returns -1 if failure.
+ ********************************************************************************************/
+int sys_read( uint32_t   file_id,
+              void     * buf,
+              uint32_t   count );
+/*********************************************************************************************
+ * [15] This function writes bytes to an open file identified by its file descriptor.
+ * This file can be a regular file or character oriented device.
+ *********************************************************************************************
+ * @ file_id  : open file index in fd_array.
+ * @ buf      : buffer virtual address in user space.
+ * @ count    : number of bytes.
+ * @ return number of bytes actually written if success / returns -1 if failure.
+ ********************************************************************************************/
+int sys_write( uint32_t   file_id,
+               void     * buf,
+               uint32_t   count );
+/*********************************************************************************************
+ * [16] This function epositions the offset of the file descriptor identified by <file_id>,
+ * according to the operation type defined by the <whence> and <offset> arguments.
+ *********************************************************************************************
+ * @ file_id  : open file index in fd_array.
+ * @ offset   : buffer virtual address in user space.
+ * @ whence   : operation type (see below).
+ * @ return 0 if success / returns -1 if failure.
+ ********************************************************************************************/
+int sys_lseek( xptr_t    file_id,
+               uint32_t  offset,
+               uint32_t  whence );
+typedef enum
+{
+    SEEK_SET  = 0,     /*! new_offset <= offset                                             */
+    SEEK_CUR  = 1,     /*! new_offset <= current_offset + offset                            */
+    SEEK_END  = 2,     /*! new_iffset <= current_size + offset                              */
+}
+lseek_operation_t;
+/*********************************************************************************************
+ * [17] This function release the memory allocated for the file descriptor identified by
+ * the <file_id> argument, and remove the fd array_entry in all copies of the process
+ * descriptor.
+ *********************************************************************************************
+  file_id   : file descriptor index in fd_array.
+ * @ return 0 if success / returns -1 if failure.
+ ********************************************************************************************/
+int sys_close( uint32_t file_id );
+/*********************************************************************************************
+ * [18] This function removes a directory entry identified by the <pathname> from its
+ * directory, and decrement the link count of the file referenced by the link.
+ * If the link count reduces to zero, and no process has the file open, then all resources
+ * associated with the file are reclaimed.  If one or more process have the file open when
+ * the last link is removed, the link is removed, but the removal of the file is delayed
+ * until all references to it have been closed.
+ *********************************************************************************************
+ * @ pathname   : pathname (can be relative or absolute).
+ * @ return 0 if success / returns -1 if failure.
+ ********************************************************************************************/
+int sys_unlink( char * pathname );
+/*********************************************************************************************
+ * [19] This function creates in the calling thread cluster an unnamed pipe, and two
+ * (read and write) file descriptors.
+ *********************************************************************************************
+ * @ file_id[0] : [out] read only file descriptor index.
+ * @ file_id[1] : [out] write only file descriptor index.
+ * @ return 0 if success / return -1 if failure.
+ ********************************************************************************************/
+int sys_pipe( uint32_t file_id[2] );
+/*********************************************************************************************
+ * [20] This function change the current working directory in reference process descriptor.
+ *********************************************************************************************
+ * @ pathname   : pathname (can be relative or absolute).
+ * @ return 0 if success / returns -1 if failure.
+ ********************************************************************************************/
+int sys_chdir( char * pathname );
+/*********************************************************************************************
+ * [21] This function creates a new directory in file system.
+ *********************************************************************************************
+ * @ pathname   : pathname (can be relative or absolute).
+ * @ mode       : access rights (as defined in chmod).
+ * @ return 0 if success / returns -1 if failure.
+ ********************************************************************************************/
+int sys_mkdir( char      pathname,
+               uint32_t  mode );
+/*********************************************************************************************
+ * [22] This function creates a named FIFO file in the calling thread cluster.
+ * The associated read and write file descriptors mut be be  explicitely created
+ * using the sy_open() function.
+ *********************************************************************************************
+ * @ pathname   : pathname (can be relative or absolute).
+ * @ mode       : access rights (as defined in chmod).
+ * @ return 0 if success / returns -1 if failure.
+ ********************************************************************************************/
+int sys_mkfifo( char     * pathname,
+                uint32_t   mode );
+/*********************************************************************************************
+ * [23] This function open a directory, that must exist in the file system.
+ *********************************************************************************************
+ * @ pathname   : pathname (can be relative or absolute).
+ * @ return file descriptor index in fd_array if success / return -1 if failure.
+ ********************************************************************************************/
+int sys_opendir( char * pathname );
+/*********************************************************************************************
+ * [24] This function returns in the structure pointed by the <dirent> argument various
+ * information about an entry of the directory identified by the <file_id> argument.
+ *********************************************************************************************
+ * @ file_id   : file descriptor index of the searched directory.
+ * @ dirent    : pointer on a dirent structure in user space.
+ * @ return 0 if success / returns -1 if failure.
+ ********************************************************************************************/
+int sys_readdir( uint32_t              file_id,
+                 struct vfs_dirent_s * dirent );
+/*********************************************************************************************
+ * [25] This function close the file descriptor previouly open by the opendir() function.
+ *********************************************************************************************
+ * @ file_id   : file descriptor index of the searched directory.
+ * @ return 0 if success / returns -1 if failure.
+ ********************************************************************************************/
+int sys_closedir( uint32_t file_id );
+/*********************************************************************************************
+ * [26] This function returns the pathname of the current working directory.
+ *********************************************************************************************
+ * buf     : buffer addres in user space.
+ * nbytes  : user buffer size in bytes.
+ * @ return 0 if success / returns -1 if failure.
+ ********************************************************************************************/
+int sys_getcwd( char     * buf,
+                uint32_t   nbytes );
+/*********************************************************************************************
+ * [27] This function returns in a 64 bits user buffer the calling core cycles count.
+ * It uses both the hardware register and the core descriptor cycles count tos take
+ * into account a possible harware register overflow  in 32 bits architectures.
+ *********************************************************************************************
+ * cyles    : [out] address of buffer in user space.
+ ********************************************************************************************/
+int sys_clock( uint64_t * cycles );
+/*********************************************************************************************
+ * [28] This function forces the calling thread to sleep, for a fixed number of cycles.
+ *********************************************************************************************
+ * cycles   : number of cycles.
+ ********************************************************************************************/
+int sys_alarm( uint32_t cycles );
+/*********************************************************************************************
+ * [29] This undefined function does nothing.
+ *********************************************************************************************
+ * @ pathname   : pathname (can be relative or absolute).
+ * @ return 0 if success / returns -1 if failure.
+ ********************************************************************************************/
+int sys_rmdir( char * pathname );
+/*********************************************************************************************
+ * [30] This function implement the operations related to User Thread Local Storage.
+ * It is actually implemented as an uint32_t variable in the thread descriptor.
+ *********************************************************************************************
+ * @ operation  : UTLS operation type as defined below.
+ * @ value      : argument value for the UTLS_SET operation.
+ * @ return value for the UTLS_GET and UTLS_GET_ERRNO / return -1 if failure.
+ ********************************************************************************************/
+int sys_utls( uint32_t operation,
+              uint32_t value );
+typedef enum
+{
+    UTLS_SET       = 1,
+    UTLS_GET       = 2,
+    UTLS_GET_ERRNO = 3,
+}
+utls_operation_t;
+/*********************************************************************************************
+ * [31] This function change the acces rights for the file/dir identified by the
+ * pathname argument.
+ *********************************************************************************************
+ * @ pathname   : pathname (can be relative or absolute).
+ * @ rights     : acces rights.
+ * @ return 0 if success / returns -1 if failure.
+ ********************************************************************************************/
+int sys_chmod( char     * pathname,
+               uint32_t   rights );
+/*********************************************************************************************
+ * [32] This function associate a specific signal handler to a given signal type.
+ * Tee handlers for the SIGKILL and SIGSTOP signals cannot be redefined.
+ *********************************************************************************************
+ * @ sig_id    : index defining signal type (from 1 to 31).
+ * @ handler   : pointer on fonction implementing the specific handler.
+ * @ return 0 if success / returns -1 if failure.
+ ********************************************************************************************/
+int sys_signal( uint32_t   sig_id,
+                void     * handler );
+/*********************************************************************************************
+ * [33] This function returns in the structure <tv>, defined in the time.h file,
+ * the current time (in seconds & micro-seconds).
+ * It is computed from the calling core descriptor.
+ * The timezone is not supported.
+ *********************************************************************************************
+ * @ tv      : pointer on the timeval structure.
+ * @ tz      : pointer on the timezone structure : must be NULL.
+ * @ return 0 if success / returns -1 if failure.
+ ********************************************************************************************/
+int sys_gettimeofday( struct timeval  * tv,
+                      struct timezone * tz );
 /*********************************************************************************************
  * [34] This function implements the "kill" system call.
+ * It register the signal identified by the <sig> argument in all thread descriptors
+ * of process identified by the <pid> argument.
+ * It register the signal defined by the <sig_id> argument in all thread descriptors
+ * of a target process identified by the <pid> argument. This is done in all clusters
+ * containing threads for the target process.
+ * It can be executed by any thread running in any cluster, as this function uses
+ * remote access to traverse the list of process copies in the owner cluster,
+ * and the RPC_SIGNAL_RISE to signal the remote threads.
  *********************************************************************************************
  * @ pid      : target process identifier.
+ * @ sig      : signal index.
+ * @ sig_id   : index defining the signal type (from 1 to 31).
+ * @ return 0 if success / returns -1 if failure.
  ********************************************************************************************/
 int sys_kill( pid_t    pid,
+              uint32_t sig );
+/*********************************************************************************************
+ * [35] This function TODO
+              uint32_t sig_id );
+/*********************************************************************************************
+ * [35] This function implements the "getpid" system call.
+ *********************************************************************************************
+ * @ returns the PID for the calling thread.
  ********************************************************************************************/
 int sys_getpid();
 …
  * The calling process descriptor (parent process), and the associated thread descriptor are
  * replicated in the same cluster as the calling thread, but the new process (child process)
  * is registered in another target cluster, that will become the process owner.
+ * is registered in another target cluster, that is the new process owner.
  * The child process and the associated main thread will be migrated to the target cluster
  * later, when the child process makes an "exec" or any other system call.
 …
  * [37] This function implement the "exec" system call.
  * It is executed in the client cluster, but the new process descriptor and main thread
+ * must be created in a server cluster, that is generally another cluster, using a RPC.
+ * - If the server_cluster is the client cluster, call directly make_exec() in local
+ *   mode, to change the process image and launch a new thread in local cluster.
+ *   finally, the old thread is deleted.
+ * - If the target_cluster is remote, call rpc_process_exec_client() to execute the
+ *   make_exec() in remote mode on the remote cluster, to create a new process
+ *   descriptor and a new thread on remote cluster. Finally, both the local
+ *   process descriptor and the local thread descriptor are deleted.
+ * must be created in a server cluster, that is generally another cluster.
+ * - if the server_cluster is the client cluster, call directly the process_make_exec()
+ *   function to create a new process, and launch a new thread in local cluster.
+ * - if the target_cluster is remote, call rpc_process_exec_client() to execute the
+ *   process_make_exec() on the remote cluster.
  * In both case this function build an exec_info_t structure containing all informations
  * required to build the new process descriptor and the associated thread, including
  * the mode (local/remote).
+ * required to build the new process descriptor and the associated thread.
+ * Finally, the calling process and thread are deleted.
  *********************************************************************************************
  * @ filename : string pointer on .elf filename (virtual pointer in user space)
  * @ argv     : array of strings on process arguments (virtual pointers in user space)
  * @ envp     : array of strings on Renvironment variables (virtual pointers in user space)
  * @ returns O if success / returns non-zero if error.
+ * @ returns O if success / returns -1 if failure.
  ********************************************************************************************/
 int sys_exec( char  * filename,
 …
 /*********************************************************************************************
+ * [38] This function TODO
+ ********************************************************************************************/
+int sys_thread_getattr();
+/*********************************************************************************************
+ * [39] This function implements the ps system call.
+ ********************************************************************************************/
+int sys_ps( uint32_t cmd,
+            pid_t    pid,
+            uint32_t tid );
+/*********************************************************************************************
+ * [40] This function TODO
+ ********************************************************************************************/
+int sys_madvise();
+/*********************************************************************************************
+ * [41] This function TODO
+ ********************************************************************************************/
+int sys_mcntl();
+/*********************************************************************************************
+ * [42] This function TODO
+ ********************************************************************************************/
+int sys_stat();
+/*********************************************************************************************
+ * [43] This function TODO
+ ********************************************************************************************/
+int sys_thread_migrate();
+/*********************************************************************************************
+ * [44] This function TODO
+ ********************************************************************************************/
+int sys_sbrk();
+/*********************************************************************************************
+ * [45] This function TODO
+ ********************************************************************************************/
+int sys_rmdir();
+/*********************************************************************************************
+ * [46] This function TODO
+ ********************************************************************************************/
+int sys_ftime();
+/*********************************************************************************************
+ * [47] This function TODO
+ ********************************************************************************************/
+int sys_chmod();
+/*********************************************************************************************
+ * [48] This function TODO
+ ********************************************************************************************/
+int sys_fsync();
+/*********************************************************************************************
+ * [49] This function TODO
+ ********************************************************************************************/
+int sys_gettimeofday();
+/*********************************************************************************************
+ * [50] This function TODO
+ ********************************************************************************************/
+int sys_times();
+ * [38] This function  returns in the <stat> structure, defined in the vfs.h file,
+ * various informations on the file/directory identified by the <file_id> argument.
+ *********************************************************************************************
+ * @ file_id   : file descriptor index in fd_array.
+ * @ stat      : pointer on the stat structure.
+ * @ returns O if success / returns -1 if failure.
+ ********************************************************************************************/
+int sys_stat( uint32_t            file_id,
+              struct vfs_stat_s * stat );
+/*********************************************************************************************
+ * [39] This function is used to activate / desactivate Rthe trace for a thread
+ * identified by the <trdid> and <pid> arguments.
+ * It can be called by any other thread.
+ *********************************************************************************************
+ * @ operation  : operation type as defined below.
+ * @ pid        : process identifier.
+ * @ trdid      : thread identifier.
+ * @ returns O if success / returns -1 if failure.
+ ********************************************************************************************/
+int sys_trace( uint32_t operation,
+               pid_t    pid,
+               uint32_t trdid );
+typedef enum
+{
+    TRACE_ON       = 0,
+    TRACE_OFF      = 1,
+}
+trace_operation_t;

trunk/kernel/vfs/fatfs.c

-                      r15
+                      r23
  * fatfs.c - FATFS file system API implementation.
+ *
  * Author    Mohamed Lamine Karaoui (2015)
  *           Alain Greiner (2016)
+ * Author    Mohamed Lamine Karaoui (2014,2015)
+ *           Alain Greiner (2016,2017)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
 #include <rpc.h>
 #include <mapper.h>
+#include <cluster.h>
 #include <dev_ioc.h>
 #include <fatfs.h>
 //////////////////////////////////////////////////////////////////////////////////////////
+//          Extern  variables
+//////////////////////////////////////////////////////////////////////////////////////////
+extern vfs_ctx_t        fs_context[FS_TYPES_NR];   // allocated in vfs.c file
+extern remote_barrier_t global_barrier;            // allocated dans kernel_init.c
 //////////////////////////////////////////////////////////////////////////////////////////
 // FATFS specific functions : these functions cannot be called by the VFS
 //////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////
 …
                                         uint32_t      cluster )
+{
     return (ctx->cluster_begin_lba + ((cluster - 2) * ctx->sectors_per_cluster));
+    return (ctx->cluster_begin_lba + ((cluster - 2) << 3));
+}
 …
 }  // end fatfs_get_cluster()
+///////////////////////////////////////////////////////////////////////////////////////
+// This static function return an integer record value (one, two, or four bytes)
+// from a memory buffer, taking into account endianness.
+///////////////////////////////////////////////////////////////////////////////////////
+// @ offset        : first byte of record in buffer.
+// @ size          : record length in bytes (1/2/4).
+// @ buffer        : pointer on buffer base.
+// @ little endian : the most significant byte has the highest address when true.
+// @ return the integer value in a 32 bits word.
+///////////////////////////////////////////////////////////////////////////////////////
+static uint32_t get_record_from_buffer( uint32_t    offset,
+                                        uint32_t    size,
+                                        uint8_t   * buffer,
+                                        uint32_t    little_endian )
+{
+    uint32_t n;
+    uint32_t res  = 0;
+    if ( little_endian)
+    {
+        for( n = size ; n > 0 ; n-- ) res = (res<<8) | buffer[offset+n-1];
+    }
+    else
+    {
+        for( n = 0 ; n < size ; n++ ) res = (res<<8) | buffer[offset+n];
+    }
+    return res;
+}  // end get_record_from_buffer()
 …
 ///////////////////////////////////////////////////////////////////////////////////////
+//          The following functions are called by the VFS.
 ///////////////////////////////////////////////////////////////////////////////////////
+// Generic API : the following functions are called by the VFS,
+//               and must be defined by all isupported file systems.
+///////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////
+error_t fatfs_inode_create( struct vfs_inode_s * vfs_inode )
+{
+    printk("\n[PANIC] %s not fully implemented yet\n", __FUNCTION__ );
+    hal_core_sleep();
+///////////////////
+xptr_t fatfs_init()
+{
+    kmem_req_t    req;
+    fatfs_ctx_t * fatfs_ctx;       // local pointer on FATFS context
+    vfs_ctx_t   * vfs_ctx;         // local pointer on VFS context
+    xptr_t        root_inode_xp;   // extended pointer on root inode
+    error_t       error;
+    // get local pointer on VFS context for FATFS
+    vfs_ctx = &fs_context[FS_TYPE_FATFS];
+    // get number of kernel instances and extended pointer on global barrier
+    cluster_t * cluster     = LOCAL_CLUSTER;
+    uint32_t    nb_clusters = cluster->x_size * cluster->y_size;
+    xptr_t      barrier_xp  = XPTR( cluster->io_cxy , &global_barrier );
+    ///// step 1 : all clusters allocate memory for FATFS context
+    // allocate memory for FATFS context extension
+        req.type    = KMEM_FATFS_CTX;
+        req.size    = sizeof(fatfs_ctx_t);
+    req.flags   = AF_KERNEL | AF_ZERO;
+        fatfs_ctx   = (fatfs_ctx_t *)kmem_alloc( &req );
+    if( fatfs_ctx == NULL )
+    {
+        printk("\n[PANIC] in %s : no memory for FATFS context\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
+    ///// step 2 : only cluster_0 access device and creates root inode
+    if( local_cxy == 0 )
+    {
+        // create VFS root inode
+        error = vfs_inode_create( XPTR_NULL,        // no parent dentry
+                                  FS_TYPE_FATFS,
+                                  INODE_TYPE_DIR,
+,                // attr
+,                // rights
+,                // uid
+,                // gid
+                                  &root_inode_xp );
+        assert( (error == 0 ) , __FUNCTION__ , "cannot create VFS root inode" );
+        // initialize VFS context / access device to initialize FATFS context
+        error = fatfs_ctx_init( vfs_ctx,
+                                fatfs_ctx,
+                                root_inode_xp );
+        // create FATFS root inode
+        error = fatfs_inode_create( GET_PTR( root_inode_xp ) ,
+                                    fatfs_ctx->root_dir_cluster );
+        if( error )
+        {
+            printk("\n[PANIC] in %s : cannot create FATFS root inode\n", __FUNCTION__ );
+            hal_core_sleep();
+        }
+    }
+    //////////////// synchronize all clusters
+    remote_barrier( barrier_xp , nb_clusters );
+    ///// step 3 : all others clusters initialize both context and extension
+    if( local_cxy != 0 )
+    {
+        // copy VFS context from remote cluster_0 to local cluster
+        hal_remote_memcpy( XPTR( local_cxy , vfs_ctx ),
+                           XPTR( 0 , vfs_ctx ),
+                           sizeof(vfs_ctx_t) );
+        // copy FATFS context from remote cluster_0 to local cluster
+        hal_remote_memcpy( XPTR( local_cxy , fatfs_ctx ),
+                           XPTR( 0 , vfs_ctx->extend ) ,
+                           sizeof(fatfs_ctx_t) );
+        // update extend field in local copy of VFS context
+        vfs_ctx->extend = fatfs_ctx;
+    }
+    return root_inode_xp;
+}  // end fatfs_init()
+//////////////////////////////////////////////
+error_t fatfs_ctx_init( vfs_ctx_t   * vfs_ctx,
+                        fatfs_ctx_t * fatfs_ctx,
+                        xptr_t        root_inode_xp )
+{
+    error_t  error;
+    uint8_t  buffer[512];    // buffer for boot record
+    // make a synchronous access to IOC device to read the boot record from device
+    error = dev_ioc_sync_read( buffer , 0 , 1 );
+    assert( (error == 0) , __FUNCTION__ , "cannot access FAT boot record" );
+    // check sector size from boot record
+    uint32_t sector_size = get_record_from_buffer( BPB_BYTSPERSEC , buffer , 1 );
+    assert( (sector_size == 512) , __FUNCTION__ , "sector size must be 512 bytes" );
+    // check cluster size from boot record
+    uint32_t nb_sectors = get_record_from_buffer( BPB_SECPERCLUS , buffer , 1 );
+    assert( (nb_sectors == 8) , __FUNCTION__ , "cluster size must be 8 sectors" );
+    // check number of FAT copies from boot record
+    uint32_t nb_fats = get_record_from_buffer( BPB_NUMFATS , buffer , 1 );
+    assert( (nb_fats == 1) , __FUNCTION__ , "number of FAT copies must be 1" );
+    // get & check number of sectors in FAT from boot record
+    uint32_t fat_sectors = get_record_from_buffer( BPB_FAT32_FATSZ32 , buffer , 1 );
+    assert( ((fat_sectors & 0xF) == 0) , __FUNCTION__ , "FAT not multiple of 16 sectors");
+    // get and check root cluster from boot record
+    uint32_t root_cluster = get_record_from_buffer( BPB_FAT32_ROOTCLUS , buffer , 1 );
+    assert( (root_cluster == 2) , __FUNCTION__ , "Root cluster index must be  2");
+    // get FAT lba from boot record
+    uint32_t fat_lba = get_record_from_buffer( BPB_RSVDSECCNT , buffer , 1 );
+    // allocate a mapper for the FAT itself
+    mapper_t * fat_mapper = mapper_create();
+    assert( (fat_mapper != NULL) , __FUNCTION__ , "no memory for FAT mapper" );
+    // initialize the FATFS context
+    fatfs_ctx->fat_begin_lba         = fat_lba;
+    fatfs_ctx->fat_sectors_count     = fat_sectors;
+    fatfs_ctx->bytes_per_sector      = sector_size;
+    fatfs_ctx->bytes_per_cluster     = sector_size * nb_sectors;
+    fatfs_ctx->cluster_begin_lba     = fat_lba + fat_sectors;
+    fatfs_ctx->root_dir_cluster      = 2;
+    fatfs_ctx->last_allocated_sector = 0;    // TODO ???
+    fatfs_ctx->last_allocated_index  = 0;    // TODO ???
+    fatfs_ctx->fat_mapper_xp         = XPTR( local_cxy , fat_mapper );
+    // initialize the VFS context
+    vfs_ctx->type    = FS_TYPE_FATFS;
+    vfs_ctx->attr    = 0;                    // not READ_ONLY / not SYNC
+    vfs_ctx->count   = fat_sectors << 10;    // total number of sectors in data region
+    vfs_ctx->blksize = 512;                  // number of bytes per sector
+    vfs_ctx->root_xp = root_inode_xp;
+    vfs_ctx->extend  = fatfs_ctx;
+    spinlock_init( &vfs_ctx->lock );
+    bitmap_init( vfs_ctx->bitmap , CONFIG_VFS_MAX_INODES );
+    return 0;
+}  // end fatfs_ctx_init()
+////////////////////////////////////////////////////
+void fatfs_ctx_destroy( struct vfs_ctx_s * vfs_ctx )
+{
+    kmem_req_t    req;
+    fatfs_ctx_t * fatfs_ctx;
+    // get pointer on FATFS context extension
+    fatfs_ctx = (fatfs_ctx_t *)vfs_ctx->extend;
+    req.type = KMEM_FATFS_INODE;
+    req.ptr  = fatfs_ctx;
+    kmem_free( &req );
+}
+////////////////////////////////////////////////////
+error_t fatfs_inode_create( vfs_inode_t * vfs_inode,
+                            uint32_t      first_cluster )
+{
     kmem_req_t      req;
     fatfs_inode_t * fatfs_inode;
     // allocate memory for fatfs inode
+    // allocate memory for FATFS inode extension
         req.type    = KMEM_FATFS_INODE;
         req.size    = sizeof(fatfs_inode_t);
 …
     if( fatfs_inode == NULL ) return ENOMEM;
+    // initialise ramfs_inode
+    fatfs_inode->first_cluster = 0;   // TODO ???
+    fatfs_inode->ctx           = (fatfs_ctx_t *)vfs_inode->ctx->extend;
+    // link FATFS inode to VFS inode
+    vfs_inode->extend = fatfs_inode;
+    // initialise FATFS inode
+    fatfs_inode->first_cluster = first_cluster;
-    // link fatfs_inode to vfs_inode
-    vfs_inode->extend = fatfs_inode;
     return 0;
+}
+//////////////////////////////////////////////////////
+void fatfs_inode_destroy( struct vfs_inode_s * inode )
+{
+    printk("\n[PANIC] %s not fully implemented yet\n", __FUNCTION__ );
+    hal_core_sleep();
+}
+//////////////////////////////////////////////////
+error_t fatfs_ctx_create( struct vfs_ctx_s * ctx )
+{
+    printk("\n[PANIC] %s not fully implemented yet\n", __FUNCTION__ );
+    hal_core_sleep();
+    return 0;
+}
+////////////////////////////////////////////////
+void fatfs_ctx_destroy( struct vfs_ctx_s * ctx )
+{
+    printk("\n[PANIC] %s not fully implemented yet\n", __FUNCTION__ );
+    hal_core_sleep();
+}
+}
+///////////////////////////////////////////////////
+void fatfs_inode_destroy( vfs_inode_t * vfs_inode )
+{
+    kmem_req_t      req;
+    fatfs_inode_t * fatfs_inode;
+    // get pointer on FATFS inode
+    fatfs_inode = (fatfs_inode_t *)vfs_inode->extend;
+    req.type = KMEM_FATFS_INODE;
+    req.ptr  = fatfs_inode;
+    kmem_free( &req );
+        vfs_inode->extend = NULL;
+}
 ////////////////////////////////////////////////
 …
                                   bool_t   is_read )
+{
     // get source buffer base address
     char * buffer = (char *)ppm_page2base( page );
+    // get memory buffer base address
+    uint8_t * buffer = (uint8_t *)ppm_page2base( page );
     // get pointer on source mapper and page index from page descriptor
     mapper_t * src_mapper  = page->mapper;
+    mapper_t * mapper      = page->mapper;
     uint32_t   page_index  = page->index;
-    if( src_mapper == NULL)
+    {
-        printk("\n[PANIC] in %s : no mapper for this page\n", __FUNCTION__ );
-        hal_core_sleep();
+    }
     // get VFS inode pointer from mapper
     vfs_inode_t * vfs_inode = src_mapper->inode;
+    vfs_inode_t * vfs_inode = mapper->inode;
     // get FATFS inode pointer for VFS inode
 …
     // get FATFS context pointer from FATFS inode
     fatfs_ctx_t * fatfs_ctx = fatfs_inode->ctx;
+    fatfs_ctx_t * fatfs_ctx = (fatfs_ctx_t *)vfs_inode->ctx->extend;
     // get number of sectors

trunk/kernel/vfs/fatfs.h

-                      r15
+                      r23
  * fatfs.h - FATFS file system API definition.
+ *
  * Author    Mohamed Lamine Karaoui (2015)
  *           Alain Greiner (2016)
+ * Author    Mohamed Lamine Karaoui (2014,2015)
+ *           Alain Greiner (2016,2017)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
 #include <hal_types.h>
 #include <rwlock.h>
+#include <vfs.h>
+///////////////////////////////////////////////////////////////////////////////////////////
+// The FATFS File System implements a FAT32 read/write file system.
+///////////////////////////////////////////////////////////////////////////////////////////
+/*************** Partition Boot Sector Format **********************************/
+//                                     offset |  length
+#define BS_JMPBOOT                          0 ,  3
+#define BS_OEMNAME                          3 ,  8
+#define BPB_BYTSPERSEC                     11 ,  2
+#define BPB_SECPERCLUS                     13 ,  1
+#define BPB_RSVDSECCNT                     14 ,  2
+#define BPB_NUMFATS                        16 ,  1
+#define BPB_ROOTENTCNT                     17 ,  2
+#define BPB_TOTSEC16                       19 ,  2
+#define BPB_MEDIA                          21 ,  1
+#define BPB_FATSZ16                        22 ,  2
+#define BPB_SECPERTRK                      24 ,  2
+#define BPB_NUMHEADS                       26 ,  2
+#define BPB_HIDDSEC                        28 ,  4
+#define BPB_TOTSEC32                       32 ,  4
+#define BPB_PARTITION_TABLE               446 , 64
+// FAT 32
+#define BPB_FAT32_FATSZ32                  36 ,  4
+#define BPB_FAT32_EXTFLAGS                 40 ,  2
+#define BPB_FAT32_FSVER                    42 ,  2
+#define BPB_FAT32_ROOTCLUS                 44 ,  4
+#define BPB_FAT32_FSINFO                   48 ,  2
+#define BPB_FAT32_BKBOOTSEC                50 ,  2
+#define BS_FAT32_DRVNUM                    64 ,  1
+#define BS_FAT32_BOOTSIG                   66 ,  1
+#define BS_FAT32_VOLID                     67 ,  4
+#define BS_FAT32_VOLLAB                    71 , 11
+#define BS_FAT32_FILSYSTYPE                82 ,  8
+// Partitions
+#define FIRST_PARTITION_ACTIVE            446 ,  8
+#define FIRST_PARTITION_BEGIN_LBA         454 ,  4
+#define FIRST_PARTITION_SIZE              458 ,  4
+#define SECOND_PARTITION_ACTIVE           462 ,  8
+#define SECOND_PARTITION_BEGIN_LBA        470 ,  4
+#define SECOND_PARTITION_SIZE             474 ,  4
+#define THIRD_PARTITION_ACTIVE            478 ,  8
+#define THIRD_PARTITION_BEGIN_LBA         486 ,  4
+#define THIRD_PARTITION_SIZE              490 ,  4
+#define FOURTH_PARTITION_ACTIVE           494 ,  8
+#define FOURTH_PARTITION_BEGIN_LBA        502 ,  4
+#define FOURTH_PARTITION_SIZE             506 ,  4
+/*******************************************************************************/
+#define MBR_SIGNATURE_POSITION            510 , 2
+#define MBR_SIGNATURE_VALUE               0xAA55
+/************** FAT_FS_INFO SECTOR  ********************************************/
+#define FS_SIGNATURE_VALUE_1              0x52526141
+#define FS_SIGNATURE_VALUE_2              0x72724161
+#define FS_SIGNATURE_VALUE_3              0x000055AA
+#define FS_SIGNATURE_POSITION_1           0   , 4
+#define FS_SIGNATURE_POSITION_2           484 , 4
+#define FS_SIGNATURE_POSITION_3           508 , 4
+#define FS_FREE_CLUSTERS                  488 , 4
+#define FS_FREE_CLUSTER_HINT              492 , 4
+/*******************************************************************************/
+#define DIR_ENTRY_SIZE          32
+#define NAME_MAX_SIZE           31
+/******* Directory Entry Structure (32 bytes) **********************************/
+//                            offset | length
+#define DIR_NAME                   0 , 11   // dir_entry name
+#define DIR_ATTR                  11 ,  1   // attributes
+#define DIR_NTRES                 12 ,  1   // reserved for the OS
+#define DIR_CRT_TIMES_TENTH       13 ,  1
+#define DIR_FST_CLUS_HI           20 ,  2   // cluster index 16 MSB bits
+#define DIR_WRT_TIME              22 ,  2   // time of last write
+#define DIR_WRT_DATE              24 ,  2   // date of last write
+#define DIR_FST_CLUS_LO           26 ,  2   // cluster index 16 LSB bit
+#define DIR_FILE_SIZE             28 ,  4   // dir_entry size (up to 4 Gbytes)
+/*******************************************************************************/
+/******* LFN Directory Entry Structure  (32 bytes) *****************************/
+//                            offset | length
+#define LDIR_ORD                   0 ,  1   // Sequence number (from 0x01 to 0x0f)
+#define LDIR_NAME_1                1 , 10   // name broken into 3 parts
+#define LDIR_ATTR                 11 ,  1   // attributes (must be 0x0F)
+#define LDIR_TYPE                 12 ,  1   // directory type (must be 0x00)
+#define LDIR_CHKSUM               13 ,  1   // checksum of name in short dir
+#define LDIR_NAME_2               14 , 12
+#define LDIR_RSVD                 26 ,  2   // artifact of previous fat (must be 0)
+#define LDIR_NAME_3               28 ,  4
+/*******************************************************************************/
+/***********************  DIR_ATTR values  (attributes) ************************/
+#define ATTR_READ_ONLY            0x01
+#define ATTR_HIDDEN               0x02
+#define ATTR_SYSTEM               0x04
+#define ATTR_VOLUME_ID            0x08
+#define ATTR_DIRECTORY            0x10
+#define ATTR_ARCHIVE              0x20
+#define ATTR_LONG_NAME_MASK       0x0f      // READ_ONLY|HIDDEN|SYSTEM|VOLUME_ID
+/*******************************************************************************/
+/********************* DIR_ORD special values **********************************/
+#define FREE_ENTRY                0xE5     // this entry is free in the directory
+#define NO_MORE_ENTRY             0x00     // no more entry in the directory
+/*******************************************************************************/
+/******************** CLuster Index Special Values *****************************/
+#define FREE_CLUSTER              0x00000000
+#define RESERVED_CLUSTER          0x00000001
+#define BAD_CLUSTER               0x0FFFFFF7
+#define END_OF_CHAIN_CLUSTER_MIN  0x0ffffff8
+#define END_OF_CHAIN_CLUSTER_MAX  0x0fffffff
+/*******************************************************************************/
 /****  Forward declarations  ****/
 struct mapper_s;
+struct device_s;
+struct page_s;
+struct vfs_ctx_s;
 struct vfs_inode_s;
+struct vfs_ctx_s;
+struct page_s;
+/*****************************************************************************************
+ * This structure defines a FATFS specific context extension.
+/*****************************************************************************************
+ * This structure defines a FATFS specific context (extension to VFS context).
  ****************************************************************************************/
 typedef struct fatfs_ctx_s
+{
+    rwlock_t          lock;                  /*! TODO protect what ???                  */
+    uint32_t          fat_begin_lba;         /*! first lba of FAT region                */
+    uint32_t          fat_begin_lba;         /*! lba of FAT region                      */
     uint32_t          fat_sectors_count;     /*! number of sectors in FAT region        */
     uint32_t          bytes_per_sector;      /*!                                        */
     uint32_t          bytes_per_cluster;     /*!                                        */
     uint32_t          cluster_begin_lba;     /*! first lba of data region on device     */
     uint32_t          sectors_per_cluster;   /*!                                        */
     uint32_t          rootdir_first_cluster; /*                                         */
     uint32_t          last_allocated_sector; /*!                                        */
     uint32_t          last_allocated_index;  /*! TODO last allocated cluster ???        */
     xptr_t            fat_mapper_xp;         /*! FAT mapper (in IO cluster)             */
+    uint32_t          cluster_begin_lba;     /*! lba of data region                     */
+    uint32_t          sectors_per_cluster;   /*! cluster index for root directory       */
+    uint32_t          root_dir_cluster;      /*!                                        */
+    uint32_t          last_allocated_sector; /*! TODO ???                               */
+    uint32_t          last_allocated_index;  /*! TODO ???                               */
+    xptr_t            fat_mapper_xp;         /*! FAT mapper (in IO cluster)             */
+}
 fatfs_ctx_t;
 /*****************************************************************************************
  * This structure defines the FAT specific inode extension (versus the VFS inode).
+ * This structure defines the FATFS specific inode (extension to VFS inode).
  ****************************************************************************************/
 typedef struct fatfs_inode_s
+{
+    struct fatfs_ctx_s * ctx;                /*! local pointer on the FATFS context     */
+        uint32_t             first_cluster;      /*! first cluster for this file/dir        */
+        uint32_t          first_cluster;         /*! first cluster for this file/dir        */
+}
 fatfs_inode_t;
 …
+//////////////////////////////////////////////////////////////////////////////////////////
+// These functions are specific to the FATFS, and cannot be called by the VFS.
+//////////////////////////////////////////////////////////////////////////////////////////
 /*****************************************************************************************
  * This function returns the LBA of the first sector of a FAT cluster.
 …
  * @ ctx          :     pointer on FATFS context.
  * @ cluster  : cluster index in FATFS.
  * # return the lba value.
+ * @ return the lba value.
  ****************************************************************************************/
 inline uint32_t fatfs_lba_from_cluster( fatfs_ctx_t * ctx,
 …
                            uint32_t        * cluster );
+//////////////////////////////////////////////////////////////////////////////////////////
+// These functions are called by the VFS, and must be implemented by all File Systems.
+//////////////////////////////////////////////////////////////////////////////////////////
+/******************************************************************************************
+ * This function initializes the FATFS file system as the root FS.
+ * It is executed cooperatively during kernel init by all CP0s in all clusters.
+ * The initilisation is made in three phases, separated by synchronisation barrier:
+ * - phase 1 : all CP0s in all clusters allocate memory for the local copy of
+ *   the FATFS context.
+ * - phase 2 : cluster_0 only creates the root inode descriptor, access the external
+ *   device to get information stored on the boot record, and initialises both
+ *   the VFS context, and the FATFS context.
+ * - phase 3 : all other clusters initialize their local VFS context and FATFS context
+ *   from values contained in cluster_0, using hal_remote_memcpy().
+ ******************************************************************************************
+ * @ return an extended pointer on the created root inode / return XPTR_NULL if failure.
+ *****************************************************************************************/
+xptr_t fatfs_init();
+/******************************************************************************************
+ * This function mount the FATFS on the root FS.
+ * TODO not implemented [AG]
+ ******************************************************************************************
+ * @ parent_inode_xp : extended pointer on the parent inode.
+ *****************************************************************************************/
+error_t fatfs_mount( xptr_t parent_inode_xp );
+/*****************************************************************************************
+ * This function  initializes both the VFS context and the FATFS context.
+ * Both the VFS context and the FATFS context must have been previously allocated.
+ * It access the device to read the boot record, and is supposed to be called only
+ * in cluster_0 (in other clusters these contexts are replicated from values
+ * contained in cluster_0).
+ *****************************************************************************************
+ * @ vfs_ctx        : local pointer on VFS context for FATFS.
+ * @ fatfs_ctx      : local pointer on specific FATFS context.
+ * @ root_inode_xp  : extended pointer on VFS root inode.
+ ****************************************************************************************/
+error_t fatfs_ctx_init( struct vfs_ctx_s   * vfs_ctx,
+                        struct fatfs_ctx_s * fatfs_ctx,
+                        xptr_t               root_inode_xp );
+/*****************************************************************************************
+ * This function releases memory dynamically allocated for the FATFS context extension.
+ *****************************************************************************************
+ * @ vfs_ctx   : local pointer on VFS context.
+ ****************************************************************************************/
+void fatfs_ctx_destroy( struct vfs_ctx_s * vfs_ctx );
 /*****************************************************************************************
  * This function allocates memory for a FATFS inode, initializes it,
  * and link it to the VFS inode.
  *****************************************************************************************
+ * @ inode         : local pointer on the VFS inode.
+ * @ first_cluster : first cluster index in the FAT32.
+ * @ return 0 if success / return ENOMEM if error.
+ ****************************************************************************************/
+error_t fatfs_inode_create( struct vfs_inode_s * inode,
+                            uint32_t             first_cluster);
+/*****************************************************************************************
+ * This function releases memory allocated for a FATFS inode.
+ *****************************************************************************************
  * @ inode   : local pointer on vfs_inode.
- * @ return 0 if success / return ENOMEM if error.
- ****************************************************************************************/
-error_t fatfs_inode_create( struct vfs_inode_s * inode );
-/*****************************************************************************************
- * This function releases memory allocated for a FATFS inode.
- *****************************************************************************************
- * @ inode   : local pointer on vfs_inode.
  ****************************************************************************************/
 void fatfs_inode_destroy( struct vfs_inode_s * inode );
+/*****************************************************************************************
+ * This function allocates memory for a FATFS context, initialises it,
+ * and link it to the local VFS context.
+ *****************************************************************************************
+ * @ inode   : local pointer on VFS context.
+ * @ return 0 if success / return ENOMEM if error.
+ ****************************************************************************************/
+error_t fatfs_ctx_create( struct vfs_ctx_s * ctx );
+/*****************************************************************************************
+ * This function releases memory allocated for a FATFS context.
+ *****************************************************************************************
+ * @ ctx   : local pointer on VFS context.
+ ****************************************************************************************/
+void fatfs_ctx_destroy( struct vfs_ctx_s * ctx );
+/*****************************************************************************************
+ * This function moves a page from the mapper to the FATFS file system.
+/*****************************************************************************************
+ * This function moves a page from the mapper to the FATFS file system on device.
  * It must be called by a thread running in cluster containing the mapper.
  * The pointer on the mapper and the page index in file are supposed to be registered
+ * The pointer on the mapper and the page index in file are registered
  * in the page descriptor.
  *****************************************************************************************
 …
  * This function moves a page from the FATFS file system on device to the mapper.
  * It must be called by a thread running in cluster containing the mapper.
  * The pointer on the mapper and the page index in file are supposed to be registered
+ * The pointer on the mapper and the page index in file are registered
  * in the page descriptor.
  *****************************************************************************************
 …
 #endif  /* _FATFS_H_ */

trunk/kernel/vfs/ramfs.c

-                      r15
+                      r23
  * ramfs.c  RAMFS file system API implementation.
+ *
  * Authors   Mohamed Lamine Karaoui (2015)
  *           Alain Greiner (2016)
+ * Authors   Mohamed Lamine Karaoui (2014,2015)
+ *           Alain Greiner (2016,2017)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
-///////////////////////////////////////////////////////////////////////////////////////
-// RAMFS specific functions : these static functions cannot be called by the VFS
-///////////////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////////////
+// Generic API : the following functions are called by the VFS,
+//               and must be defined by all supported file systems.
+//             The following functions are called by the VFS.
 ///////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////
+error_t ramfs_inode_create( struct vfs_inode_s * vfs_inode )
+//////////////////////////////////////////////
+error_t ramfs_mount( xptr_t   parent_inode_xp,
+                     char   * ramfs_root_name )
+{
+    printk("\n[PANIC] %s not fully implemented yet\n", __FUNCTION__ );
+    hal_core_sleep();
+    xptr_t        root_inode_xp;   // unused
+    // create VFS dentry and VFS inode for RAMFS root directory
+    return  vfs_add_child_in_parent( INODE_TYPE_DIR,
+                                     FS_TYPE_RAMFS,
+                                     parent_inode_xp,
+                                     ramfs_root_name,
+                                     &root_inode_xp );
+}
-    kmem_req_t      req;
-    ramfs_inode_t * ramfs_inode;
+    // allocate memory for ramfs inode
+        req.type    = KMEM_RAMFS_INODE;
+        req.size    = sizeof(ramfs_inode_t);
+    req.flags   = AF_KERNEL | AF_ZERO;
+        ramfs_inode = (ramfs_inode_t *)kmem_alloc( &req );
+////////////////////////////////////////////
+error_t ramfs_ctx_init( vfs_ctx_t * vfs_ctx,
+                        xptr_t      root_inode_xp )
+    if( ramfs_inode == NULL ) return ENOMEM;
+{
+    vfs_ctx->type    = FS_TYPE_RAMFS;
+    vfs_ctx->attr    = 0;                // not READ_ONLY / not SYNC
+    vfs_ctx->count   = 0;                // unused for RAMFS
+    vfs_ctx->blksize = 512;              // unused for RAMFS
+    vfs_ctx->root_xp = root_inode_xp;
+    vfs_ctx->extend  = NULL;             // unused for DEVFS
     // initialise ramfs_inode TODO
+    spinlock_init( &vfs_ctx->lock );
+    // link vfs_inode to ramfs_inode
+    vfs_inode->extend = ramfs_inode;
+    bitmap_init( vfs_ctx->bitmap , CONFIG_VFS_MAX_INODES );
     return 0;
+}
-//////////////////////////////////////////////////////
-void ramfs_inode_destroy( struct vfs_inode_s * inode )
+{
-    assert( false , __FUNCTION__ , "not fully implemented yet" );
+}
-/////////////////////////////////////////////////
-error_t ramfs_write_page( struct page_s  * page )
+{
-    printk("\n[PANIC] %s not fully implemented yet\n", __FUNCTION__ );
-    hal_core_sleep();
-    return 0;
+}
-////////////////////////////////////////////////
-error_t ramfs_read_page( struct page_s  * page )
+{
-    printk("\n[PANIC] %s not fully implemented yet\n", __FUNCTION__ );
-    hal_core_sleep();
-    return 0;
+}

trunk/kernel/vfs/ramfs.h

-                      r15
+                      r23
  * ramfs.h  RAMFS file system API definition.
+ *
  * Authors   Mohamed Lamine Karaoui (2015)
  *           Alain Greiner (2016)
+ * Authors   Mohamed Lamine Karaoui (2014,2015)
+ *           Alain Greiner (2016,2017)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
 #define _RAMFS_H_
+///////////////////////////////////////////////////////////////////////////////////////////
+// The RAMFS File System Rdoes not uses any external device to store data.
+// It stores the dynamically created files and directories in the VFS mappers.
+// The ramfs_read_page() and ramfs_write_page() functions should never be used.
+// The RAMFS cannot be used as the root FS.
+// There is no RAMFS context extension, and no RAMFS inode extension.
+///////////////////////////////////////////////////////////////////////////////////////////
 /****  Forward declarations  ****/
+struct vfs_inode_s;
+struct page_s;
+//////////////////////////////////////////////////////////////////////////////////////////
+// These functions are called by the VFS, and must be implemented by all FS.
+//////////////////////////////////////////////////////////////////////////////////////////
+/******************************************************************************************
+ * This function does not exist, as the RAMFS cannot be the root FS.
+ *****************************************************************************************/
+xptr_t ramfs_init();
+/******************************************************************************************
+ * This function mount a RAMFS on a given inode of the root FS.
+ * It actually creates a new VFS dentry in the cluster containing the parent inode,
+ * and create a new VFS inode in another cluster.
+ ******************************************************************************************
+ * @ parent_inode_xp : extended pointer on the parent inode.
+ * @ ramfs_root_name : RAMFS root directory name.
+ *****************************************************************************************/
+error_t ramfs_mount( xptr_t   parent_inode_xp,
+                     char   * ramfs_root_name );
 /*****************************************************************************************
+ * This structure defines a RAMFS specific context extension.
+ * This function initializes all fields of the VFS context.
+ * No extra memory is allocated for a RAMFS context.
  ****************************************************************************************/
+typedef struct ramfs_ctx_s
+{
+    intptr_t          base;
+    rwlock_t          size;
+}
+ramfs_ctx_t;
+error_t ramfs_ctx_init( struct vfs_ctx_s * vfs_ctx,
+                        xptr_t             root_inode_xp );
 /*****************************************************************************************
  * This structure defines the RAMFS inode specific extension (versus the VFS inode).
+ * This function does not exist for a RAMFS context, as there is no RAMFS context.
  ****************************************************************************************/
+typedef struct ramfs_inode_s
+{
+    struct vfs_inode_s * vfs_inode;   /*! local pointer on VFS inode                    */
+}
+ramfs_inode_t;
+error_t ramfs_ctx_destroy();
 /*****************************************************************************************
+ * This function allocates memory for a RAMFS inode, and link it to the VFS inode.
+ *****************************************************************************************
+ * @ inode   : local pointer on vfs_inode.
+ * @ return 0 if success / return ENOMEM if error.
+ * This function does not exist, as the RAMFS does not use a RAMFS inode extension.
  ****************************************************************************************/
 error_t ramfs_inode_create( struct vfs_inode_s * inode );
 /*****************************************************************************************
+ * This function releases memory allocated for a RAMFS inode.
+ *****************************************************************************************
+ * @ inode   : local pointer on vfs_inode.
+ * This function does not exist, as the RAMFS does not use a RAMFS inode extension.
  ****************************************************************************************/
 void ramfs_inode_destroy( struct vfs_inode_s * inode );
 /*****************************************************************************************
+ * This function moves a page from the mapper to the RAMFS file system.
+ * It must be called by a thread running in cluster containing the mapper.
+ * The pointer on the mapper and the page index in file are supposed to be registered
+ * in the page descriptor.
+******************************************************************************************
+ * @ page    : local pointer on source page descriptor.
+ * @ return 0 if success / return EIO if error.
+ * This function does nothing for the RAMFS File System.
  ****************************************************************************************/
 error_t ramfs_write_page( struct page_s  * page );
+error_t ramfs_write_page( struct page_s * page );
 /*****************************************************************************************
+ * This function moves a page from the RAMFS file system to the mapper.
+ * It must be called by a thread running in cluster containing the mapper.
+ * The pointer on the mapper and the page index in file are supposed to be registered
+ * in the page descriptor.
+ *****************************************************************************************
+ * @ page    : local pointer on destination page descriptor.
+ * @ return 0 if success / return EIO if error.
+ * This function does not exist for the RAMFS File System.
  ****************************************************************************************/
 error_t ramfs_read_page( struct page_s  * page );
+error_t ramfs_read_page( struct page_s * page );
 #endif  /* _RAMFS_H_ */

trunk/kernel/vfs/vfs.c

-                      r14
+                      r23
 #include <slist.h>
 #include <xhtab.h>
+#include <rpc.h>
 #include <errno.h>
 #include <kmem.h>
 …
 #include <thread.h>
 #include <process.h>
+#include <vfs.h>
 #include <fatfs.h>
 #include <ramfs.h>
+#include <vfs.h>
+#include <devfs.h>
+#include <syscalls.h>
 …
 //////////////////////////////////////////////////////////////////////////////////////////
 // array of supported FS contexts (indexed by the FS type)
+// array of supported FS contexts
 vfs_ctx_t   fs_context[FS_TYPES_NR];
 …
 //////////////////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////
+////////////////////////////////////////////
 error_t vfs_ctx_inum_alloc( vfs_ctx_t * ctx,
                             uint32_t  * inum )
 …
     // get lid from local inum allocator
     uint32_t lid = bitmap_ffc( ctx->inum , CONFIG_VFS_MAX_INODES );
+    uint32_t lid = bitmap_ffc( ctx->bitmap , CONFIG_VFS_MAX_INODES );
     if( lid == -1 )   // no more free slot => error
 …
+    {
         // set slot allocated
         bitmap_set( ctx->inum , lid );
+        bitmap_set( ctx->bitmap , lid );
         // release lock
 …
                            uint32_t    inum )
+{
     bitmap_clear( ctx->inum , inum & 0xFFFF );
+    bitmap_clear( ctx->bitmap , inum & 0xFFFF );
+}
 …
 //////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////
+error_t vfs_inode_create( xptr_t      dentry_xp,
+                          uint32_t    type,
+                          uint32_t    attr,
+                          uint32_t    mode,
+                          uid_t       uid,
+                          gid_t       gid,
+                          xptr_t    * inode_xp )
+//////////////////////////////////////////////////////
+error_t vfs_inode_create( xptr_t            dentry_xp,
+                          vfs_fs_type_t     fs_type,
+                          vfs_inode_type_t  inode_type,
+                          uint32_t          attr,
+                          uint32_t          rights,
+                          uid_t             uid,
+                          gid_t             gid,
+                          xptr_t          * inode_xp )
+{
     mapper_t         * mapper;     // associated mapper( to be allocated)
 …
     error_t            error;
+    // check type and get pointer on context
+    if     ( type == FS_TYPE_FATFS ) ctx = &fs_context[FS_TYPE_FATFS];
+    else if( type == FS_TYPE_RAMFS ) ctx = &fs_context[FS_TYPE_RAMFS];
+    // check fs type and get pointer on context
+    if     ( fs_type == FS_TYPE_FATFS ) ctx = &fs_context[FS_TYPE_FATFS];
+    else if( fs_type == FS_TYPE_RAMFS ) ctx = &fs_context[FS_TYPE_RAMFS];
+    else if( fs_type == FS_TYPE_DEVFS ) ctx = &fs_context[FS_TYPE_DEVFS];
     else
+    {
 …
+    }
     // allocate memory for inode descriptor
+    // allocate memory for VFS inode descriptor
         req.type  = KMEM_VFS_INODE;
         req.size  = sizeof(vfs_inode_t);
 …
     // initialize inode descriptor
     inode->gc         = 0;
+    inode->type       = inode_type;
     inode->inum       = inum;
     inode->attr       = attr;
     inode->mode       = mode;
+    inode->rights     = rights;
     inode->uid        = uid;
     inode->gid        = gid;
 …
     // initialize dentries hash table, if new inode is a directory
     if( attr & INODE_ATTR_DIR )  xhtab_init( &inode->children , XHTAB_DENTRY_TYPE );
+    if( inode_type == INODE_TYPE_DIR ) xhtab_init( &inode->children , XHTAB_DENTRY_TYPE );
     // initialize inode locks
     remote_rwlock_init( XPTR( local_cxy , &inode->data_lock ) );
     remote_spinlock_init( XPTR( local_cxy , &inode->main_lock ) );
-    // create FS specific inode
-    if     ( ctx->type == FS_TYPE_FATFS )  fatfs_inode_create( inode );
-    else if( ctx->type == FS_TYPE_RAMFS )  ramfs_inode_create( inode );
     // return extended pointer on inode
 …
 //////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////
 error_t vfs_dentry_create( uint32_t      type,
                            char        * name,
                            vfs_inode_t * parent,
                            xptr_t      * dentry_xp )
+///////////////////////////////////////////////////
+error_t vfs_dentry_create( vfs_fs_type_t   fs_type,
+                           char          * name,
+                           vfs_inode_t   * parent,
+                           xptr_t        * dentry_xp )
+{
     vfs_ctx_t      * ctx;        // context descriptor
     vfs_dentry_t   * dentry;     // dentry descriptor (to be allocated)
         kmem_req_t       req;        // request to kernel memory allocator
+    xptr_t           xhtab_xp;   // extended pointer on xhtab_t embedded in inode
+    xptr_t           xlist_xp;   // extended pointer on xlist_entry_t in dentry
+printk("\n            @@@ dentry_create : 0 / name = %s\n", name );
     // check type and get pointer on context
+    if     ( type == FS_TYPE_FATFS ) ctx = &fs_context[FS_TYPE_FATFS];
+    else if( type == FS_TYPE_RAMFS ) ctx = &fs_context[FS_TYPE_RAMFS];
+    if     ( fs_type == FS_TYPE_FATFS ) ctx = &fs_context[FS_TYPE_FATFS];
+    else if( fs_type == FS_TYPE_RAMFS ) ctx = &fs_context[FS_TYPE_RAMFS];
+    else if( fs_type == FS_TYPE_DEVFS ) ctx = &fs_context[FS_TYPE_DEVFS];
     else
+    {
 …
     uint32_t length = strlen( name );
     if( length > (CONFIG_VFS_MAX_NAME_LENGTH - 1) )
+    if( length >= CONFIG_VFS_MAX_NAME_LENGTH )
+    {
         printk("\n[ERROR] in %s : name too long\n", __FUNCTION__ );
         return EINVAL;
+    }
+printk("\n            @@@ dentry_create : 1 / name = %s\n", name );
     // allocate memory for dentry descriptor
 …
     // initialize dentry descriptor
     dentry->ctx     = ctx;
     dentry->length  = length;
 …
     strcpy( dentry->name , name );
+    // return extended pointer on dentry to caller
+printk("\n            @@@ dentry_create : 2 / name = %s\n", name );
+    // register dentry in hash table rooted in parent inode
+    xhtab_insert( XPTR( local_cxy , &parent->children ),
+                  name,
+                  XPTR( local_cxy , &dentry->xlist ) );
+printk("\n            @@@ dentry_create : 3 / name = %s\n", name );
+    // return extended pointer on dentry
     *dentry_xp = XPTR( local_cxy , dentry );
-    // register dentry in hash table rooted in parent inode
-    xhtab_xp    = XPTR( local_cxy , &parent->children );
-    xlist_xp    = XPTR( local_cxy , &dentry->xlist );
-    xhtab_register( xhtab_xp  , name , xlist_xp );
     return 0;
 …
 //////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////
+void vfs_file_count_up( xptr_t file_xp )
+{
+    // get file cluster and local pointer
+    cxy_t        file_cxy = GET_CXY( file_xp );
+    vfs_file_t * file_ptr = (vfs_file_t *)GET_PTR( file_xp );
+    // atomically increment count
+    hal_remote_atomic_add( XPTR( file_cxy , &file_ptr->refcount ) , 1 );
+}
+//////////////////////////////////////////
+void vfs_file_count_down( xptr_t file_xp )
+{
+    // get file cluster and local pointer
+    cxy_t        file_cxy = GET_CXY( file_xp );
+    vfs_file_t * file_ptr = (vfs_file_t *)GET_PTR( file_xp );
+    // atomically decrement count
+    hal_remote_atomic_add( XPTR( file_cxy , &file_ptr->refcount ) , -1 );
+}
+////////////////////////////////////////////////
+error_t vfs_file_create( xptr_t        inode_xp,
+                         uint32_t      type,
+/////////////////////////////////////////////
+error_t vfs_file_create( vfs_inode_t * inode,
                          uint32_t      attr,
                          xptr_t      * file_xp )
+{
     vfs_file_t  * file_ptr;
+                         xptr_t      * file_xp )
+{
+    vfs_file_t  * file;
         kmem_req_t    req;
-    // get inode cluster and local pointer
-    cxy_t         inode_cxy = GET_CXY( inode_xp );
-    vfs_inode_t * inode_ptr = (vfs_inode_t *)GET_PTR( inode_xp );
-    // check cluster identifier
-    if( inode_cxy != local_cxy )
+    {
-        printk("\n[PANIC] in %s : local cluster is not the inode owner\n", __FUNCTION__ );
-        hal_core_sleep();
+    }
     // allocate memory for new file descriptor
 …
         req.size  = sizeof(vfs_file_t);
     req.flags = AF_KERNEL | AF_ZERO;
+        file_ptr  = (vfs_file_t *)kmem_alloc( &req );
+    if( file_ptr == NULL ) return ENOMEM;
+    // get inode local pointer
+        file      = (vfs_file_t *)kmem_alloc( &req );
+    if( file == NULL ) return ENOMEM;
     // initializes new file descriptor
+    file_ptr->gc       = 0;
+    file_ptr->type     = type;
+    file_ptr->attr     = attr;
+    file_ptr->offset   = 0;
+    file_ptr->refcount = 0;
+    file_ptr->inode    = inode_ptr;
+    file_ptr->ctx      = inode_ptr->ctx;
+    file_ptr->mapper   = inode_ptr->mapper;
+    remote_rwlock_init( XPTR( local_cxy , &file_ptr->lock ) );
+    *file_xp = XPTR( local_cxy , file_ptr );
+    return 0;
+}
+////////////////////////////////////////
+void vfs_file_destroy( xptr_t  file_xp )
+{
+    // get file cluster and local pointer
+    cxy_t        file_cxy = GET_CXY( file_xp );
+    vfs_file_t * file_ptr = (vfs_file_t *)GET_PTR( file_xp );
+    if( file_cxy != local_cxy )
+    {
+        printk("\n[PANIC] in %s : file descriptor not in local cluster\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
+    if( file_ptr->refcount )
+    file->gc       = 0;
+    file->type     = inode->type;
+    file->attr     = attr;
+    file->offset   = 0;
+    file->refcount = 0;
+    file->inode    = inode;
+    file->ctx      = inode->ctx;
+    file->mapper   = inode->mapper;
+    remote_rwlock_init( XPTR( local_cxy , &file->lock ) );
+    *file_xp = XPTR( local_cxy , file );
+    return 0;
+}  // end vfs_file_create()
+///////////////////////////////////////////
+void vfs_file_destroy( vfs_file_t *  file )
+{
+    if( file->refcount )
+    {
         printk("\n[PANIC] in %s : file refcount non zero\n", __FUNCTION__ );
 …
         kmem_req_t req;
         req.ptr   = file_ptr;
+        req.ptr   = file;
         req.type  = KMEM_VFS_FILE;
         kmem_free( &req );
+}
+//////////////////////////////////////////////////////////////////////////////////////////
+//           File related functions
+}  // end vfs_file_destroy()
+////////////////////////////////////////
+void vfs_file_count_up( xptr_t file_xp )
+{
+    // get file cluster and local pointer
+    cxy_t        file_cxy = GET_CXY( file_xp );
+    vfs_file_t * file_ptr = (vfs_file_t *)GET_PTR( file_xp );
+    // atomically increment count
+    hal_remote_atomic_add( XPTR( file_cxy , &file_ptr->refcount ) , 1 );
+}
+//////////////////////////////////////////
+void vfs_file_count_down( xptr_t file_xp )
+{
+    // get file cluster and local pointer
+    cxy_t        file_cxy = GET_CXY( file_xp );
+    vfs_file_t * file_ptr = (vfs_file_t *)GET_PTR( file_xp );
+    // atomically decrement count
+    hal_remote_atomic_add( XPTR( file_cxy , &file_ptr->refcount ) , -1 );
+}
+//////////////////////////////////////////////////////////////////////////////////////////
+//           File access related functions
 //////////////////////////////////////////////////////////////////////////////////////////
 …
                           char     * path,
                           uint32_t   flags,
+                          xptr_t   * file_xp )
+{
+    return 0;
+}
+///////////////////////////////////
+uint32_t vfs_read( xptr_t   file_xp,
+                   void   * buffer,
+                   uint32_t size )
+{
+    return 0;
+}
+////////////////////////////////////
+uint32_t vfs_write( xptr_t   file_xp,
+                    void   * buffer,
+                    uint32_t size )
+{
+    return 0;
+}
+                  uint32_t   mode,
+                          xptr_t   * new_file_xp,
+                  uint32_t * new_file_id )
+{
+    error_t       error;
+    xptr_t        inode_xp;     // extended pointer on target inode
+    cxy_t         inode_cxy;    // inode cluster identifier
+    vfs_inode_t * inode_ptr;    // inode local pointer
+    uint32_t      file_attr;    // file descriptor attributes
+    uint32_t      lookup_mode;  // lookup working mode
+    xptr_t        file_xp;      // extended pointer on created file descriptor
+    uint32_t      file_id;      // created file descriptor index in reference fd_array
+    // compute lookup working mode
+    lookup_mode = VFS_LOOKUP_OPEN;
+    if( (flags & O_DIR    )      )  lookup_mode |= VFS_LOOKUP_DIR;
+    if( (flags & O_CREAT  )      )  lookup_mode |= VFS_LOOKUP_CREATE;
+    if( (flags & O_EXCL   )      )  lookup_mode |= VFS_LOOKUP_EXCL;
+    // compute attributes for the created file
+    file_attr = 0;
+    if( (flags & O_RDONLY ) == 0 )  file_attr |= FD_ATTR_READ_ENABLE;
+    if( (flags & O_WRONLY ) == 0 )  file_attr |= FD_ATTR_WRITE_ENABLE;
+    if( (flags & O_SYNC   )      )  file_attr |= FD_ATTR_SYNC;
+    if( (flags & O_APPEND )      )  file_attr |= FD_ATTR_APPEND;
+    if( (flags & O_CLOEXEC)      )  file_attr |= FD_ATTR_CLOSE_EXEC;
+    // get extended pointer on target inode
+    error = vfs_lookup( cwd_xp , path , lookup_mode , &inode_xp );
+    if( error ) return error;
+    // get target inode cluster and local pointer
+    inode_cxy = GET_CXY( inode_xp );
+    inode_ptr = (vfs_inode_t *)GET_PTR( inode_xp );
+    // create a new file descriptor in cluster containing inode
+    if( inode_cxy == local_cxy )      // target cluster is local
+    {
+        error = vfs_file_create( inode_ptr , file_attr , &file_xp );
+    }
+    else                              // target cluster is remote
+    {
+        rpc_vfs_file_create_client( inode_cxy , inode_ptr , file_attr , &file_xp , &error );
+    }
+    if( error )  return error;
+    // allocate and register a new file descriptor index in reference cluster fd_array
+    error = process_fd_register( file_xp , &file_id );
+    if( error ) return error;
+    // success
+    *new_file_xp = file_xp;
+    *new_file_id = file_id;
+    return 0;
+}  // end vfs_open()
+/////////////////////////////////////
+error_t vfs_move( bool_t   to_buffer,
+                  xptr_t   file_xp,
+                  void   * buffer,
+                  uint32_t size )
+{
+    assert( ( file_xp != XPTR_NULL ) , __FUNCTION__ , "file_xp == XPTR_NULL" );
+    cxy_t              file_cxy;     // remote file descriptor cluster
+    vfs_file_t       * file_ptr;     // remote file descriptor local pointer
+    vfs_inode_type_t   inode_type;
+    uint32_t           file_offset;  // current offset in file
+    mapper_t         * mapper;
+    error_t            error;
+    // get cluster and local pointer on remote file descriptor
+    file_cxy  = GET_CXY( file_xp );
+    file_ptr  = (vfs_file_t *)GET_PTR( file_xp );
+    // get inode type from remote file descriptor
+    inode_type = hal_remote_lw( XPTR( file_cxy , &file_ptr->type   ) );
+    // action depends on inode type
+    if( inode_type == INODE_TYPE_FILE )
+    {
+        // get mapper pointer and file offset from file descriptor
+        file_offset = hal_remote_lw( XPTR( file_cxy , &file_ptr->offset ) );
+        mapper = (mapper_t *)hal_remote_lpt( XPTR( file_cxy , &file_ptr->mapper ) );
+        // move data between mapper and buffer
+        if( file_cxy == local_cxy )
+        {
+            error = mapper_move( mapper,
+                                 to_buffer,
+                                 file_offset,
+                                 buffer,
+                                 size );
+        }
+        else
+        {
+            rpc_mapper_move_client( file_cxy,
+                                    mapper,
+                                    to_buffer,
+                                    file_offset,
+                                    buffer,
+                                    size,
+                                    &error );
+        }
+        return error;
+    }
+    else if (inode_type == INODE_TYPE_DIR )
+    {
+        printk("\n[ERROR] in %s : inode is a directory", __FUNCTION__ );
+        return EINVAL;
+    }
+    else if (inode_type == INODE_TYPE_DEV )
+    {
+        // TODO
+        return 0;
+    }
+    else
+    {
+        printk("\n[PANIC] in %s : illegal inode type\n", __FUNCTION__ );
+        hal_core_sleep();
+        return -1;
+    }
+}  // end vfs_access()
 //////////////////////////////////////
 …
                    uint32_t * new_offset )
+{
+    return 0;
+}
+//////////////////////////////////////
+error_t vfs_close( xptr_t     file_xp,
+                   uint32_t * refcount )
+{
+    return 0;
+}
+    printk("\n[PANIC] %s non implemented\n", __FUNCTION__ );
+    hal_core_sleep();
+    return 0;
+    assert( ( file_xp != XPTR_NULL ) , __FUNCTION__ , "file_xp == XPTR_NULL" );
+}  // vfs_lseek()
+///////////////////////////////////
+error_t vfs_close( xptr_t   file_xp,
+                   uint32_t file_id )
+{
+    assert( (file_xp != XPTR_NULL) , __FUNCTION__ , "file_xp == XPTR_NULL" );
+    assert( (file_id < CONFIG_PROCESS_FILE_MAX_NR) , __FUNCTION__ , "illegal file_id" );
+    thread_t  * this    = CURRENT_THREAD;
+    process_t * process = this->process;
+    // get cluster and local pointer on remote file descriptor
+    cxy_t        file_cxy = GET_CXY( file_xp );
+    vfs_file_t * file_ptr = (vfs_file_t *)GET_PTR( file_xp );
+    // get local pointer on local cluster manager
+    cluster_t * cluster = LOCAL_CLUSTER;
+    // get owner process cluster and lpid
+    cxy_t   owner_cxy  = CXY_FROM_PID( process->pid );
+    lpid_t  lpid       = LPID_FROM_PID( process->pid );
+    // get extended pointers on copies root and lock
+    xptr_t root_xp = XPTR( owner_cxy , &cluster->pmgr.copies_root[lpid] );
+    xptr_t lock_xp = XPTR( owner_cxy , &cluster->pmgr.copies_lock[lpid] );
+    // take the lock protecting the copies
+    remote_spinlock_lock( lock_xp );
+    // 1) loop on the process descriptor copies to cancel all fd_array[file_id] entries
+    xptr_t  iter_xp;
+    XLIST_FOREACH( root_xp , iter_xp )
+    {
+        xptr_t      process_xp  = XLIST_ELEMENT( iter_xp , process_t , copies_list );
+        cxy_t       process_cxy = GET_CXY( process_xp );
+        process_t * process_ptr = (process_t *)GET_PTR( process_xp );
+        xptr_t lock_xp  = XPTR( process_cxy , &process_ptr->fd_array.lock );
+        xptr_t entry_xp = XPTR( process_cxy , &process_ptr->fd_array.array[file_id] );
+        // lock is required for atomic write of a 64 bits word
+        remote_rwlock_wr_lock( lock_xp );
+        hal_remote_swd( entry_xp , XPTR_NULL );
+        remote_rwlock_wr_unlock( lock_xp );
+        hal_wbflush();
+    }
+    // 2) release memory allocated to file descriptor in remote cluster
+    if( file_cxy == local_cxy )             // file cluster is local
+    {
+        vfs_file_destroy( file_ptr );
+    }
+    else                                    // file cluster is local
+    {
+        rpc_vfs_file_destroy_client( file_cxy , file_ptr );
+    }
+    return 0;
+}  // end vfs_close()
 ////////////////////////////////////
 …
                     char   * path )
+{
+    printk("\n[PANIC] %s non implemented\n", __FUNCTION__ );
+    hal_core_sleep();
+    return 0;
+}  // vfs_unlink()
+///////////////////////////////////////
+error_t vfs_stat( xptr_t       file_xp,
+                  vfs_stat_t * k_stat )
+{
+    printk("\n[PANIC] %s non implemented\n", __FUNCTION__ );
+    hal_core_sleep();
+    return 0;
+}
+////////////////////////////////////////////
+error_t vfs_readdir( xptr_t         file_xp,
+                     vfs_dirent_t * k_dirent )
+{
+    printk("\n[PANIC] %s non implemented\n", __FUNCTION__ );
+    hal_core_sleep();
     return 0;
+}
 //////////////////////////////////////
+error_t vfs_stat( xptr_t       file_xp,
+                  vfs_stat_t * stat )
+{
+    return 0;
+}
+//////////////////////////////////////////////////////////////////////////////////////////
+//           Directory related functions
+//////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////
+error_t vfs_mkdir( xptr_t     file_xp,
+                   char     * path,
+                   uint32_t   mode )
+{
+    printk("\n[PANIC] %s non implemented\n", __FUNCTION__ );
+    hal_core_sleep();
+    return 0;
+}
+////////////////////////////////////
+error_t vfs_rmdir( xptr_t   file_xp,
+                   char   * path )
+{
+    printk("\n[PANIC] %s non implemented\n", __FUNCTION__ );
+    hal_core_sleep();
+    return 0;
+}
+///////////////////////////////////
+error_t vfs_chdir( xptr_t   cwd_xp,
+                   char   * path )
+{
+    error_t           error;
+    xptr_t            inode_xp;     // extended pointer on target inode
+    cxy_t             inode_cxy;    // target inode cluster identifier
+    vfs_inode_t     * inode_ptr;    // target inode local pointer
+    uint32_t          mode;         // lookup working mode
+    vfs_inode_type_t  inode_type;   // target inode type
+    // set lookup working mode
+    mode = 0;
+    // get extended pointer on target inode
+    error = vfs_lookup( cwd_xp , path , mode , &inode_xp );
+    if( error ) return error;
+    // get inode cluster and local pointer
+    inode_cxy = GET_CXY( inode_xp );
+    inode_ptr = (vfs_inode_t *)GET_PTR( inode_xp );
+    // get inode type from remote file
+    inode_type = hal_remote_lw( XPTR( inode_cxy , &inode_ptr->type ) );
+    if( inode_type != INODE_TYPE_DIR )
+    {
+        CURRENT_THREAD->errno = ENOTDIR;
+        return -1;
+    }
+    printk("\n[PANIC] %s non fully implemented\n", __FUNCTION__ );
+    hal_core_sleep();
+    return 0;
+}
+///////////////////////////////////
+error_t vfs_chmod( xptr_t   cwd_xp,
+                   char   * path,
+                   uint32_t rights )
+{
+    error_t           error;
+    xptr_t            inode_xp;     // extended pointer on target inode
+    cxy_t             inode_cxy;    // inode cluster identifier
+    vfs_inode_t     * inode_ptr;    // inode local pointer
+    uint32_t          mode;         // lookup working mode
+    vfs_inode_type_t  inode_type;   // target inode type
+    // set lookup working mode
+    mode = 0;
+    // get extended pointer on target inode
+    error = vfs_lookup( cwd_xp , path , mode , &inode_xp );
+    if( error ) return error;
+    // get inode cluster and local pointer
+    inode_cxy = GET_CXY( inode_xp );
+    inode_ptr = (vfs_inode_t *)GET_PTR( inode_xp );
+    // get inode type from remote inode
+    inode_type = hal_remote_lw( XPTR( inode_cxy , &inode_ptr->type ) );
+    printk("\n[PANIC] %s non fully implemented\n", __FUNCTION__ );
+    hal_core_sleep();
+    return 0;
+}
+///////////////////////////////////
+error_t vfs_mkfifo( xptr_t   cwd_xp,
+                    char   * path,
+                    uint32_t rights )
+{
+    printk("\n[PANIC] in %s : not implemented yet\n", __FUNCTION__ );
+    hal_core_sleep();
+    return 0;
+}
+/////////////////////////////////////////////////////////////////////////////////////////r
 //            Inode Tree functions
 //////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////
 // This static function is used by the vfs_lookup() function.
+// This function is used by the vfs_lookup() function.
 // It takes an extended pointer on a remote inode (parent directory inode),
 // and check access_rights violation for the calling thread.
 …
+}
+////////////////////////////////////////
+error_t vfs_lookup( xptr_t       cwd_xp,
+                    char       * pathname,
+                    uint32_t     client_uid,
+                    uint32_t     client_gid,
+                                        xptr_t     * inode_xp,
+                    xptr_t     * ctx_xp )
+//////////////////////////////////////////////
+error_t vfs_lookup( xptr_t             cwd_xp,
+                    char             * pathname,
+                    uint32_t           mode,
+                                        xptr_t           * inode_xp )
+{
     char          name[CONFIG_VFS_MAX_NAME_LENGTH];   // one name in path
+    xptr_t        parent_xp;    // extended pointer on parent inode
+    cxy_t         parent_cxy;   // cluster for parentc inode
+    vfs_inode_t * parent_ptr;   // local pointer on parent inode
+    xptr_t        child_xp;     // extended pointer on child inode
+    cxy_t         child_cxy;    // cluster for child inode
+    vfs_inode_t * child_ptr;    // local pointer on child inode
+    char        * current;      // current pointer on path
+    char        * next;         // next value for current pointer
+    bool_t        last;         // true when the name is the last in path
+    bool_t        found;        // true when a child has been found
+    thread_t    * this;         // pointer on calling thread descriptor
+    process_t   * process;      // pointer on calling process descriptor
+    vfs_ctx_t   * ctx;          // parent inode context
+    uint32_t      type;         // file system type of parent inode
+    error_t       error;
+    xptr_t             parent_xp;    // extended pointer on parent inode
+    cxy_t              parent_cxy;   // cluster for parent inode
+    vfs_inode_t      * parent_ptr;   // local pointer on parent inode
+    xptr_t             child_xp;     // extended pointer on child inode
+    cxy_t              child_cxy;    // cluster for child inode
+    vfs_inode_t      * child_ptr;    // local pointer on child inode
+    vfs_inode_type_t   inode_type;   // child inode type
+    vfs_fs_type_t      fs_type;      // File system type
+    vfs_ctx_t        * ctx_ptr;      // local pointer on FS context
+    char             * current;      // current pointer on path
+    char             * next;         // next value for current pointer
+    bool_t             last;         // true when the name is the last in path
+    bool_t             found;        // true when a child has been found
+    thread_t         * this;         // pointer on calling thread descriptor
+    process_t        * process;      // pointer on calling process descriptor
+    error_t            error;
     this    = CURRENT_THREAD;
 …
     do
+    {
+        // get cluster and local pointer for parent inode
+        parent_cxy = GET_CXY( parent_xp );
+        parent_ptr = (vfs_inode_t *)GET_PTR( parent_xp );
+        // get parent inode FS type
+        ctx = (vfs_ctx_t *)(intptr_t)hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->ctx ) );
+        type = ctx->type;
+        // get one name from path
+        // get one name from path and the last flag
         vfs_get_name_from_path( current , name , &next , &last );
 …
             vfs_inode_remote_unlock( parent_xp );
+            // insert a new dentry/inode in parent inode
+            error = vfs_add_child_in_parent( type , parent_xp , name , &child_xp );
+            // get cluster and local pointer on parent inode
+            parent_cxy = GET_CXY( parent_xp );
+            parent_ptr = (vfs_inode_t *)GET_PTR( parent_xp );
+            // get parent inode FS type
+            ctx_ptr = (vfs_ctx_t *)hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->ctx ) );
+            fs_type = ctx_ptr->type;
+            // get child inode type
+            if( (last == false) || (mode & VFS_LOOKUP_DIR) ) inode_type = INODE_TYPE_DIR;
+            else                                             inode_type = INODE_TYPE_FILE;
+            // insert a child dentry/inode in parent inode
+            error = vfs_add_child_in_parent( inode_type,
+                                             fs_type,
+                                             parent_xp,
+                                             name,
+                                             &child_xp );
             if( error )
 …
         // check access rights
         error = vfs_access_denied( child_xp,
                                    client_uid,
                                    client_gid );
         if( error )
+        {
             printk("\n[ERROR] in %s : permission denied for %s\n", __FUNCTION__ , name );
             return EACCES;
+        }
+        // error = vfs_access_denied( child_xp,
+        //                            client_uid,
+        //                            client_gid );
+        // if( error )
+        // {
+        //     printk("\n[ERROR] in %s : permission denied for %s\n", __FUNCTION__ , name );
+        //     return EACCES;
+        // }
         // take lock on child inode if not last
 …
     // return searched pointers
     *inode_xp = child_xp;
-    *ctx_xp   = (xptr_t)hal_remote_lwd( XPTR( child_cxy , &child_ptr->ctx ) );
     return 0;
 …
         uint32_t     count;       // number of characters written in buffer
         uint32_t     index;       // slot index in buffer
     xptr_t       inode_xp;  // extended pointer on
+    xptr_t       inode_xp;    // extended pointer on
     // implementation note:
 …
 }  // end vfs_get_path()
+///////////////////////////////////////////////
+error_t vfs_add_child_in_parent( uint32_t type,
+                                 xptr_t   parent_xp,
+                                 char   * name,
+                                 xptr_t * child_xp )
+{
+    xptr_t     dentry_xp;  // extended pointer on created dentry
+    xptr_t     inode_xp;   // extended pointer on created inode
+    error_t    error;
+///////////////////////////////////////////////////////////////
+error_t vfs_add_child_in_parent( vfs_inode_type_t   inode_type,
+                                 vfs_fs_type_t      fs_type,
+                                 xptr_t             parent_xp,
+                                 char             * name,
+                                 xptr_t           * child_xp )
+{
+    error_t         error;
+    xptr_t          dentry_xp;   // extended pointer on created dentry
+    xptr_t          inode_xp;    // extended pointer on created inode
+    cxy_t           parent_cxy;  // parent inode cluster identifier
+    vfs_inode_t   * parent_ptr;  // parent inode local pointer
+    vfs_ctx_t     * parent_ctx;  // parent inode context local pointer
     // get parent inode cluster and local pointer
+    cxy_t         parent_cxy = GET_CXY( parent_xp );
+    vfs_inode_t * parent_ptr = (vfs_inode_t *)GET_PTR( parent_xp );
+    parent_cxy = GET_CXY( parent_xp );
+    parent_ptr = (vfs_inode_t *)GET_PTR( parent_xp );
+    // get parent inode context local pointer
+    parent_ctx = (vfs_ctx_t *)hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->ctx ) );
     // create dentry
     if( parent_cxy == local_cxy )      // parent cluster is the local cluster
+    {
         error = vfs_dentry_create( type,
+        error = vfs_dentry_create( fs_type,
                                    name,
                                    parent_ptr,
 …
+    {
         rpc_vfs_dentry_create_client( parent_cxy,
                                       type,
+                                      fs_type,
                                       name,
                                       parent_ptr,
 …
+    {
         error = vfs_inode_create( dentry_xp,
+                                  type,
+                                  fs_type,
+                                  inode_type,
                                   attr,
                                   mode,
 …
         rpc_vfs_inode_create_client( child_cxy,
                                      dentry_xp,
+                                     type,
+                                     fs_type,
+                                     inode_type,
                                      attr,
                                      mode,
 …
+//////////////////////////////////////////////////////////////////////////////////////////
+//            Mapper related functions
+//////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////
+error_t vfs_move_page_to_mapper( page_t * page )
+{
+    error_t         error = 0;
+    assert( (page != NULL) , __FUNCTION__ , "page pointer is NULL\n" );
+    mapper_t * mapper = page->mapper;
+    assert( (mapper != NULL) , __FUNCTION__ , "no mapper for page\n" );
+    // get FS type
+    vfs_fs_type_t fs_type = mapper->inode->ctx->type;
+    // update mapper if permitted by file system type
+    if( fs_type == FS_TYPE_FATFS )
+    {
+        // get mapper lock in WRITE_MODE
+        rwlock_wr_lock( &mapper->lock );
+        error = fatfs_read_page( page );
+        // release mapper lock
+        rwlock_wr_unlock( &mapper->lock );
+    }
+    else if( fs_type == FS_TYPE_RAMFS )
+    {
+        assert( false , __FUNCTION__ , "should not be called for RAMFS\n" );
+    }
+    else if( fs_type == FS_TYPE_DEVFS )
+    {
+        assert( false , __FUNCTION__ , "should not be called for DEVFS\n" );
+    }
+    else
+    {
+        assert( false , __FUNCTION__ , "undefined file system type\n" );
+    }
+    return error;
+}  // end vfs_move_page_to_mapper()
+//////////////////////////////////////////////////
+error_t vfs_move_page_from_mapper( page_t * page )
+{
+    error_t         error = 0;
+    assert( (page != NULL) , __FUNCTION__ , "page pointer is NULL\n" );
+    mapper_t * mapper = page->mapper;
+    assert( (mapper != NULL) , __FUNCTION__ , "no mapper for page\n" );
+    // get FS type
+    vfs_fs_type_t  fs_type = mapper->inode->ctx->type;
+    // update file system if permitted by file system type
+    if( fs_type == FS_TYPE_FATFS )
+    {
+            if( page_is_flag( page , PG_DIRTY ) )
+            {
+            // get mapper lock in READ_MODE
+            rwlock_rd_lock( &mapper->lock );
+            error = fatfs_write_page( page );
+            // release mapper lock from READ_MODE
+            rwlock_rd_unlock( &mapper->lock );
+            // clear dirty bit if success
+                    if( error == 0 ) page_undo_dirty( page );
+         }
+    }
+    else if( fs_type == FS_TYPE_RAMFS )
+    {
+        assert( false , __FUNCTION__ , "should not be called for RAMFS\n" );
+    }
+    else if( fs_type == FS_TYPE_DEVFS )
+    {
+        assert( false , __FUNCTION__ , "should not be called for DEVFS\n" );
+    }
+    else
+    {
+        assert( false , __FUNCTION__ , "undefined file system type\n" );
+    }
+    return error;
+}  // end vfs_move_page_from_mapper()

trunk/kernel/vfs/vfs.h

-                      r14
+                      r23
  * vfs.h - Virtual File System definition.
+ *
  * Author  Mohamed Lamine Karaoui (2015)
  *         Alain Greiner (2016)
+ * Author  Mohamed Lamine Karaoui (2014,2015)
+ *         Alain Greiner (2016,2017)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
 #include <fatfs.h>
 #include <ramfs.h>
+#include <devfs.h>
 /****  Forward declarations  ***/
 …
 struct device_s;
 struct vseg_s;
+/*********************************************************************************************
+ * This defines the various Flags arguments for an open() or opendir() system call.
+ ********************************************************************************************/
+#define VFS_O_APPEND         0x00080000
+#define VFS_O_RDONLY         0x00100000
+#define VFS_O_WRONLY         0x00200000
+#define VFS_O_RDWR           0x00300000
+#define VFS_O_CREATE         0x00400000
+#define VFS_O_EXCL           0x00800000
+#define VFS_O_TRUNC          0x01000000
+#define VFS_O_SYNC               0x08000000
+/*********************************************************************************************
+ * This defines the various types of command for an lseek() system call.
+ ********************************************************************************************/
+#define VFS_SEEK_SET         0
+#define VFS_SEEK_CUR         1
+#define VFS_SEEK_END         2
+/*********************************************************************************************
+ * TODO : the following flags were defined in the vfs-params.h file...
+ *        ... and must be documented. [AG]
+ ********************************************************************************************/
+//////////////////////////////////////
+///    keep these flags compact    ///
+//////////////////////////////////////
+#define VFS_REGFILE          0x0000000
+#define VFS_DIR              0x0000001
+#define VFS_FIFO             0x0000002
+#define VFS_DEV_CHR          0x0000004
+#define VFS_DEV_BLK          0x0000008
+#define VFS_DEV              0x000000C
+#define VFS_SOCK             0x0000010
+#define VFS_SYMLNK           0x0000020
+//////////////////////////////////////
+#define VFS_RD_ONLY          0x0000040
+#define VFS_SYS              0x0000080
+#define VFS_ARCHIVE          0x0000100
+#define VFS_PIPE             0x0000200
+#define VFS_IFMT             0x0170000
+#define VFS_IFSOCK           0x0140000
+#define VFS_IFLNK            0x0120000
+#define VFS_IFREG            0x0100000
+#define VFS_IFBLK            0x0060000
+#define VFS_IFDIR            0x0040000
+#define VFS_IFCHR            0x0020000
+#define VFS_IFIFO            0x0010000
+#define VFS_ISUID            0x0004000
+#define VFS_ISGID            0x0002000
+#define VFS_ISVTX            0x0001000
+struct page_s;
+/******************************************************************************************
+ * These flags are used to define the working mode of the vfs_lookup() function.
+ *****************************************************************************************/
+#define VFS_LOOKUP_DIR      0x01     /* the searched inode is a directory                */
+#define VFS_LOOKUP_OPEN         0x02     /* the search is for an open/opendir                */
+#define VFS_LOOKUP_PARENT       0x04     /* return the parent inode (not the inode itself)   */
+#define VFS_LOOKUP_CREATE   0x10     /* file must be created if missing                  */
+#define VFS_LOOKUP_EXCL     0x20     /* file cannot previously exist                     */
+/******************************************************************************************
+ * This define the masks for the POSIX access rights to inodes
+ *****************************************************************************************/
+#define VFS_ISUID                0x0004000
+#define VFS_ISGID                0x0002000
+#define VFS_ISVTX                0x0001000
 #define VFS_IRWXU            0x0000700
 …
 #define VFS_IWUSR            0x0000200
 #define VFS_IXUSR            0x0000100
 #define VFS_IRWXG            0x0000070
 #define VFS_IRGRP            0x0000040
 #define VFS_IWGRP            0x0000020
 #define VFS_IXGRP            0x0000010
 #define VFS_IRWXO            0x0000007
 #define VFS_IROTH            0x0000004
 …
 #define VFS_IEXEC            VFS_IXUSR
+#define VFS_SET(state,flag)    (state) |= (flag)
+#define VFS_IS(state,flag)     (state) & (flag)
+#define VFS_CLEAR(state,flag)  (state) &= ~(flag)
+/* Lookup flags */
+#define VFS_LOOKUP_FILE         0x1
+#define VFS_LOOKUP_LAST         0x2
+#define VFS_LOOKUP_OPEN         0x4
+#define VFS_LOOKUP_RESTART      0x8
+#define VFS_LOOKUP_RETRY        0x10
+#define VFS_LOOKUP_PARENT       0x20
+#define VFS_LOOKUP_HELD         0x40
+/* Context flags*/
+#define VFS_FS_LOCAL            0x1
+#define VFS_FS_USE_MAPPER       0x2
+/******************************************************************************************
+ * This structure defines informations common to all inodes and dentries
+ * of a given file system. As it is declared a global variable in the kdata segment,
+ * it is replicated in all clusters and handled as private by each OS intance.
+ *****************************************************************************************/
+typedef enum
+{
+        FS_TYPE_DEVFS = 0,
+        FS_TYPE_FATFS = 1,
+        FS_TYPE_RAMFS = 2,
+        FS_TYPES_NR   = 3,
+}
+vfs_fs_type_t;
+typedef enum
+{
+    CTX_ATTR_READ_ONLY    = 0x01,            /*! write access prohibited                 */
+    CTX_ATTR_SYNC         = 0x10,            /*! synchronise FS on each write            */
+}
+vfs_ctx_attr_t;
+typedef struct vfs_ctx_s
+{
+        vfs_fs_type_t  type;                     /*! File System type                        */
+        uint32_t           attr;                     /*! global attributes for all files in FS   */
+        uint32_t       count;                    /*! total number of clusters on device      */
+        uint32_t       blksize;                  /*! device cluster size (bytes)             */
+        xptr_t         root_xp;                  /*! extended pointer on root inode          */
+    spinlock_t     lock;                     /*! lock protecting inum allocator          */
+    uint32_t       bitmap[BITMAP_SIZE(CONFIG_VFS_MAX_INODES)];  /* inum allocator        */
+    void         * extend;                   /*! FS specific context extension           */
+}
+vfs_ctx_t;
 /******************************************************************************************
 …
  * The <parent> inode is unique for a directory (not hard links for directories).
  * For a file, the parent field points to the first dentry who created this inode.
  * Syncronisation:
+ * Syncrhonisation:
  * - the main_lock (spinlock) is used during the inode tree traversal or for inode
  *   modification (add/remove children).
 …
  *   in the mapper.
  * - the mapper lock (rwlock) is only used during the radix tree traversal to return
+ *   to return the relevant page for red/write.
+ *****************************************************************************************/
+ *   the relevant page for read/write.
+ *****************************************************************************************/
+/* this enum define the VFS inode types values */
 typedef enum
+{
+    INODE_TYPE_NORMAL,                 /*! file or directory                            */
+    INODE_TYPE_PIPE,                   /*! POSIX pipe                                   */
+    INODE_TYPE_SOCKET,                 /*! POSIX socket                                 */
+    INODE_TYPE_DEV,                    /*! peripheral channel                           */
+    INODE_TYPE_FILE    =     0x001,      /*! file                                        */
+    INODE_TYPE_DIR     =     0x002,      /*! directory                                   */
+    INODE_TYPE_FIFO    =     0x004,      /*! POSIX named pipe                            */
+    INODE_TYPE_PIPE    =     0x008,      /*! POSIX anonymous pipe                        */
+    INODE_TYPE_SOCKET  =     0x010,      /*! POSIX socket                                */
+    INODE_TYPE_DEV     =     0x020,      /*! character peripheral channel                */
+    INODE_TYPE_SYML    =     0x080,      /*! symbolic link                               */
+}
 vfs_inode_type_t;
+/* this enum define the VFS inode attributes values */
 typedef enum
+{
+    INODE_ATTR_DIRTY  = 0x01,
+    INODE_ATTR_DIR    = 0x02,
+    INODE_ATTR_INLOAD = 0x04,
+    INODE_ATTR_NEW    = 0x08,
+    INODE_ATTR_DIRTY   =     0x01,       /* modified versus the value on device          */
+    INODE_ATTR_INLOAD  =     0x04,       /* loading from device in progress              */
+    INODE_ATTR_NEW     =     0x08,       /* not saved on device yet                      */
+}
 vfs_inode_attr_t;
 …
 typedef struct vfs_inode_s
+{
         struct vfs_ctx_s      * ctx;         /*! Rlocal pointer on FS context                */
+        struct vfs_ctx_s      * ctx;         /*! local pointer on FS context                 */
     uint32_t                gc;          /*! generation counter                          */
         uint32_t                inum;        /*! inode identifier (unique in file system)    */
         uint32_t                attr;        /*! inode attributes (see above)                */
         uint32_t                type;        /*! inode type (see above)                      */
+        vfs_inode_type_t        type;        /*! inode type (see above)                      */
         uint32_t                size;        /*! number of bytes                             */
         uint32_t                links;       /*! number of alias dentry                      */
         uid_t                   uid;         /*! user owner identifier                       */
         gid_t                   gid;         /*! group owner identifier                      */
     uint32_t                mode;        /*! access mode                                 */
+    uint32_t                rights;      /*! access rights                               */
         uint32_t                    refcount;    /*! reference counter (all pointers)            */
         xptr_t                  parent_xp;   /*! extended pointer on parent dentry           */
         xhtab_t                 children;    /*! embedded htab of dir entries (for dir type) */
+        xhtab_t                 children;    /*! embedded xhtab of vfs_dentry_t              */
         remote_rwlock_t         data_lock;   /*! protect read/write to data and to size      */
         remote_spinlock_t       main_lock;   /*! protect inode tree traversal and modifs     */
         xlist_entry_t           xlist;       /*! member of set of inodes in same cluster     */
+        list_entry_t            list;        /*! member of set of inodes in same cluster     */
         xlist_entry_t           wait_root;   /*! root of threads waiting on this inode       */
         struct vfs_inode_op_s * op;          /*! TODO ???                                    */
 …
 /******************************************************************************************
  * This structure describes an open file/directory for a given process.
+ * This file structure describes an open file/directory for a given process.
  * It is not replicated, and is dynamically allocated in the cluster that contains
  * the inode, when a thread makes an open() or opendir() system call.
+ *****************************************************************************************/
+ * It cannot exist a file structure without an inode structure.
+ * Aa the fd_array (containing extended pointers on the open file descriptors)
+ * is replicated in all process descriptors, we need a references counter.
+ *****************************************************************************************/
 typedef enum
+{
     FD_ATTR_READ_ENABLE  = 0x01,       /*! read access possible                         */
     FD_ATTR_WRITE_ENABLE = 0x02,       /*! write access possible                        */
     FD_ATTR_APPEND       = 0x04,       /*! append on each write                         */
     FD_ATTR_CLOSE_EXEC   = 0x08,       /*! close file on exec                           */
     FD_ATTR_SYNC         = 0x10,       /*! synchronise FS on each write                 */
     FD_ATTR_IS_DIR       = 0x20,       /*! this is a directory                          */
+}
 vfs_fd_attr_t;
+    FD_ATTR_READ_ENABLE    = 0x01,     /*! read access possible                         */
+    FD_ATTR_WRITE_ENABLE   = 0x02,     /*! write access possible                        */
+    FD_ATTR_APPEND         = 0x04,     /*! append on each write                         */
+    FD_ATTR_CLOSE_EXEC     = 0x08,     /*! close file on exec                           */
+    FD_ATTR_SYNC           = 0x10,     /*! synchronise FS on each write                 */
+    FD_ATTR_IS_DIR         = 0x20,     /*! this is a directory                          */
+}
+vfs_file_attr_t;
 typedef struct vfs_file_s
+{
+        struct vfs_ctx_s      * ctx;        /*! local pointer on FS context.                 */
         uint32_t                gc;         /*! generation counter                           */
         uint32_t                type;       /*! see above                                    */
         uint32_t                attr;       /*! see above                                    */
+        vfs_file_attr_t         attr;       /*! file attributes bit vector (see above)       */
+        vfs_inode_type_t        type;       /*! same type as inode                           */
         uint32_t                offset;     /*! seek position in file                        */
         uint32_t                refcount;   /*! all pointers on this file                    */
         remote_rwlock_t       lock;       /*! protect offset modifications                 */
+        uint32_t                refcount;   /*! all pointers on this file descriptor         */
+        remote_rwlock_t         lock;       /*! protect offset modifications                 */
         struct mapper_s       * mapper;     /*! associated file cache                        */
         struct vfs_inode_s    * inode;      /*! local pointer on associated inode            */
+        struct vfs_ctx_s      * ctx;        /*! file system features                         */
+        struct vfs_file_op_s  * op;         /*! local set of function pointers               */
+        void                  * extend;     /*! FS specific extension                        */
+}
 vfs_file_t;
 /******************************************************************************************
+ * This structure defines informations common to all inodes and dentries
+ * of a given file system. As it is declared a global variable in the kdata segment,
+ * it is replicated in all clusters and handled as private by each OS intance.
+ *****************************************************************************************/
+typedef enum
+{
+        FS_TYPE_SYSFS = 0,
+        FS_TYPE_DEVFS = 1,
+        FS_TYPE_FATFS = 2,
+        FS_TYPE_RAMFS = 3,
+        FS_TYPES_NR   = 4,
+}
+vfs_types_t;
+typedef enum
+{
+    CTX_ATTR_READ_ONLY    = 0x01,       /*! read access possible                         */
+    CTX_ATTR_SYNC         = 0x10,       /*! synchronise FS on each write                 */
+}
+vfs_ctx_attr_t;
+typedef struct vfs_ctx_s
+{
+        uint32_t                      type;          /*! File System type                        */
+        uint32_t                      attr;          /*! global attributes for all files in FS   */
+        uint32_t                  count;         /*! number of clusters                      */
+        uint32_t                  blksize;       /*! cluster size                            */
+    xptr_t                    ioc_xp;        /*! extended pointer on IOC device          */
+        xptr_t                    root_xp;       /*! extended pointer on root inode          */
+    spinlock_t                lock;          /*! lock protecting inum allocator          */
+        BITMAP( inum , CONFIG_VFS_MAX_INODES );  /*! inum allocator                          */
+    void                    * extend;        /*! FS specific context extension           */
+}
+vfs_ctx_t;
+/******************************************************************************************
+ * This structure define the informations associated to a given file descriptor,
+ * that are returned by the vfs_stat() function.
+ * This structure define the informations associated to a file descriptor,
+ * returned to user space by the stat() system call.
  *****************************************************************************************/
 …
 vfs_stat_t;
+/******************************************************************************************
+ * This structure defines the set of operations that can be done on a VFS context.
+ * TODO A quoi cela sert-il ? [AG]
+ *****************************************************************************************/
+typedef error_t (vfs_create_context_t)  ( vfs_ctx_t * context );
+typedef error_t (vfs_destroy_context_t) ( vfs_ctx_t * context );
+typedef error_t (vfs_read_root_t)       ( vfs_ctx_t * context , vfs_inode_t * root );
+typedef error_t (vfs_reply_root_t)      ( vfs_ctx_t * context , vfs_inode_t * root );
+typedef error_t (vfs_write_root_t)      ( vfs_ctx_t * context , vfs_inode_t * root );
+struct vfs_ctx_op_s
+{
+        vfs_create_context_t  * create;      /*! allocate memory and initialize a context   */
+        vfs_destroy_context_t * destroy;     /*! release memory allocated to a context      */
+        vfs_read_root_t       * read_root;   /*! TODO                                       */
+        vfs_reply_root_t      * repli_root;  /*! TODO                                       */
+        vfs_write_root_t      * write_root;  /*! TODO                                       */
+}
+vfs_ctx_op_t;
+/******************************************************************************************
+ * This structure defines the set of operations that can be done on a VFS inode.
+ * TODO A quoi cela sert-il ? [AG]
+ *****************************************************************************************/
+typedef error_t (vfs_init_inode_t)    ( vfs_inode_t * inode );
+typedef error_t (vfs_create_inode_t)  ( vfs_inode_t * parent , vfs_dentry_t  * dentry );
+typedef error_t (vfs_lookup_inode_t)  ( vfs_inode_t * parent , vfs_dentry_t  * dentry );
+typedef error_t (vfs_write_inode_t)   ( vfs_inode_t * inode );
+typedef error_t (vfs_release_inode_t) ( vfs_inode_t * inode );
+typedef error_t (vfs_unlink_inode_t)  ( vfs_inode_t * parent , vfs_dentry_t  * dentry , uint32_t flags );
+typedef error_t (vfs_stat_inode_t)    ( vfs_inode_t * inode );
+typedef error_t (vfs_trunc_inode_t)   ( vfs_inode_t * inode );
+typedef error_t (vfs_delete_inode_t)  ( vfs_inode_t * inode );
+typedef struct vfs_inode_op_s
+{
+        vfs_init_inode_t    * init;     /*! initialise inode from scratch                    */
+        vfs_create_inode_t  * create;   /*! allocate memory for one inode                    */
+        vfs_lookup_inode_t  * lookup;   /*! get one directory entry by name                  */
+        vfs_write_inode_t   * write;    /*! update the device from the inode                 */
+        vfs_release_inode_t * release;  /*! reset one inode and release associated objects   */
+        vfs_unlink_inode_t  * unlink;   /*! unlink a directory entry from parent inode       */
+        vfs_delete_inode_t  * delete;   /*! release memory allocated to inode when count = 0 */
+        vfs_stat_inode_t    * stat;     /*! TODO                                             */
+        vfs_trunc_inode_t   * trunc;    /*! change the size of a file                        */
+}
+vfs_inode_op_t;
+/******************************************************************************************
+ * This structure defines the set of operations that can be done on a VFS dentry.
+ * TODO A quoi cela sert-il ? [AG]
+ *****************************************************************************************/
+typedef error_t (vfs_compare_dentry_t) ( char * first , char * second );
+typedef struct vfs_dentry_op_s
+{
+        vfs_compare_dentry_t * compare;
+}
+vfs_dentry_op_t;
+/******************************************************************************************
+ * This structure defines the set of operations that can be done on a VFS file.
+ * TODO A quoi cela sert-il ? [AG]
+ *****************************************************************************************/
+typedef error_t (vfs_open_file_t)    ( vfs_file_t * file , void * priv );
+typedef error_t (vfs_read_file_t)    ( vfs_file_t * file , char * buffer );
+typedef error_t (vfs_write_file_t)   ( vfs_file_t * file , char * buffer );
+typedef error_t (vfs_lseek_file_t)   ( vfs_file_t * file );
+typedef error_t (vfs_close_file_t)   ( vfs_file_t * file );
+typedef error_t (vfs_release_file_t) ( vfs_file_t * file );
+typedef error_t (vfs_read_dir_t)     ( vfs_file_t * file );
+typedef error_t (vfs_mmap_file_t)    ( vfs_file_t * file , struct vseg_s * vseg );
+typedef error_t (vfs_munmap_file_t)  ( vfs_file_t * file , struct vseg_s * vseg );
+typedef struct vfs_file_op_s
+{
+        vfs_open_file_t    * open;
+        vfs_read_file_t    * read;
+        vfs_write_file_t   * write;
+        vfs_lseek_file_t   * lseek;
+        vfs_read_dir_t     * readdir;
+        vfs_close_file_t   * close;
+        vfs_release_file_t * release;
+        vfs_mmap_file_t    * mmap;
+        vfs_munmap_file_t  * munmap;
+}
+vfs_file_op_t;
+/*********************************************************************************************
+ * This structure defines the information associated to a directory entry,
+ * returned to user space by the readdir() system call.
+ ********************************************************************************************/
+typedef struct vfs_dirent_s
+{
+    uint32_t    inum;                               /*! inode identifier                    */
+    uint32_t    type;                               /*! inode type                          */
+    char        name[CONFIG_VFS_MAX_NAME_LENGTH];   /*! dentry name                         */
+}
+vfs_dirent_t;
 …
 /*****************************************************************************************/
+/******************************************************************************************
+ * This function initializes the Virtual File System.
+ *****************************************************************************************/
+void vfs_init();
+/******************************************************************************************
+ * This function mount a given file system type for a given process.
+/******************************************************************************************
+ * This function mount a given file system type for a given process TODO.
  *****************************************************************************************/
 error_t vfs_mount_fs_root( struct device_s  * device,
 …
+/*****************************************************************************************/
+/************************ File Descriptor related functions ******************************/
+/*****************************************************************************************/
+/********************* Inode related functions *******************************************/
+/*****************************************************************************************/
+/******************************************************************************************
+ * This function allocates memory from local cluster for an inode descriptor and the
+ * associated mapper. It initialise these descriptors from arguments values.
+ * The parent dentry must have been previously created.
+ * If the client thread is not running in the cluster containing this inode,
+ * it must use the rpc_vfs_inode_create_client() function.
+ ******************************************************************************************
+ * @ dentry_xp  : extended pointer on associated dentry (in parent inode cluster).
+ * @ fs_type    : file system type.
+ * @ inode_type : inode type.
+ * @ attr       : inode attributes.
+ * @ rights     : inode access rights.
+ * @ uid        : user owner ID.
+ * @ gid        : group owner ID.
+ * @ inode_xp   : [out] buffer for extended pointer on created inode.
+ * # return 0 if success / return ENOMEM or EINVAL if error.
+ *****************************************************************************************/
+error_t vfs_inode_create( xptr_t            dentry_xp,
+                          vfs_fs_type_t     fs_type,
+                          vfs_inode_type_t  inode_type,
+                          uint32_t          attr,
+                          uint32_t          rights,
+                          uid_t             uid,
+                          gid_t             gid,
+                          xptr_t          * inode_xp );
+/******************************************************************************************
+ * This function releases memory allocated to an inode descriptor.
+ * It must be executed by a thread running in the cluster containing the inode,
+ * and the inode refcount must be zero.
+ * If the client thread is not running in the owner cluster, it must use the
+ * rpc_vfs_inode_destroy_client() function.
+ ******************************************************************************************
+ * @ inode  : local pointer on inode descriptor.
+ *****************************************************************************************/
+void vfs_inode_destroy( vfs_inode_t *  inode );
+/******************************************************************************************
+ * This function atomically increment/decrement the inode refcount.
+ * It can be called by any thread running in any cluster.
+ *****************************************************************************************/
+void vfs_inode_remote_up( xptr_t  inode_xp );
+void vfs_inode_remote_down( xptr_t  inode_xp );
+/******************************************************************************************
+ * This function returns the <size> of a file/dir from a remote inode,
+ * taking the remote_rwlock protecting <size> in READ_MODE.
+ *****************************************************************************************
+ * @ inode_xp  : extended pointer on the remote inode.
+ * @ return the current size.
+ *****************************************************************************************/
+uint32_t vfs_inode_get_size( xptr_t inode_xp );
+/******************************************************************************************
+ * This function set the <size> of a file/dir to a remote inode,
+ * taking the remote_rwlock protecting <size> in WRITE_MODE.
+ *****************************************************************************************
+ * @ inode_xp  : extended pointer on the remote inode.
+ * @ size      : value to be written.
+ *****************************************************************************************/
+void vfs_inode_set_size( xptr_t   inode_xp,
+                         uint32_t size );
+/******************************************************************************************
+ * This function takes the main lock of a remote inode.
+ * This lock protect all inode fiels, including the children dentries.
+ *****************************************************************************************
+ * @ inode_xp  : extended pointer on the remote inode.
+ *****************************************************************************************/
+void vfs_inode_remote_lock( xptr_t inode_xp );
+/******************************************************************************************
+ * This function releases the main lock of a remote inode.
+ * This lock protect all inode fiels, including the children dentries.
+ *****************************************************************************************
+ * @ inode_xp  : extended pointer on the remote inode.
+ *****************************************************************************************/
+void vfs_inode_remote_unlock( xptr_t inode_xp );
+/******************************************************************************************
+ * This function TODO
+ *****************************************************************************************/
+error_t vfs_inode_hold( vfs_inode_t * inode,
+                        uint32_t      gc );
+/******************************************************************************************
+ * This function TODO
+ *****************************************************************************************/
+error_t vfs_inode_trunc( vfs_inode_t * inode );
+/******************************************************************************************
+ * This function TODO
+ *****************************************************************************************/
+error_t vfs_inode_link( vfs_inode_t * inode,
+                        uint32_t      igc );
+/******************************************************************************************
+ * This function TODO
+ *****************************************************************************************/
+error_t vfs_inode_unlink( vfs_inode_t * inode );
+/******************************************************************************************
+ * This function TODO
+ *****************************************************************************************/
+error_t vfs_inode_stat( vfs_inode_t * inode,
+                        uint32_t      inum );
+/******************************************************************************************
+ * This function TODO
+ *****************************************************************************************/
+error_t vfs_icache_del( vfs_inode_t * inode );
+/******************************************************************************************
+ * This function TODO  Pourquoi 2 arguments ?
+ *****************************************************************************************/
+error_t vfs_stat_inode( vfs_inode_t * inode,
+                        uint32_t      inum );
+/*****************************************************************************************/
+/***************** Dentry related functions **********************************************/
+/*****************************************************************************************/
+/******************************************************************************************
+ * This function allocates memory from local cluster for a dentry descriptor,
+ * initialises it from  arguments values, and returns the extended pointer on dentry.
+ * The inode field is not initialized, because the inode does not exist yet.
+ * If the client thread is not running in the target cluster for this inode,
+ * it must use the rpc_dentry_create_client() function.
+ ******************************************************************************************
+ * @ fs_type    : file system type.
+ * @ name       : directory entry file/dir name.
+ * @ parent     : local pointer on parent inode.
+ * @ dentry_xp  : [out] buffer for extended pointer on created dentry.
+ * @ return 0 if success / return ENOMEM or EINVAL if error.
+ *****************************************************************************************/
+error_t vfs_dentry_create( vfs_fs_type_t   fs_type,
+                           char          * name,
+                           vfs_inode_t   * parent,
+                           xptr_t        * dentry_xp );
+/******************************************************************************************
+ * This function releases memory allocated to a dentry descriptor.
+ * It must be executed by a thread running in the cluster containing the dentry,
+ * and the dentry refcount must be zero.
+ * If the client thread is not running in the owner cluster, it must use the
+ * rpc_dentry_destroy_client() function.
+ ******************************************************************************************
+ * @ dentry  : local pointer on dentry descriptor.
+ *****************************************************************************************/
+void vfs_dentry_destroy( vfs_dentry_t *  dentry );
+/******************************************************************************************
+ * These functions atomically increment/decrement the dentry refcount.
+ * It can be called by any thread running in any cluster.
+ *****************************************************************************************/
+void vfs_dentry_remote_up( xptr_t dentry_xp );
+void vfs_dentry_remote_down( xptr_t dentry_xp );
+/*****************************************************************************************/
+/************************ File descriptor related functions ******************************/
 /*****************************************************************************************/
 /******************************************************************************************
  * This function allocates memory and initializes a new local file descriptor.
  * It must be executed in the owner cluster containing the inode.
+ * It must be executed in the cluster containing the inode.
  * If the client thread is not running in the owner cluster, it must use the
  * rpc_vfs_file_create_client() function.
  ******************************************************************************************
+ * @ inode_xp : extended pointer on associated inode.
+ * @ type     : file descriptor type.
+ * @ inode    : local pointer on associated inode.
  * @ attr     : file descriptor attributes.
  * @ file_xp  : [out] buffer for extended pointer on created file descriptor.
  * @ return 0 if success / return ENOMEM if error.
  *****************************************************************************************/
+error_t vfs_file_create( xptr_t     inode_xp,
+                         uint32_t   type,
+                         uint32_t   attr,
+                         xptr_t   * file_xp );
+error_t vfs_file_create( vfs_inode_t * inode,
+                         uint32_t      attr,
+                         xptr_t      * file_xp );
 /******************************************************************************************
 …
  * rpc_vfs_file_destroy_client() function.
  ******************************************************************************************
+ * @ file_xp  : extended pointer on file descriptor.
+ *****************************************************************************************/
+void vfs_file_destroy( xptr_t  file_xp );
+ * @ file  : local pointer on file descriptor.
+ *****************************************************************************************/
+void vfs_file_destroy( vfs_file_t *  file );
 /******************************************************************************************
 …
 /*****************************************************************************************/
+/********************* Inode related functions *******************************************/
+/*****************************************************************************************/
+/******************************************************************************************
+ * This function allocates memory from local cluster for an inode descriptor and the
+ * associated mapper. It initialise these descriptors from arguments values.
+ * The parent dentry must have been previously created.
+ * If the client thread is not running in the cluster containing this inode,
+ * it must use the rpc_vfs_inode_create_client() function.
+ ******************************************************************************************
+ * @ dentry_xp  : extended pointer on associated dentry (in parent inode cluster).
+ * @ type       : file system type.
+ * @ attr       : inode attributes.
+ * @ mode       : inode access mode.
+ * @ uid        : user owner ID.
+ * @ gid        : group owner ID.
+ * @ inode_xp   : [out] buffer for extended pointer on created inode.
+ * # return 0 if success / return ENOMEM or EINVAL if error.
+ *****************************************************************************************/
+error_t vfs_inode_create( xptr_t      dentry_xp,
+                          uint32_t    type,
+                          uint32_t    attr,
+                          uint32_t    mode,
+                          uid_t       uid,
+                          gid_t       gid,
+                          xptr_t    * inode_xp );
+/******************************************************************************************
+ * This function releases memory allocated to an inode descriptor.
+ * It must be executed by a thread running in the cluster containing the inode,
+ * and the inode refcount must be zero.
+ * If the client thread is not running in the owner cluster, it must use the
+ * rpc_vfs_inode_destroy_client() function.
+ ******************************************************************************************
+ * @ inode  : local pointer on inode descriptor.
+ *****************************************************************************************/
+void vfs_inode_destroy( vfs_inode_t *  inode );
+/******************************************************************************************
+ * This function atomically increment the inode refcount.
+ * It can be called by any thread running in any cluster.
+ *****************************************************************************************/
+void vfs_inode_remote_up( xptr_t  inode_xp );
+/******************************************************************************************
+ * This function atomically decrement the inode refcount.
+ * It can be called by any thread running in any cluster.
+ *****************************************************************************************/
+void vfs_inode_remote_down( xptr_t  inode_xp );
+/******************************************************************************************
+ * This function returns the <size> of a file/dir from a remote inode,
+ * taking the remote_rwlock protecting <size> in READ_MODE.
+ *****************************************************************************************
+ * @ inode_xp  : extended pointer on the remote inode.
+ * @ return the current size.
+ *****************************************************************************************/
+uint32_t vfs_inode_get_size( xptr_t inode_xp );
+/******************************************************************************************
+ * This function set the <size> of a file/dir to a remote inode,
+ * taking the remote_rwlock protecting <size> in WRITE_MODE.
+ *****************************************************************************************
+ * @ inode_xp  : extended pointer on the remote inode.
+ * @ size      : value to be written.
+ *****************************************************************************************/
+void vfs_inode_set_size( xptr_t   inode_xp,
+                         uint32_t size );
+/******************************************************************************************
+ * This function takes the main lock of a remote inode.
+ * This lock protect all inode fiels, including the children dentries.
+ *****************************************************************************************
+ * @ inode_xp  : extended pointer on the remote inode.
+ *****************************************************************************************/
+void vfs_inode_remote_lock( xptr_t inode_xp );
+/******************************************************************************************
+ * This function releases the main lock of a remote inode.
+ * This lock protect all inode fiels, including the children dentries.
+ *****************************************************************************************
+ * @ inode_xp  : extended pointer on the remote inode.
+ *****************************************************************************************/
+void vfs_inode_remote_unlock( xptr_t inode_xp );
+/******************************************************************************************
+ * This function TODO
+ *****************************************************************************************/
+error_t vfs_inode_hold( vfs_inode_t * inode,
+                        uint32_t      gc );
+/******************************************************************************************
+ * This function TODO
+ *****************************************************************************************/
+error_t vfs_inode_trunc( vfs_inode_t * inode );
+/******************************************************************************************
+ * This function TODO
+ *****************************************************************************************/
+error_t vfs_inode_link( vfs_inode_t * inode,
+                        uint32_t      igc );
+/******************************************************************************************
+ * This function TODO
+ *****************************************************************************************/
+error_t vfs_inode_unlink( vfs_inode_t * inode );
+/******************************************************************************************
+ * This function TODO
+ *****************************************************************************************/
+error_t vfs_inode_stat( vfs_inode_t * inode,
+                        uint32_t      inum );
+/******************************************************************************************
+ * This function TODO
+ *****************************************************************************************/
+error_t vfs_icache_del( vfs_inode_t * inode );
+/******************************************************************************************
+ * This function TODO  Pourquoi 2 arguments ?
+ *****************************************************************************************/
+error_t vfs_stat_inode( vfs_inode_t * inode,
+                        uint32_t      inum );
+/*****************************************************************************************/
+/***************** Dentry related functions **********************************************/
+/*****************************************************************************************/
+/******************************************************************************************
+ * This function allocates memory from local cluster for a dentry descriptor,
+ * initialises it from  arguments values, and returns the extended pointer on dentry.
+ * The inode field is not initialized, because the inode does not exist yet.
+ * If the client thread is not running in the target cluster for this inode,
+ * it must use the rpc_dentry_create_client() function.
+ ******************************************************************************************
+ * @ type       : file system type.
+ * @ name       : directory entry file/dir name.
+ * @ parent     : local pointer on parent inode.
+ * @ dentry_xp  : [out] buffer for extended pointer on created inode.
+ * @ return 0 if success / return ENOMEM or EINVAL if error.
+ *****************************************************************************************/
+error_t vfs_dentry_create( uint32_t      type,
+                           char        * name,
+                           vfs_inode_t * parent,
+                           xptr_t      * dentry_xp );
+/******************************************************************************************
+ * This function releases memory allocated to a dentry descriptor.
+ * It must be executed by a thread running in the cluster containing the dentry,
+ * and the dentry refcount must be zero.
+ * If the client thread is not running in the owner cluster, it must use the
+ * rpc_dentry_destroy_client() function.
+ ******************************************************************************************
+ * @ dentry  : local pointer on dentry descriptor.
+ *****************************************************************************************/
+void vfs_dentry_destroy( vfs_dentry_t *  dentry );
+/******************************************************************************************
+ * This function atomically increment the dentry refcount.
+ * It can be called by any thread running in any cluster.
+ *****************************************************************************************/
+void vfs_dentry_remote_up( xptr_t dentry_xp );
+/******************************************************************************************
+ * This function atomically decrement the dentry refcount.
+ * It can be called by any thread running in any cluster.
+ *****************************************************************************************/
+void vfs_dentry_remote_down( xptr_t dentry_xp );
+/*****************************************************************************************/
+/*                 Inode-Tree related functions                                          */
+/******************* Inode-Tree related functions ****************************************/
 /*****************************************************************************************/
 …
 /******************************************************************************************
  * This function takes a pathname (absolute or relative to cwd) and returns an extended
+ * pointer on the associated inode, and an extended pointer on the inode context.
+ * If a given name in the path is not found in the inode tree, it try to load the missing
+ * dentry/inode couple, from informations found in the parent directory.
+ * If this directory entry does not exist on device, it returns an error.
+ ******************************************************************************************
+ * @ cwd_xp     : extended pointer on current directory (for relative path).
+ * @ pathname   : path in kernel space (can be relative or absolute).
+ * @ client_uid : client thread user ID (for checking).
+ * @ client_gid : client thread group ID (for checking).
+ * @ inode_xp   : [out] buffer for extended pointer on inode.
+ * @ ctx_xp     : [out] buffer for extended pointer on inode context.
+ * @ return 0 if success / ENOENT if inode not found / EACCES if permissopn denied
+ *****************************************************************************************/
+error_t vfs_lookup( xptr_t       cwd_xp,
+                    char       * pathname,
+                    uint32_t     client_uid,
+                    uint32_t     client_gid,
+                                        xptr_t     * inode_xp,
+                    xptr_t     * ctx_xp );
+ * pointer on the associated inode.
+ * - If a given name in the path is not found in the inode tree, it try to load the missing
+ *   dentry/inode couple, from informations found in the parent directory.
+ * - If this directory entry does not exist on device, it returns an error.
+ * - If the the file identified by the pathname does not exist on device but the
+ *   flag CREATE is set, the inode is created.
+ * - If the the file identified by the pathname exist on device but both flags EXCL
+ *   and CREATE are set, an error is returned.
+ ******************************************************************************************
+ * @ cwd_xp      : extended pointer on current directory (for relative path).
+ * @ pathname    : path in kernel space (can be relative or absolute).
+ * @ lookup_mode : flags defining the working mode (defined above in this file).
+ * @ inode_xp    : [out] buffer for extended pointer on inode.
+ * @ return 0 if success / ENOENT if inode not found , EACCES if permissopn denied,
+ *                        EAGAIN if a new complete lookup must be made
+ *****************************************************************************************/
+error_t vfs_lookup( xptr_t             cwd_xp,
+                    char             * pathname,
+                    uint32_t           lookup_mode,
+                                        xptr_t           * inode_xp );
 /******************************************************************************************
 …
  * - The dentry is created in the cluster containing the existing <parent_xp> inode.
  * - the child inode and its associated mapper are created in a randomly selected cluster.
+ * - The dentry name is defined by the <name> argument.
+ ******************************************************************************************
+ * @ type       : new inode type
+ * - The new dentry name is defined by the <name> argument.
+ * - The new inode and the parent inode can have different FS types.
+ ******************************************************************************************
+ * @ inode_type : new inode type
+ * @ fs_type    : new inode FS type.
  * @ parent_xp  : extended pointer on parent inode.
  * @ name       : new directory entry name.
 …
  * @ return 0 if success / ENOENT if entry not found in parent directory
  *****************************************************************************************/
+error_t vfs_add_child_in_parent( uint32_t type,
+                                 xptr_t   parent_xp,
+                                 char   * name,
+                                 xptr_t * child_xp );
+/******************************************************************************************
+ * TODO
+error_t vfs_add_child_in_parent( vfs_inode_type_t   inode_type,
+                                 vfs_fs_type_t      fs_type,
+                                 xptr_t             parent_xp,
+                                 char             * name,
+                                 xptr_t           * child_xp );
+/******************************************************************************************
+ * This function removes a couple dentry/inode from the Inode-Tree, and remove it from
+ * the external device.
+ * TODO
  ******************************************************************************************
  * @ child_xp   : extended pointer on removed inode.
 …
 error_t vfs_remove_child_from_parent( xptr_t child_xp );
+/*****************************************************************************************/
+/************************ File related functions *****************************************/
+/*****************************************************************************************/
+/****************** File access API ******************************************************/
 /*****************************************************************************************/
 /******************************************************************************************
  * This function allocates a vfs_file_t structure in the cluster containing the inode
+ * associated to the requested file, initializes it, and returns an extended pointer
+ * on this remote open file descriptor.
+ * associated to the file identified by <cwd_xp> & <path>.
+ * It initializes it, register it in the reference process fd_array, and returns both
+ * the extended pointer on the remote file descriptor, and the index in the fd_array.
  * The pathname can be relative to current directory or absolute.
  * If the inode does not exist in the inode cache, it try to find file on the mounted
+ * If the inode does not exist in the inode cache, it try to find the file on the mounted
  * device, and creates an inode on a pseudo randomly selected cluster if found.
  * It the requested file does not exist on device, it creates a new inode if the
  * O_CREAT flag is set and return an error otherwise.
  ******************************************************************************************
+ * @ cwd_xp    : extended pointer on current directory file descriptor (for relative path).
+ * @ path      : file pathname (absolute or relative to current directory).
+ * @ flags     : O_RDONLY, O_WRONLY, O_CREATE etc...
+ * @ file_xp   : [out] buffer for extended pointer on created remote file descriptor.
+ * @ cwd_xp      : extended pointer on current working directory file descriptor.
+ * @ path        : file pathname (absolute or relative to current directory).
+ * @ flags       : defined above
+ * @ mode        : access rights (as defined by chmod)
+ * @ file_xp     : [out] buffer for extended pointer on created remote file descriptor.
+ * @ file_id     : [out] buffer for created file descriptor index in reference fd_array.
  * @ return 0 if success / return non-zero if error.
  *****************************************************************************************/
 …
                           char     * path,
                           uint32_t   flags,
+                          xptr_t   * file_xp );
+/******************************************************************************************
+ * This function moves <size> bytes from the file identified by the open file descriptor
+ * <file_xp> to the local kernel <buffer> , taken into account the offset in <file_xp>.
+ ******************************************************************************************
+ * @ file_xp   : extended pointer on the remote open file descriptor.
+ * @ buffer    : local pointer on destination kernel buffer.
+                  uint32_t   mode,
+                          xptr_t   * file_xp,
+                          uint32_t * file_id );
+/******************************************************************************************
+ * This function moves <size> bytes between the file identified by the open file descriptor
+ * <file_xp> and a local kernel <buffer> , taken into account the offset in <file_xp>.
+ * The transfer direction is defined by the <to_buffer> argument.
+ ******************************************************************************************
+ * @ to_buffer : mapper -> buffer if true / buffer->mapper if false.
+ * @ file_xp   : extended pointer on the remote file descriptor.
+ * @ buffer    : local pointer on local kernel buffer.
  * @ size      : requested number of bytes from offset.
- * @ returns number of bytes actually transfered / 0 if EOF / -1 if error.
- *****************************************************************************************/
-uint32_t vfs_read( xptr_t   file_xp,
-                   void   * buffer,
-                   uint32_t size );
-/******************************************************************************************
- * This function moves <size> bytes from the local kernel <buffer> to the open file
- * descriptor <file_xp>, taken into account the offset defined in <file_xp>.
- ******************************************************************************************
- * @ file_xp   : extended pointer on the remote open file descriptor.
- * @ buffer    : local pointer on source kernel buffer.
- * @ size      : requested number of bytes to be written from offset.
  * @ returns number of bytes actually transfered / -1 if error.
  *****************************************************************************************/
+uint32_t vfs_write( xptr_t   file_xp,
+                    void   * buffer,
+                    uint32_t size );
+error_t vfs_move( bool_t   to_buffer,
+                  xptr_t   file_xp,
+                  void   * buffer,
+                  uint32_t size );
 /******************************************************************************************
 …
 /******************************************************************************************
+ * This function close an open file descriptor.
+ * This function close an open file descriptor:
+ * 1) All entries in fd_array copies are directly cancelled by the calling thread,
+ *    using remote accesses.
+ * 2) The memory allocated to file descriptor in cluster containing the inode is released.
+ *    It requires a RPC if cluster containing the file descriptor is remote.
  ******************************************************************************************
  * @ file_xp     : extended pointer on the file descriptor.
  * @ refcount    : number of references after close.
  * @ return 0 if success / return -1 if error
  *****************************************************************************************/
 error_t vfs_close( xptr_t     file_xp,
                    uint32_t * refcount );
 /******************************************************************************************
  * This function remove from the file system a directory entry identified by its pathname.
  * The pathname can be relative to current directory or absolute.
  ******************************************************************************************
  * @ cwd_xp   : extended pointer on the current directory file descriptor.
+ * @ file_id     : file descriptor index in fd_array.
+ * @ returns 0 if success / -1 if error.
+ *****************************************************************************************/
+error_t vfs_close( xptr_t    file_xp,
+                   uint32_t  file_id );
+/******************************************************************************************
+ * This function remove from the file system a directory entry identified by the
+ * <cwd_xp> & <path> arguments.
+ ******************************************************************************************
+ * @ cwd_xp   : extended pointer on the current working directory file descriptor.
  * @ path     : pathname (absolute or relative to current directory).
+ * @ returns 0 if success / -1 if error.
  *****************************************************************************************/
 error_t vfs_unlink( xptr_t   cwd_xp,
 …
 /******************************************************************************************
+ * This function returns in the <ustat> structure various informations on the file TODO
+ * This function returns, in the structure pointed by the <k_stat> kernel pointer,
+ * various informations on the file descriptor identified by the <file_xp> argument.
+ * TODO not implemented yet...
+ ******************************************************************************************
+ * @ file_xp    : extended pointer on the file descriptor of the searched directory .
+ * @ k_dirent   : local pointer on the dirent_t structure in kernel space.
+ * @ returns 0 if success / -1 if error.
  *****************************************************************************************/
 error_t vfs_stat( xptr_t       file_xp,
+                  vfs_stat_t * ustat );
+/*****************************************************************************************/
+/************************ Directory related functions ************************************/
+/*****************************************************************************************/
+/******************************************************************************************
+ * This function TODO
+ *****************************************************************************************/
+error_t vfs_opendir( xptr_t      cwd_xp,
+                     char      * path,
+                     uint32_t    flags,
+                     xptr_t      file_xp );
+/******************************************************************************************
+ * This function TODO
+ *    fat32_readdir need cleaning
+ *****************************************************************************************/
+error_t vfs_readdir( xptr_t            file_xp,
+                     char            * path );
+/******************************************************************************************
+ * This function TODO
+ *****************************************************************************************/
+error_t vfs_mkdir( xptr_t            file_xp,
+                   char            * path,
+                   uint32_t          mode );
+/******************************************************************************************
+ * This function remove a directory from the file system.
+ *****************************************************************************************/
+error_t vfs_rmdir( xptr_t            file_xp,
+                   char            * path );
+/******************************************************************************************
+ * This function TODO
+ *****************************************************************************************/
+error_t vfs_chdir( char            * pathname,
+                   xptr_t            cwd_xp );
+/******************************************************************************************
+ * This function TODO
+ *****************************************************************************************/
+error_t vfs_chmod( char            * pathname,
+                   vfs_file_t      * cwd,
+                   uint32_t          mode );
+/******************************************************************************************
+ * This function TODO
+ *****************************************************************************************/
+error_t vfs_closedir( xptr_t       file_xp,
+                      uint32_t   * refcount );
+/*****************************************************************************************/
+/*******************  Pipe related functions *********************************************/
+/*****************************************************************************************/
+/******************************************************************************************
+ * This function TODO ???
+ *****************************************************************************************/
+error_t vfs_pipe( xptr_t pipefd[2] );
+/******************************************************************************************
+ * This function TODO
+ *****************************************************************************************/
+error_t vfs_mkfifo( xptr_t            cwd_xp,
+                    char            * path,
+                    uint32_t          mode );
+                  vfs_stat_t * k_stat );
+/******************************************************************************************
+ * 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_t structure in kernel space.
+ * @ returns 0 if success / -1 if error.
+ *****************************************************************************************/
+error_t vfs_readdir( xptr_t         file_xp,
+                     vfs_dirent_t * k_dirent );
+/******************************************************************************************
+ * This function  creates a new inode and associated dentry  for the directory defined
+ * by the <cwd_xp> & <path> arguments.
+ * TODO not implemented yet...
+ ******************************************************************************************
+ * @ cwd_xp   : extended pointer on the current working directory file descriptor.
+ * @ path     : pathname (absolute or relative to current directory).
+ * @ mode     : access rights (as defined by chmod)
+ * @ returns 0 if success / -1 if error.
+ *****************************************************************************************/
+error_t vfs_mkdir( xptr_t     cwd_xp,
+                   char     * path,
+                   uint32_t   mode );
+/******************************************************************************************
+ * This function remove a directory identified by the <cwd_xp / path> arguments
+ * from the file system.
+ * TODO not implemented yet...
+ ******************************************************************************************
+ * @ cwd_xp   : extended pointer on the current working directory file descriptor.
+ * @ path     : pathname (absolute or relative to current directory).
+ * @ returns 0 if success / -1 if error.
+ *****************************************************************************************/
+error_t vfs_rmdir( xptr_t   cwd_xp,
+                   char   * path );
+/******************************************************************************************
+ * This function makes the directory identified by <cwd_xp / path> arguments to become
+ * the working directory for the calling process.
+ ******************************************************************************************
+ * @ cwd_xp      : extended pointer on current directory file descriptor (relative path).
+ * @ path        : file pathname (absolute or relative to current directory).
+ * return 0 if success / -1 if error.
+ *****************************************************************************************/
+error_t vfs_chdir( xptr_t   cwd_xp,
+                   char   * path );
+/******************************************************************************************
+ * This function change the access rigths for the file identified by the <cwd_xp / path>
+ * arguments. The new access rights are defined by the <mode> argument value.
+ ******************************************************************************************
+ * @ cwd_xp      : extended pointer on current directory file descriptor (relative path).
+ * @ path        : file pathname (absolute or relative to current directory).
+ * @ mode        : access rights new value.
+ * return 0 if success / -1 if error.
+ *****************************************************************************************/
+error_t vfs_chmod( xptr_t        cwd_xp,
+                   char        * path,
+                   uint32_t      mode );
+/******************************************************************************************
+ * This function creates a named FIFO file.
+ * TODO not implemented yet
+ ******************************************************************************************
+ * @ path        : FIFO pathname (absolute or relative to current directory).
+ * @ cwd_xp      : extended pointer on the current working directory file descriptor.
+ * @ mode        : access rights new value.
+ *****************************************************************************************/
+error_t vfs_mkfifo( xptr_t       cwd_xp,
+                    char       * path,
+                    uint32_t     mode );
+/*****************************************************************************************/
+/****************** Mapper access API ****************************************************/
+/*****************************************************************************************/
+/******************************************************************************************
+ * This function makes an I/O operation to move one page from VFS to a given mapper,
+ * in case of MISS on the mapper cache.
+ * Depending on the file system type, it calls the proper, FS specific function.
+ * It must be executed by a thread running in the cluster containing the mapper.
+ * The mapper pointer is obtained from the page descriptor.
+ * It takes the mapper lock before launching the IO operation.
+ ******************************************************************************************
+ * @ page   : local pointer on the page descriptor.
+ * @ returns 0 if success / return EINVAL if it cannot access the external device.
+ *****************************************************************************************/
+error_t vfs_move_page_to_mapper( struct page_s * page );
+/******************************************************************************************
+ * This function makes an I/0 operation to move one page from a given mapper to VFS,
+ * when a dirty page in the mapper cache must be updated in the File System.
+ * Depending on the file system type, it calls the proper, FS specific function.
+ * It must be executed by a thread running in the cluster containing the mapper.
+ * The mapper pointer is obtained from the page descriptor.
+ * It takes the mapper lock before launching the IO operation.
+ * It does nothing if the page is not dirty. If the page is dirty, it clear the page
+ * dirty bit, and remove the page from the PPM dirty list.
+ ******************************************************************************************
+ * @ page   : local pointer on the page descriptor.
+ * @ returns 0 if success / return EINVAL if it cannot access the external device.
+ *****************************************************************************************/
+error_t vfs_move_page_from_mapper( struct page_s * page );
+///////////////////////////////////////////////////////////////////////////////////////////
+// These typedef define the FS specific operations that must be implemented by any
+// specific file system to be supported by the ALMOS_MKH VFS.
+// These typedef are not actually used, and are only defined for documentation
+///////////////////////////////////////////////////////////////////////////////////////////
+typedef error_t (fs_init_t)          ( xptr_t vfs_root_xp );
+typedef error_t (fs_inode_extend_t)  ( struct vfs_inode_s * inode,
+                                       void               * extend );
+typedef void    (fs_inode_release_t) ( struct vfs_inode_s * inode );
+typedef error_t (fs_write_page_t)    ( struct page_s * page );
+typedef error_t (fs_read_page_t)     ( struct page_s * page );
+/* deprecated [AG]
+typedef error_t (lookup_inode_t)  ( vfs_inode_t  * parent ,
+                                    vfs_dentry_t * dentry );
+typedef error_t (write_inode_t)   ( vfs_inode_t  * inode );
+typedef error_t (release_inode_t) ( vfs_inode_t  * inode );
+typedef error_t (unlink_inode_t)  ( vfs_inode_t  * parent,
+                                    vfs_dentry_t * dentry,
+                                    uint32_t       flags );
+typedef error_t (stat_inode_t)    ( vfs_inode_t  * inode );
+typedef error_t (trunc_inode_t)   ( vfs_inode_t  * inode );
+typedef error_t (delete_inode_t)  ( vfs_inode_t  * inode );
+typedef struct vfs_inode_op_s
+{
+        init_inode_t    * init;
+        create_inode_t  * create;
+        lookup_inode_t  * lookup;
+        write_inode_t   * write;
+        release_inode_t * release;
+        unlink_inode_t  * unlink;
+        delete_inode_t  * delete;
+        stat_inode_t    * stat;
+        trunc_inode_t   * trunc;    // change the size of a file
+}
+vfs_inode_op_t;
+ ******************************************************************************************
+ * These typedef define the set of FS specific operations on a VFS DENTRY descriptor.
+ * They must be implemented by any specific file system to be supported by ALMOS_MKH.
+ * This code is not actually used, and is only defined for documentation
+ ******************************************************************************************
+typedef error_t (vfs_compare_dentry_t) ( char * first , char * second );
+typedef struct vfs_dentry_op_s
+{
+        vfs_compare_dentry_t * compare;
+}
+vfs_dentry_op_t;
+ ******************************************************************************************
+ * These typedef define the set of FS specific operations on FILE descriptors
+ * They must be implemented by any specific file system to be supported by ALMOS_MKH.
+ * This code is not actually used, and is only defined for documentation
+ ******************************************************************************************
+typedef error_t (open_file_t   ) ( vfs_file_t * file,
+                                   void       * extend );
+typedef error_t (read_file_t   ) ( vfs_file_t * file,
+                                   char       * buffer,
+                                   uint32_t     count );
+typedef error_t (write_file_t  ) ( vfs_file_t * file,
+                                   char       * buffer,
+                                   uint32_t     count );
+typedef error_t (lseek_file_t  ) ( vfs_file_t * file );
+typedef error_t (close_file_t  ) ( vfs_file_t * file );
+typedef error_t (release_file_t) ( vfs_file_t * file );
+typedef error_t (read_dir_t    ) ( vfs_file_t * file );
+typedef error_t (mmap_file_t   ) ( vfs_file_t    * file ,
+                                   struct vseg_s * vseg );
+typedef error_t (munmap_file_t ) ( vfs_file_t    * file,
+                                   struct vseg_s * vseg );
+typedef struct vfs_file_op_s
+{
+        open_file_t    * open;
+        read_file_t    * read;
+        write_file_t   * write;
+        lseek_file_t   * lseek;
+        read_dir_t     * readdir;
+        close_file_t   * close;
+        release_file_t * release;
+        mmap_file_t    * mmap;
+        munmap_file_t  * munmap;
+}
+vfs_file_op_t;
+*/
 #endif  /* _VFS_H_ */

Context Navigation

Legend:

Download in other formats: