Changeset 408 for trunk/kernel

trunk/kernel/devices/dev_dma.c

-                      r407
+                      r408
     // set dma name
     snprintf( dma->name , 16 , "dma_%d_%x" , channel , local_cxy );
+    snprintf( dma->name , 16 , "dma%d_%x" , channel , local_cxy );
     // call driver init function
 …
+    }
     // initialises server field in DMA chdev descriptor
+    // initialises server field in chdev descriptor
     dma->server = new_thread;
+    // initializes chdev field in thread descriptor
+    new_thread->chdev = dma;
+    // start server thread
+    thread_block( new_thread , THREAD_BLOCKED_DEV_QUEUE );
+    // unblock server thread
     thread_unblock( XPTR( local_cxy , new_thread ) , THREAD_BLOCKED_GLOBAL );

trunk/kernel/devices/dev_fbf.c

r407	r408
40	40	{
41	41	// set FBF chdev extension fields
42		// TODO this should be done in the impementation
	42	// TODO this should be done in the implementation
43	43	// TODO specific part, as these parameters must be obtained from the hardware.
44	44	chdev->ext.fbf.width = CONFIG_FBF_WIDTH;

trunk/kernel/devices/dev_ioc.c

-                      r407
+                      r408
     assert( (error == 0) , __FUNCTION__ , "cannot create server thread" );
     // set "server" field in ioc descriptor
+    // set "server" field in chdev descriptor
     ioc->server = new_thread;
+    // start server thread
+    thread_block( new_thread , THREAD_BLOCKED_DEV_QUEUE );
+    // set "chdev field in thread descriptor
+    new_thread->chdev = ioc;
+    // unblock server thread
     thread_unblock( XPTR( local_cxy , new_thread ) , THREAD_BLOCKED_GLOBAL );

trunk/kernel/devices/dev_nic.c

-                      r407
+                      r408
     nic->server = new_thread;
+    // start server thread
+    thread_block( new_thread , THREAD_BLOCKED_DEV_QUEUE );
+    // set "chdev" field in thread descriptor
+    new_thread->chdev = nic;
+    // unblock server thread
     thread_unblock( XPTR( local_cxy , new_thread ) , THREAD_BLOCKED_GLOBAL );
 …
     // get pointer on NIC-RX chdev descriptor
     uint32_t   channel = thread_ptr->dev_channel;
+    uint32_t   channel = thread_ptr->chdev->channel;
     xptr_t     dev_xp  = chdev_dir.nic_rx[channel];
     cxy_t      dev_cxy = GET_CXY( dev_xp );
 …
         // block on THREAD_BLOCKED_IO condition and deschedule
         thread_block( thread_ptr , THREAD_BLOCKED_IO );
         sched_yield();
+        sched_yield("client blocked on I/O");
         // disable NIC-RX IRQ
 …
     // get pointer on NIC-TX chdev descriptor
     uint32_t   channel = thread_ptr->dev_channel;
+    uint32_t   channel = thread_ptr->chdev->channel;
     xptr_t     dev_xp  = chdev_dir.nic_tx[channel];
     cxy_t      dev_cxy = GET_CXY( dev_xp );
 …
         // block on THREAD_BLOCKED I/O condition and deschedule
         thread_block( thread_ptr , THREAD_BLOCKED_IO );
         sched_yield();
+        sched_yield("client blocked on I/O");
         // disable NIC-TX IRQ

trunk/kernel/devices/dev_txt.c

-                      r407
+                      r408
         txt->server = new_thread;
+        // start server thread
+        thread_block( new_thread , THREAD_BLOCKED_DEV_QUEUE );
+        // set "chdev" field in thread descriptor
+        new_thread->chdev = txt;
+        // unblock server thread
         thread_unblock( XPTR( local_cxy , new_thread ) , THREAD_BLOCKED_GLOBAL );
+    }

trunk/kernel/fs/vfs.c

r407	r408
3	3	*
4	4	* Author Mohamed Lamine Karaoui (2015)
5		* Alain Greiner (2016)
	5	* Alain Greiner (2016,2017)
6	6	*
7	7	* Copyright (c) UPMC Sorbonne Universites

trunk/kernel/kern/chdev.c

-                      r407
+                      r408
     uint32_t   lid;           // core running the server thread local index
     xptr_t     lock_xp;       // extended pointer on lock protecting the chdev queue
     uint32_t   modified;      // non zero if the server thread state was modified
+    uint32_t   different;     // non zero if server thread core != client thread core
     uint32_t   save_sr;       // for critical section
 …
     lid = hal_remote_lw( XPTR( chdev_cxy , &core_ptr->lid ) );
+    // enter critical section
+    // compute server core != thread core
+    different = (lid != this->core->lid) || (local_cxy != chdev_cxy);
+    // enter critical section to make atomic :
+    // (1) client blocking
+    // (2) client registration in server queue
+    // (3) IPI to force server scheduling
+    // (4) descheduling
+    // ... in this order
     hal_disable_irq( &save_sr );
+    // block current thread
+    thread_block( CURRENT_THREAD , THREAD_BLOCKED_IO );
     // register client thread in waiting queue
 …
     remote_spinlock_unlock( lock_xp );
+    // unblock server thread
+    modified = thread_unblock( XPTR( chdev_cxy , server_ptr ), THREAD_BLOCKED_DEV_QUEUE );
+    // send IPI to core running the server thread
+    if( modified ) dev_pic_send_ipi( chdev_cxy , lid );
+    // send IPI to core running the server thread if required
+    if( different ) dev_pic_send_ipi( chdev_cxy , lid );
-    // block client thread
-    assert( thread_can_yield( this ) , __FUNCTION__ , "illegal sched_yield\n" );
 chdev_dmsg("\n[DBG] %s : core[%x,%d] (thread %s) deschedules / cycle %d\n",
 __FUNCTION__, local_cxy, this->core->lid, thread_type_str(this->type) , hal_time_stamp() );
+    thread_block( CURRENT_THREAD , THREAD_BLOCKED_IO );
+    sched_yield();
+    // deschedule
+    assert( thread_can_yield( this ) , __FUNCTION__ , "illegal sched_yield\n" );
+    sched_yield("blocked on I/O");
 chdev_dmsg("\n[DBG] %s : core[%x,%d] (thread %s) resumes / cycle %d\n",
 …
 __FUNCTION__ , server , hal_time_stamp() );
+            // block and deschedule
+            thread_block( server , THREAD_BLOCKED_DEV_QUEUE );
+            sched_yield();
+            // deschedule
+            sched_yield("I/O queue empty");
 chdev_dmsg("\n[DBG] %s : thread %x resume /cycle %d\n",

trunk/kernel/kern/cluster.c

-                      r407
+                      r408
 #include <dqdt.h>
 ///////////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////
 // Extern global variables
 ///////////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////
 extern process_t process_zero;     // allocated in kernel_init.c file
-//////////////////////////////////
-void cluster_sysfs_register(void)
+{
-        // TODO
+}
 /////////////////////////////////////////////////

trunk/kernel/kern/cluster.h

-                      r407
+                      r408
  * This function allocates a new PID in local cluster, that becomes the process owner.
  * It registers the process descriptor extended pointer in the local processs manager
  * pref_tbl[] array. This function is called by the rpc_process_alloc_pid() function for
  * remote registration, or by the process_init_create() function for local registration.
+ * pref_tbl[] array. This function is called by the process_make_fork() function,
+ * or by the process_init_create() function.
  ******************************************************************************************
  * @ process    : [in]  extended pointer on the process descriptor.

trunk/kernel/kern/core.c

r407	r408
111	111
112	112	// handle scheduler
113		if( (ticks % CONFIG_SCHED_TICKS_PER_QUANTUM) == 0 ) sched_yield();
	113	if( (ticks % CONFIG_SCHED_TICKS_PER_QUANTUM) == 0 ) sched_yield( "TICK");
114	114
115	115	// update DQDT

trunk/kernel/kern/do_syscall.c

-                      r407
+                      r408
 #include <printk.h>
 #include <syscalls.h>
+#include <shared_syscalls.h>
 /////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////
 // This ƒonction should never be called...
 /////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////
 static int sys_undefined()
+{
 …
+}
 /////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////
 // This array of pointers define the kernel functions implementing the syscalls.
 // It must be kept consistent with the enum in "shared_syscalls.h" file.
 /////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////
 typedef int (*sys_func_t) ();
 …
     sys_mutex,              // 9
     sys_undefined,          // 10
+    sys_exit,               // 10
     sys_munmap,             // 11
     sys_open,               // 12
 …
 };
+////////////////////////////////////
+char * syscall_str( uint32_t index )
+{
+        if     ( index == SYS_THREAD_EXIT    ) return "THREAD_EXIT";      // 0
+        else if( index == SYS_THREAD_YIELD   ) return "THREAD_YIELD";     // 1
+        else if( index == SYS_THREAD_CREATE  ) return "THREAD_CREATE";    // 2
+        else if( index == SYS_THREAD_JOIN    ) return "THREAD_JOIN";      // 3
+        else if( index == SYS_THREAD_DETACH  ) return "THREAD_DETACH";    // 4
+        else if( index == SYS_SEM            ) return "SEM";              // 6
+        else if( index == SYS_CONDVAR        ) return "CONDVAR";          // 7
+        else if( index == SYS_BARRIER        ) return "BARRIER";          // 8
+        else if( index == SYS_MUTEX          ) return "MUTEX";            // 9
+    else if( index == SYS_EXIT           ) return "EXIT";             // 10
+    else if( index == SYS_MUNMAP         ) return "MUNMAP";           // 11
+        else if( index == SYS_OPEN           ) return "OPEN";             // 12
+        else if( index == SYS_MMAP           ) return "MMAP";             // 13
+        else if( index == SYS_READ           ) return "READ";             // 14
+        else if( index == SYS_WRITE          ) return "WRITE";            // 15
+        else if( index == SYS_LSEEK          ) return "LSEEK";            // 16
+        else if( index == SYS_CLOSE          ) return "CLOSE";            // 17
+        else if( index == SYS_UNLINK         ) return "UNLINK";           // 18
+        else if( index == SYS_PIPE           ) return "PIPE";             // 19
+        else if( index == SYS_CHDIR          ) return "CHDIR";            // 20
+        else if( index == SYS_MKDIR          ) return "MKDIR";            // 21
+        else if( index == SYS_MKFIFO         ) return "MKFIFO";           // 22
+        else if( index == SYS_OPENDIR        ) return "OPENDIR";          // 23
+        else if( index == SYS_READDIR        ) return "READDIR";          // 24
+        else if( index == SYS_CLOSEDIR       ) return "CLOSEDIR";         // 25
+        else if( index == SYS_GETCWD         ) return "GETCWD";           // 26
+        else if( index == SYS_ALARM          ) return "ALARM";            // 28
+        else if( index == SYS_RMDIR          ) return "RMDIR";            // 29
+        else if( index == SYS_UTLS           ) return "UTLS";             // 30
+        else if( index == SYS_CHMOD          ) return "CHMOD";            // 31
+        else if( index == SYS_SIGNAL         ) return "SIGNAL";           // 32
+        else if( index == SYS_TIMEOFDAY      ) return "TIMEOFDAY";        // 33
+        else if( index == SYS_KILL           ) return "KILL";             // 34
+        else if( index == SYS_GETPID         ) return "GETPID";           // 35
+        else if( index == SYS_FORK           ) return "FORK";             // 36
+        else if( index == SYS_EXEC           ) return "EXEC";             // 37
+        else if( index == SYS_STAT           ) return "STAT";             // 38
+        else if( index == SYS_TRACE          ) return "TRACE";            // 39
+    else if( index == SYS_GET_CONFIG     ) return "GET_CONFIG";       // 40
+    else if( index == SYS_GET_CORE       ) return "GET_CORE";         // 41
+    else if( index == SYS_GET_CYCLE      ) return "GET_CYCLE";        // 42
+    else if( index == SYS_GET_SCHED      ) return "GET_SCHED";        // 43
+    else if( index == SYS_PANIC          ) return "PANIC";            // 44
+        else if( index == SYS_SLEEP          ) return "SLEEP";            // 45
+        else if( index == SYS_WAKEUP         ) return "WAKEUP";           // 46
+    else                                   return "undefined";
+}
 //////////////////////////////////
 reg_t do_syscall( thread_t * this,
 …
                           reg_t      service_num )
+{
         int           error = 0;
+        int  error = 0;
     // update user time
         thread_user_time_update( this );
-    // enable interrupts
-        hal_enable_irq( NULL );
     // check syscall index
         if( service_num >= SYSCALLS_NR )
 …
+        }
-#if( CONFIG_SYSCALL_DEBUG & 0x1)
-printk("\n[DBG] %s : pid = %x / trdid = %x / service #%d\n"
-"      arg0 = %x / arg1 = %x / arg2 = %x / arg3 = %x\n",
-__FUNCTION__ , this->process->pid , this->trdid , service_num , arg0 , arg1 , arg2 , arg3 );
-#endif
     // reset errno
         this->errno = 0;
 …
         error = syscall_tbl[service_num] ( arg0 , arg1 , arg2 , arg3 );
-    // disable interrupt
-        hal_disable_irq( NULL );
     // update kernel time
         thread_kernel_time_update( this );

trunk/kernel/kern/do_syscall.h

-                      r407
+                      r408
 #include <thread.h>
 /********************************************************************************************
+/**************************************************************************************
  * This function calls the kernel function defined by the <service_num> argument.
+ * The possible values for servic_num are defined in the syscalls/syscalls.h file.
+ ********************************************************************************************
+ * The possible values for service_num are defined in the syscalls/syscalls.h file.
+ * It does NOT enable interrupts, that must be enabled by the kernel function
+ * depending on the implemented service.
+ **************************************************************************************
  * @ this        : pointer on calling thread descriptor
  * @ arg0        : kernel function argument 0
 …
  * @ service_num : kernel service index
  * @ return 0 if success / return non zero if failure.
  *******************************************************************************************/
+ *************************************************************************************/
 reg_t do_syscall( thread_t * this,
                   reg_t      arg0,

trunk/kernel/kern/kernel_init.c

-                      r407
+                      r408
 vfs_ctx_t            fs_context[FS_TYPES_NR]                 CONFIG_CACHE_LINE_ALIGNED;
+// These variables are used by the sched_yield function to save SR value
+__attribute__((section(".kdata")))
+uint32_t             switch_save_sr[CONFIG_MAX_LOCAL_CORES]  CONFIG_CACHE_LINE_ALIGNED;
+#if CONFIG_READ_DEBUG
+// TODO remove these debug variables used dans sys_read()
+#if CONFIG_READ_DEBUG
 uint32_t   enter_sys_read;
 uint32_t   exit_sys_read;
 …
 ///////////////////////////////////////////////////////////////////////////////////////////
 // This function allocates memory and initializes the chdev descriptors for the
 // external (shared) peripherals other than the IOPIC, as specified by the boot_info,
 // including the dynamic linking with the driver for the specified implementation.
+// external (shared) peripherals other than the IOPIC, as specified by the boot_info.
+// This includes the dynamic linking with the driver for the specified implementation.
 // These chdev descriptors are distributed on all clusters, using a modulo on a global
+// index, identically computed in all clusters: In each cluster, the local CP0 core
+// computes the global index for all external chdevs, and creates only the chdevs that
+// must be placed in the local cluster.
+// index, identically computed in all clusters.
+// This function is executed in all clusters by the CP0 core, that computes a global index
+// for all external chdevs. Each CP0 core creates only the chdevs that must be placed in
+// the local cluster, because the global index matches the local index.
 // The relevant entries in all copies of the devices directory are initialised.
 ///////////////////////////////////////////////////////////////////////////////////////////
 …
     // all CP0s initialize the process_zero descriptor
     if( core_lid == 0 ) process_reference_init( &process_zero , 0 , XPTR_NULL );
+    if( core_lid == 0 ) process_zero_init( &process_zero );
     // CP0 in cluster 0 initializes the PIC chdev,

trunk/kernel/kern/printk.c

-                      r407
+                      r408
+}
+//////////////////////////
+void puts( char * string )
+{
+    uint32_t   save_sr;
+    uint32_t   n = 0;
+    // compute string length
+    while ( string[n] > 0 ) n++;
+    // get pointers on TXT0 chdev
+    xptr_t    txt0_xp  = chdev_dir.txt_tx[0];
+    cxy_t     txt0_cxy = GET_CXY( txt0_xp );
+    chdev_t * txt0_ptr = GET_PTR( txt0_xp );
+    // get extended pointer on remote TXT0 chdev lock
+    xptr_t  lock_xp = XPTR( txt0_cxy , &txt0_ptr->wait_lock );
+    // get TXT0 lock in busy waiting mode
+    remote_spinlock_lock_busy( lock_xp , &save_sr );
+    // display string on TTY0
+    dev_txt_sync_write( string , n );
+    // release TXT0 lock in busy waiting mode
+    remote_spinlock_unlock_busy( lock_xp , save_sr );
+}
+/////////////////////////
+void putx( uint32_t val )
+{
+    static const char HexaTab[] = "0123456789ABCDEF";
+    char      buf[10];
+    uint32_t  c;
+    uint32_t  save_sr;
+    buf[0] = '0';
+    buf[1] = 'x';
+    // build buffer
+    for (c = 0; c < 8; c++)
+    {
+        buf[9 - c] = HexaTab[val & 0xF];
+        val = val >> 4;
+    }
+    // get pointers on TXT0 chdev
+    xptr_t    txt0_xp  = chdev_dir.txt_tx[0];
+    cxy_t     txt0_cxy = GET_CXY( txt0_xp );
+    chdev_t * txt0_ptr = GET_PTR( txt0_xp );
+    // get extended pointer on remote TXT0 chdev lock
+    xptr_t  lock_xp = XPTR( txt0_cxy , &txt0_ptr->wait_lock );
+    // get TXT0 lock in busy waiting mode
+    remote_spinlock_lock_busy( lock_xp , &save_sr );
+    // display string on TTY0
+    dev_txt_sync_write( buf , 10 );
+    // release TXT0 lock in busy waiting mode
+    remote_spinlock_unlock_busy( lock_xp , save_sr );
+}
+/////////////////////////
+void putl( uint64_t val )
+{
+    static const char HexaTab[] = "0123456789ABCDEF";
+    char      buf[18];
+    uint32_t  c;
+    uint32_t  save_sr;
+    buf[0] = '0';
+    buf[1] = 'x';
+    // build buffer
+    for (c = 0; c < 16; c++)
+    {
+        buf[17 - c] = HexaTab[(unsigned int)val & 0xF];
+        val = val >> 4;
+    }
+    // get pointers on TXT0 chdev
+    xptr_t    txt0_xp  = chdev_dir.txt_tx[0];
+    cxy_t     txt0_cxy = GET_CXY( txt0_xp );
+    chdev_t * txt0_ptr = GET_PTR( txt0_xp );
+    // get extended pointer on remote TXT0 chdev lock
+    xptr_t  lock_xp = XPTR( txt0_cxy , &txt0_ptr->wait_lock );
+    // get TXT0 lock in busy waiting mode
+    remote_spinlock_lock_busy( lock_xp , &save_sr );
+    // display string on TTY0
+    dev_txt_sync_write( buf , 18 );
+    // release TXT0 lock in busy waiting mode
+    remote_spinlock_unlock_busy( lock_xp , save_sr );
+}
 // Local Variables:

trunk/kernel/kern/printk.h

-                      r407
+                      r408
 /**********************************************************************************
  * This function displays a "PANIC" message and forces the calling core in
  * sleeping mode if a Boolean condition is false.
  * These functions are actually used to debug the kernel...
+ * This function displays a formated message on kernel TXT0 terminal,
+ * and forces the calling core in sleeping mode if a Boolean condition is false.
+ * This function is actually used to debug the kernel...
  **********************************************************************************
  * @ condition     : condition that must be true.
 …
              const char * function_name,
              char       * format , ... );
+/**********************************************************************************
+ * This function displays a non-formated message on kernel TXT0 terminal.
+ * This function is actually used to debug the assembly level kernel functions.
+ **********************************************************************************
+ * @ string   : non-formatted string.
+ *********************************************************************************/
+void puts( char * string );
+/**********************************************************************************
+ * This function displays a 32 bits value in hexadecimal on kernel TXT0 terminal.
+ * This function is actually used to debug the assembly level kernel functions.
+ **********************************************************************************
+ * @ val   : 32 bits unsigned value.
+ *********************************************************************************/
+void putx( uint32_t val );
+/**********************************************************************************
+ * This function displays a 64 bits value in hexadecimal on kernel TXT0 terminal.
+ * This function is actually used to debug the assembly level kernel functions.
+ **********************************************************************************
+ * @ val   : 64 bits unsigned value.
+ *********************************************************************************/
+void putl( uint64_t val );
 #define panic(fmt, ...)     _panic("\n[PANIC] %s(): " fmt "\n", __func__, ##__VA_ARGS__)

trunk/kernel/kern/process.c

-                      r407
+                      r408
+}
+/////////////////////////////////////////////
+void process_zero_init( process_t * process )
+{
+    // initialize PID, PPID anf PREF
+    process->pid    = 0;
+    process->ppid   = 0;
+    process->ref_xp = XPTR( local_cxy , process );
+    // reset th_tbl[] array as empty
+    uint32_t i;
+    for( i = 0 ; i < CONFIG_THREAD_MAX_PER_CLUSTER ; i++ )
+        {
+        process->th_tbl[i] = NULL;
+    }
+    process->th_nr  = 0;
+    spinlock_init( &process->th_lock );
+        hal_fence();
+process_dmsg("\n[DBG] %s : core[%x,%d] exit for process %x\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , process->pid );
+}  // end process_zero_init()
 /////////////////////////////////////////////////
 void process_reference_init( process_t * process,
                              pid_t       pid,
+                             xptr_t      parent_xp )
+{
+    cxy_t       parent_cxy;
+    process_t * parent_ptr;
+    pid_t       parent_pid;
+                             pid_t       ppid,
+                             xptr_t      model_xp )
+{
+    cxy_t       model_cxy;
+    process_t * model_ptr;
         error_t     error1;
         error_t     error2;
 …
 __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , pid );
+    // get parent process cluster, local pointer, and pid
+    // for all processes other than kernel process
+    if( process == &process_zero )                   // kernel process
+    {
+        assert( (pid == 0) , __FUNCTION__ , "process_zero must have PID = 0\n");
+        parent_cxy = 0;
+        parent_ptr = NULL;
+        parent_pid = 0;
+    }
+    else                                             // user process
+    {
+        parent_cxy = GET_CXY( parent_xp );
+        parent_ptr = (process_t *)GET_PTR( parent_xp );
+        parent_pid = hal_remote_lw( XPTR( parent_cxy , &parent_ptr->pid ) );
+    }
+    // get model process cluster and local pointer
+    model_cxy = GET_CXY( model_xp );
+    model_ptr = (process_t *)GET_PTR( model_xp );
     // initialize PID, PPID, and REF
         process->pid    = pid;
     process->ppid   = parent_pid;
+    process->ppid   = ppid;
     process->ref_xp = XPTR( local_cxy , process );
+    // initialize vmm, fd array and others structures for user processes.
+    // These structures are not used by the kernel process.
+    if( pid )
+    {
+        // initialize vmm (not for kernel)
+        vmm_init( process );
+process_dmsg("\n[DBG] %s : core[%x,%d] / vmm initialised for process %x\n",
+    // initialize vmm
+    vmm_init( process );
+process_dmsg("\n[DBG] %s : core[%x,%d] / vmm empty for process %x\n",
 __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , pid );
+        // initialize fd_array (not for kernel)
+        process_fd_init( process );
+        // create stdin / stdout / stderr pseudo-files (not for kernel)
+        if( parent_pid == 0 )                                              // process_init
+        {
+            error1 = vfs_open( process,
+                               CONFIG_INIT_STDIN,
+                               O_RDONLY,
+,                // FIXME chmod
+                               &stdin_xp,
+                               &stdin_id );
+            error2 = vfs_open( process,
+                               CONFIG_INIT_STDOUT,
+                               O_WRONLY,
+,                // FIXME chmod
+                               &stdout_xp,
+                               &stdout_id );
+            error3 = vfs_open( process,
+                               CONFIG_INIT_STDERR,
+                               O_WRONLY,
+,                // FIXME chmod
+                               &stderr_xp,
+                               &stderr_id );
+        }
+        else                                                               // user process
+        {
+            error1 = vfs_open( process,
+                               CONFIG_USER_STDIN,
+                               O_RDONLY,
+,                // FIXME chmod
+                               &stdin_xp,
+                               &stdin_id );
+            error2 = vfs_open( process,
+                               CONFIG_USER_STDOUT,
+                               O_WRONLY,
+,                // FIXME chmod
+                               &stdout_xp,
+                               &stdout_id );
+            error3 = vfs_open( process,
+                               CONFIG_USER_STDERR,
+                               O_WRONLY,
+,                // FIXME chmod
+                               &stderr_xp,
+                               &stderr_id );
+        }
+        assert( ((error1 == 0) && (error2 == 0) && (error3 == 0)) , __FUNCTION__ ,
+        "cannot open stdin/stdout/stderr pseudo files\n");
+        assert( ((stdin_id == 0) && (stdout_id == 1) && (stderr_id == 2)) , __FUNCTION__ ,
+        "bad indexes : stdin %d / stdout %d / stderr %d \n", stdin_id , stdout_id , stderr_id );
+    // initialize fd_array (not for kernel)
+    process_fd_init( process );
+    // create stdin / stdout / stderr pseudo-files
+    if( ppid == 0 )                                        // process_init
+    {
+        error1 = vfs_open( process,
+                           CONFIG_INIT_STDIN,
+                           O_RDONLY,
+,                // FIXME chmod
+                           &stdin_xp,
+                           &stdin_id );
+        error2 = vfs_open( process,
+                           CONFIG_INIT_STDOUT,
+                           O_WRONLY,
+,                // FIXME chmod
+                           &stdout_xp,
+                           &stdout_id );
+        error3 = vfs_open( process,
+                           CONFIG_INIT_STDERR,
+                           O_WRONLY,
+,                // FIXME chmod
+                           &stderr_xp,
+                           &stderr_id );
+    }
+    else                                                  // other user process
+    {
+        error1 = vfs_open( process,
+                           CONFIG_USER_STDIN,
+                           O_RDONLY,
+,                // FIXME chmod
+                           &stdin_xp,
+                           &stdin_id );
+        error2 = vfs_open( process,
+                           CONFIG_USER_STDOUT,
+                           O_WRONLY,
+,                // FIXME chmod
+                           &stdout_xp,
+                           &stdout_id );
+        error3 = vfs_open( process,
+                           CONFIG_USER_STDERR,
+                           O_WRONLY,
+,                // FIXME chmod
+                           &stderr_xp,
+                           &stderr_id );
+    }
+    assert( ((error1 == 0) && (error2 == 0) && (error3 == 0)) , __FUNCTION__ ,
+    "cannot open stdin/stdout/stderr pseudo files\n");
+    assert( ((stdin_id == 0) && (stdout_id == 1) && (stderr_id == 2)) , __FUNCTION__ ,
+    "bad indexes : stdin %d / stdout %d / stderr %d \n", stdin_id , stdout_id , stderr_id );
+    // initialize specific files, cwd_lock, and fd_array
+    process->vfs_root_xp = (xptr_t)hal_remote_lwd( XPTR( model_cxy,
+                                                         &model_ptr->vfs_root_xp ) );
+    process->vfs_cwd_xp  = (xptr_t)hal_remote_lwd( XPTR( model_cxy,
+                                                         &model_ptr->vfs_cwd_xp ) );
+    process->vfs_bin_xp  = (xptr_t)hal_remote_lwd( XPTR( model_cxy,
+                                                         &model_ptr->vfs_bin_xp ) );
+    vfs_file_count_up( process->vfs_root_xp );
+    vfs_file_count_up( process->vfs_cwd_xp );
+    vfs_file_count_up( process->vfs_bin_xp );
+    process_fd_remote_copy( XPTR( local_cxy , &process->fd_array ),
+                            XPTR( model_cxy , &model_ptr->fd_array ) );
+    remote_rwlock_init( XPTR( local_cxy , &process->cwd_lock ) );
 process_dmsg("\n[DBG] %s : core[%x,%d] / fd array initialised for process %x\n",
 __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , pid );
+        // reset reference process files structures and cwd_lock (not for kernel)
+            process->vfs_root_xp     = XPTR_NULL;
+            process->vfs_bin_xp      = XPTR_NULL;
+            process->vfs_cwd_xp      = XPTR_NULL;
+        remote_rwlock_init( XPTR( local_cxy , &process->cwd_lock ) );
+        // reset children list root (not for kernel)
+        xlist_root_init( XPTR( local_cxy , &process->children_root ) );
+            process->children_nr     = 0;
+        // reset semaphore / mutex / barrier / condvar list roots (nor for kernel)
+        xlist_root_init( XPTR( local_cxy , &process->sem_root ) );
+        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 (nor for kernel)
+        xptr_t entry = XPTR( local_cxy  , &process->brothers_list );
+        xptr_t root  = XPTR( parent_cxy , &parent_ptr->children_root );
+        xlist_add_first( root , entry );
+    }
+    // reset th_tbl[] array as empty
+    // reset children list root
+    xlist_root_init( XPTR( local_cxy , &process->children_root ) );
+    process->children_nr     = 0;
+    // reset semaphore / mutex / barrier / condvar list roots
+    xlist_root_init( XPTR( local_cxy , &process->sem_root ) );
+    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 local cluster manager pref_tbl[]
+    lpid_t lpid = LPID_FROM_PID( pid );
+    LOCAL_CLUSTER->pmgr.pref_tbl[lpid] = XPTR( local_cxy , process );
+    // register new process descriptor in local cluster manager local_list
+    cluster_process_local_link( process );
+    // register new process descriptor in local cluster manager copies_list
+    cluster_process_copies_link( process );
+    // reset th_tbl[] array as empty in process descriptor
     uint32_t i;
     for( i = 0 ; i < CONFIG_THREAD_MAX_PER_CLUSTER ; i++ )
 …
     process->th_nr  = 0;
     spinlock_init( &process->th_lock );
-    // register new process descriptor in local cluster manager local_list
-    cluster_process_local_link( process );
-    // register new process descriptor in owner cluster manager copies_list
-    cluster_process_copies_link( process );
-    // initialize signal manager TODO [AG]
         hal_fence();
 …
     uint32_t       count;     // thread counter
 printk("\n@@@ %s enter\n", __FUNCTION__ );
+printk("\n[@@@] %s enter\n", __FUNCTION__ );
     // get lock protecting th_tbl[]
 …
+    }
 printk("\n@@@ %s : %d signal(s) sent\n", __FUNCTION__, count );
+printk("\n[@@@] %s : %d signal(s) sent\n", __FUNCTION__, count );
     // second loop on threads to wait acknowledge from scheduler,
 …
+        {
 printk("\n@@@ %s start polling at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
+printk("\n[@@@] %s start polling at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
             // poll the THREAD_SIG_KILL bit until reset
             while( thread->signals & THREAD_SIG_KILL ) asm volatile( "nop" );
 printk("\n@@@ %s exit polling\n", __FUNCTION__ );
+printk("\n[@@@] %s exit polling\n", __FUNCTION__ );
             // detach target thread from parent if attached
 …
+    }
 printk("\n@@@ %s : %d ack(s) received\n", __FUNCTION__, count );
+printk("\n[@@@] %s : %d ack(s) received\n", __FUNCTION__, count );
     // release lock protecting th_tbl[]
 …
     process_destroy( process );
 printk("\n[@@@] %s : core[%x,%d] exit\n",
+printk("\n[DBG] %s : core[%x,%d] exit\n",
 __FUNCTION__, local_cxy, CURRENT_THREAD->core->lid );
 …
 }  // process_remove_thread()
+/////////////////////////////////////////////////////////
+error_t process_make_fork( xptr_t      parent_process_xp,
+                           xptr_t      parent_thread_xp,
+                           pid_t     * child_pid,
+                           thread_t ** child_thread )
+{
+    process_t * process;         // local pointer on child process descriptor
+    thread_t  * thread;          // local pointer on child thread descriptor
+    pid_t       new_pid;         // process identifier for child process
+    pid_t       parent_pid;      // process identifier for parent process
+    xptr_t      ref_xp;          // extended pointer on reference process
+    error_t     error;
+    // get cluster and local pointer for parent process
+    cxy_t       parent_process_cxy = GET_CXY( parent_process_xp );
+    process_t * parent_process_ptr = (process_t *)GET_PTR( parent_process_xp );
+    // get parent process PID
+    parent_pid = hal_remote_lw( XPTR( parent_process_cxy , &parent_process_ptr->pid ) );
+    // check parent process is the reference
+    ref_xp = hal_remote_lwd( XPTR( parent_process_cxy , &parent_process_ptr->ref_xp ) );
+    assert( (parent_process_xp == ref_xp ) , __FUNCTION__ ,
+    "parent process must be the reference process\n" );
+process_dmsg("\n[DBG] %s : core[%x,%d] enter at cycle %d\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid , hal_get_cycles() );
+    // allocate a process descriptor
+    process = process_alloc();
+    if( process == NULL )
+    {
+        printk("\n[ERROR] in %s : cannot get process in cluster %x\n",
+        __FUNCTION__, local_cxy );
+        return -1;
+    }
+process_dmsg("\n[DBG] %s : core[%x,%d] child process descriptor allocated at cycle %d\n",
+ __FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, hal_get_cycles() );
+    // allocate a child PID from local cluster
+    error = cluster_pid_alloc( XPTR( local_cxy , process ) , &new_pid );
+    if( (error != 0) || (new_pid == 0) )
+    {
+        printk("\n[ERROR] in %s : cannot get PID in cluster %x\n",
+        __FUNCTION__, local_cxy );
+        process_free( process );
+        return -1;
+    }
+process_dmsg("\n[DBG] %s : core[%x, %d] child process PID allocated = %x at cycle %d\n",
+ __FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, new_pid , hal_get_cycles() );
+    // initializes child process descriptor from parent process descriptor
+    process_reference_init( process,
+                            new_pid,
+                            parent_pid,
+                            parent_process_xp );
+process_dmsg("\n[DBG] %s : core[%x, %d] child process initialised at cycle %d\n",
+__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, hal_get_cycles() );
+    // copy VMM from parent descriptor to child descriptor
+    error = vmm_fork_copy( process,
+                           parent_process_xp );
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot copy VMM in cluster %x\n",
+        __FUNCTION__, local_cxy );
+        process_free( process );
+        cluster_pid_release( new_pid );
+        return -1;
+    }
+process_dmsg("\n[DBG] %s : core[%x, %d] child process VMM copied at cycle %d\n",
+__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, hal_get_cycles() );
+    // create child thread descriptor from parent thread descriptor
+    error = thread_user_fork( parent_thread_xp,
+                              process,
+                              &thread );
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot create thread in cluster %x\n",
+        __FUNCTION__, local_cxy );
+        process_free( process );
+        cluster_pid_release( new_pid );
+        return -1;
+    }
+process_dmsg("\n[DBG] %s : core[%x,%d] child thread created at cycle %d\n",
+__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, hal_get_cycles() );
+    // update parent process GPT to set Copy_On_Write for shared data vsegs
+    // this includes all replicated GPT copies
+    if( parent_process_cxy == local_cxy )   // reference is local
+    {
+        vmm_set_cow( parent_process_ptr );
+    }
+    else                                    // reference is remote
+    {
+        rpc_vmm_set_cow_client( parent_process_cxy,
+                                parent_process_ptr );
+    }
+process_dmsg("\n[DBG] %s : core[%x,%d] COW set in parent_process at cycle %d\n",
+__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, hal_get_cycles() );
+    // update children list in parent process
+        xlist_add_last( XPTR( parent_process_cxy , &parent_process_ptr->children_root ),
+                    XPTR( local_cxy , &process->brothers_list ) );
+        hal_remote_atomic_add( XPTR( parent_process_cxy,
+                                 &parent_process_ptr->children_nr), 1 );
+// vmm_display( process , true );
+// vmm_display( parent_process_ptr , true );
+// sched_display( 0 );
+    // return success
+    *child_thread = thread;
+    *child_pid    = new_pid;
+    return 0;
+}  // end process_make_fork()
 /////////////////////////////////////////////////////
 error_t process_make_exec( exec_info_t  * exec_info )
+{
+    char           * path;                            // pathname to .elf file
+    bool_t           keep_pid;                        // new process keep parent PID if true
+    process_t      * process;                         // local pointer on new process
+    pid_t            pid;                             // new process pid
+    xptr_t           parent_xp;                       // extended pointer on parent process
+    cxy_t            parent_cxy;                      // parent process local cluster
+    process_t      * parent_ptr;                      // local pointer on parent process
+    uint32_t         parent_pid;                      // parent process identifier
+    thread_t       * thread;                          // pointer on new thread
+    pthread_attr_t   attr;                            // main thread attributes
+    core_t         * core;                            // pointer on selected core
+    lid_t            lid;                             // selected core local index
+    char           * path;                    // pathname to .elf file
+    process_t      * old;                     // local pointer on old process
+    process_t      * new;                     // local pointer on new process
+    pid_t            pid;                     // old process identifier
+    thread_t       * thread;                  // pointer on new thread
+    pthread_attr_t   attr;                    // main thread attributes
+    lid_t            lid;                     // selected core local index
         error_t          error;
+        // get .elf pathname, parent_xp, and keep_pid flag from exec_info
+        path      = exec_info->path;
+    parent_xp = exec_info->parent_xp;
+    keep_pid  = exec_info->keep_pid;
+process_dmsg("\n[DBG] %s : core[%x,%d] enters for path = %s\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, path );
+    // get parent process cluster and local pointer
+    parent_cxy = GET_CXY( parent_xp );
+    parent_ptr = (process_t *)GET_PTR( parent_xp );
+    parent_pid = hal_remote_lw( XPTR( parent_cxy , &parent_ptr->pid ) );
+    // allocates memory for process descriptor
+        process = process_alloc();
+        if( process == NULL ) return -1;
+    // get PID
+    if( keep_pid )    // keep parent PID
+    {
+        pid = parent_pid;
+    }
+    else              // get new PID from local cluster
+    {
+        error = cluster_pid_alloc( XPTR( local_cxy , process ) , &pid );
+        if( error ) return -1;
+    }
+process_dmsg("\n[DBG] %s : core[%x,%d] created process %x for path = %s\n",
+        // get .elf pathname and PID from exec_info
+        path = exec_info->path;
+    pid  = exec_info->pid;
+    // check local cluster is old process owner
+    assert( (CXY_FROM_PID( pid ) == local_cxy), __FUNCTION__,
+    "local cluster %x is not owner for process %x\n", local_cxy, pid );
+exec_dmsg("\n[DBG] %s : core[%x,%d] enters for process %x / path = %s\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, pid , path );
+    // get old process local pointer
+    old = (process_t *)cluster_get_local_process_from_pid( pid );
+    assert( (old != NULL ) , __FUNCTION__ ,
+    "process %x not found in cluster %x\n", pid , local_cxy );
+    // allocate memory for new process descriptor
+    new = process_alloc();
+    // initialize new process descriptor
+    process_reference_init( new,
+                            old->pid,                   // same as old
+                            old->ppid,                  // same as old
+                            XPTR( local_cxy , old ) );
+exec_dmsg("\n[DBG] %s : core[%x,%d] created new process %x / path = %s\n",
 __FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, pid, path );
+    // initialize the process descriptor as the reference
+    process_reference_init( process , pid , parent_xp );
+process_dmsg("\n[DBG] %s : core[%x,%d] initialized process %x / path = %s\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, pid, path );
+    // initialize vfs_root and vfs_cwd from parent process
+    xptr_t  vfs_root_xp = hal_remote_lwd( XPTR( parent_cxy , &parent_ptr->vfs_root_xp ) );
+        vfs_file_count_up( vfs_root_xp );
+        process->vfs_root_xp = vfs_root_xp;
+    xptr_t  vfs_cwd_xp = hal_remote_lwd( XPTR( parent_cxy , &parent_ptr->vfs_cwd_xp ) );
+        vfs_file_count_up( vfs_cwd_xp );
+        process->vfs_cwd_xp = vfs_cwd_xp;
+    // initialize embedded fd_array from parent process
+    process_fd_remote_copy( XPTR( local_cxy  , &process->fd_array ),
+                            XPTR( parent_cxy , &parent_ptr->fd_array) );
+process_dmsg("\n[DBG] %s :  core[%x,%d] copied fd_array for process %x\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, pid );
+    // register "code" and "data" vsegs as well as the process entry-point in VMM,
+    // using information contained in the elf file.
+        error = elf_load_process( path , process );
+        if( error )
+    // register "code" and "data" vsegs as well as entry-point
+    // in new process VMM, using information contained in the elf file.
+        if( elf_load_process( path , new ) )
+        {
                 printk("\n[ERROR] in %s : failed to access .elf file for process %x / path = %s\n",
                        __FUNCTION__, pid , path );
         process_destroy( process );
         return error;
+                __FUNCTION__, pid , path );
+        process_destroy( new );
+        return -1;
+        }
 process_dmsg("\n[DBG] %s : core[%x,%d] registered code/data vsegs for process %x / path = %s\n",
+exec_dmsg("\n[DBG] %s : core[%x,%d] registered code/data vsegs / process %x / path = %s\n",
 __FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, pid, path );
     // select a core in cluster
+    // select a core in local cluster to execute the main thread
     lid  = cluster_select_local_core();
-    core = &LOCAL_CLUSTER->core_tbl[lid];
     // initialize pthread attributes for main thread
 …
     // create and initialize thread descriptor
         error = thread_user_create( pid,
                                 (void *)process->vmm.entry_point,
+                                (void *)new->vmm.entry_point,
                                 exec_info->args_pointers,
                                 &attr,
 …
                 printk("\n[ERROR] in %s : cannot create thread for process %x / path = %s\n",
                        __FUNCTION__, pid , path );
         process_destroy( process );
         return error;
+        process_destroy( new );
+        return -1;
+        }
+process_dmsg("\n[DBG] %s : core[%x,%d] created thread %x for process %x / path = %s\n",
+__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, thread->trdid, pid, path  );
+    // update children list in parent process
+        xlist_add_last( XPTR( parent_cxy , &parent_ptr->children_root ),
+                    XPTR( local_cxy  , &process->brothers_list ) );
+        hal_remote_atomic_add( XPTR( parent_cxy , &parent_ptr->children_nr) , 1 );
+exec_dmsg("\n[DBG] %s : core[%x,%d] created main thread %x for new process %x\n",
+__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, thread->trdid, pid );
+    // update children list (rooted in parent process)
+        xlist_replace( XPTR( local_cxy , &old->brothers_list ) ,
+                   XPTR( local_cxy , &new->brothers_list ) );
+    // FIXME request destruction of old process copies and threads in all clusters
     // activate new thread
         thread_unblock( XPTR( local_cxy , thread ) , THREAD_BLOCKED_GLOBAL );
 process_dmsg("\n[DBG] %s : core[%x,%d] exit for path = %s\n",
+exec_dmsg("\n[DBG] %s : core[%x,%d] exit for path = %s\n",
 __FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, path  );
 …
+{
     exec_info_t   exec_info;     // structure to be passed to process_make_exec()
+    xptr_t        parent_xp;     // extended pointer on parent process.
+    process_t   * process;       // local pointer on process_init descriptor
+    pid_t         pid;           // process_init identifier
     error_t       error;
 …
 __FUNCTION__ , local_cxy );
+    // parent process is local kernel process
+    parent_xp = XPTR( local_cxy , &process_zero );
+    // allocates memory for process descriptor from local cluster
+        process = process_alloc();
+        if( process == NULL )
+    {
+                printk("\n[PANIC] in %s : no memory for process descriptor in cluster %x\n",
+                __FUNCTION__, local_cxy );
+    }
+    // get new PID from local cluster
+    error = cluster_pid_alloc( XPTR( local_cxy , process ) , &pid );
+    if( error )
+    {
+                printk("\n[PANIC] in %s : cannot allocate PID in cluster %x\n",
+                __FUNCTION__, local_cxy );
+    }
+    // initialise the process desciptor (parent is local kernel process)
+    process_reference_init( process,
+                            pid,
+                            process_zero.pid,
+                            XPTR( local_cxy , &process_zero ) );
     // initialize the exec_info structure
+    exec_info.keep_pid     = false;
+    exec_info.parent_xp    = parent_xp;
+    strcpy( exec_info.path , CONFIG_PROCESS_INIT_PATH );
+    exec_info.pid          = pid;
     exec_info.args_nr      = 0;
     exec_info.envs_nr      = 0;
+    // initialize process_init and create thread_init
+    strcpy( exec_info.path , CONFIG_PROCESS_INIT_PATH );
+    // update process descriptor and create thread descriptor
         error = process_make_exec( &exec_info );
+        if( error ) panic("cannot initialize process_init in cluster %x", local_cxy );
+        if( error )
+    {
+                printk("\n[PANIC] in %s : cannot exec %s in cluster %x\n",
+                __FUNCTION__, CONFIG_PROCESS_INIT_PATH , local_cxy );
+    }
 process_dmsg("\n[DBG] %s : exit in cluster %x\n",

trunk/kernel/kern/process.h

-                      r407
+                      r408
 /*********************************************************************************************
  * This structure defines the information required by the process_make_exec() function
+ * to create a new reference process descriptor, and the associated main thread.
+ * to create a new reference process descriptor, and the associated main thread,
+ * in the parent process owner cluster.
  ********************************************************************************************/
 typedef struct exec_info_s
+{
+    xptr_t             parent_xp;      /*! extended pointer on parent process descriptor    */
+    bool_t             keep_pid;       /*! keep parent PID if true / new PID if false       */
+    pid_t              pid;            /*! process identifier (both parent and child)       */
     char               path[CONFIG_VFS_MAX_PATH_LENGTH];   /*!  .elf file path              */
 …
 /*********************************************************************************************
+ * This function initializes a new process descriptor, in the reference cluster.
+ * 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 / ref_xp fields.
+ * It registers this process descriptor in three lists:
+ * - the children_list in the parent reference process descriptor.
+ * - the local_list, rooted in the reference cluster manager.
+ * - the copies_list, rooted in the owner cluster manager.
+ * It resets the embedded structures such as the VMM or the file descriptor array.
+ *********************************************************************************************
+ * @ process      : [in] pointer on process descriptor to initialize.
+ * @ pid          : [in] process identifier defined by owner cluster.
+ * @ parent_xp    : [in] extended pointer on parent process.
+ * This function initialize, in each cluster, the kernel "process_zero", that is the owner
+ * of all kernel threads in a given cluster. It is called by the kernel_init() function.
+ * Both the PID and PPID fields are set to zero, and the ref_xp is the local process_zero.
+ * The th_tbl[] is initialized as empty.
+ *********************************************************************************************
+ * @ process      : [in] pointer on local process descriptor to initialize.
+ ********************************************************************************************/
+void process_zero_init( process_t * process );
+/*********************************************************************************************
+ * This function initializes a local, reference user process descriptor from another process
+ * descriptor, defined by the <model_xp> argument. The <process> descriptor, the <pid>, and
+ * the <ppid> arguments must be previously defined by the caller.
+ * It can be called by three functions, depending on the process type:
+ * 1) if "process" is the user "process_init", the parent is the kernel process. It is
+ *    called once, by the process_init_create() function in cluster[xmax-1][ymax-1].
+ * 2) if the caller is the process_make_fork() function, the model is generally a remote
+ *    process, that is also the parent process.
+ * 3) if the caller is the process_make_exec() function, the model is always a local process,
+ *    but the parent is the parent of the model process.
+ *
+ * The following fields are initialised (for all process but process_zero).
+ * - It set the pid / ppid / ref_xp fields.
+ * - It initializes an empty VMM (no vsegs registered in VSL and GPT).
+ * - It initializes the FDT, defining the three pseudo files STDIN / STDOUT / STDERR.
+ * - It set the root_xp, bin_xp, cwd_xp fields.
+ * - It reset the children list as empty, but does NOT register it in parent children list.
+ * - It reset the TH_TBL list of threads as empty.
+ * - It reset the semaphore / mutex / barrier / condvar lists as empty.
+ * - It registers the process in the local_list, rooted in the local cluster manager.
+ * - It registers the process in the copies_list, rooted in the owner cluster manager.
+ * - It registers the process extended pointer in the local pref_tbl[] array.
+ *********************************************************************************************
+ * @ process      : [in] pointer on local process descriptor to initialize.
+ * @ pid          : [in] process identifier.
+ * @ ppid         : [in] parent process identifier.
+ * @ model_xp     : [in] extended pointer on model process descriptor (local or remote).
  ********************************************************************************************/
 void process_reference_init( process_t * process,
                              pid_t       pid,
+                             xptr_t      parent_xp );
+                             pid_t       ppid,
+                             xptr_t      model_xp );
 /*********************************************************************************************
 …
 /*********************************************************************************************
+ * This function allocates memory and initializes a new user process descriptor,
+ * and the associated main thread, from information found in the <exec_info> structure
+ * (defined in the process.h file), that must be built by the caller.
+ * - If the <keep_pid> field is true, the new process inherits its PID from the parent PID.
+ * - If the <keep_pid> field is false, a new PID is allocated from the local cluster manager.
+ * The new process inherits from the parent process (i) the open file descriptors, (ii) the
+ * vfs_root and the vfs_cwd inodes.
+ * It accesses the .elf file to get the size of the code and data segments, and initializes
+ * the vsegs list in the VMM.
+ * It is executed in the local cluster, that becomes both "owner" and "reference".
+ * - It can be called by the process_init_create() function to build the "init" process.
+ * - It can be called directly by the sys_exec() function in case of local exec.
+ * - It can be called through the rpc_process_exec_server() function in case of remote exec.
+ * This function implements the exec() system call, and is called by the sys_exec() function.
+ * It is also called by the process_init_create() function to build the "init" process.
+ * The "new" process keep the "old" process PID and PPID, all open files, and env variables,
+ * the vfs_root and vfs_cwd, but build a brand new memory image (new VMM from the new .elf).
+ * It actually creates a "new" reference process descriptor, saves all relevant information
+ * from the "old" reference process descriptor to the "new" process descriptor.
+ * It completes the "new" process descriptor, from information found in the <exec_info>
+ * structure (defined in the process.h file), that must be built by the caller.
+ * It creates and initializes the associated main thread. It finally destroys all copies
+ * of the "old" process in all clusters, and all the old associated threads.
+ * It is executed in the local cluster, that becomes both the "owner" and the "reference"
+ * cluster for the "new" process.
  *********************************************************************************************
  * @ exec_info   : [in]  pointer on the exec_info structure.
 …
 error_t process_make_exec( exec_info_t * exec_info );
+/*********************************************************************************************
+ * This function implement the fork() system call, and is called by the sys_fork() function.
+ * It allocates memory and initializes a new "child" process descriptor, and the
+ * associated "child" thread descriptor in the local cluster. This function can involve
+ * up to three different clusters :
+ * - the local (child) cluster can be any cluster defined by the sys_fork function.
+ * - the parent cluster must be the reference clusterfor the parent process.
+ * - the client cluster containing the thread requestingthe fork can be any cluster.
+ * The new "child" process descriptor is initialised from informations found in the "parent"
+ * reference process descriptor, containing the complete process description.
+ * The new "child" thread descriptor is initialised from informations found in the "parent"
+ * thread descriptor.
+ *********************************************************************************************
+ * @ parent_process_xp  : extended pointer on the reference parent process.
+ * @ parent_thread_xp   : extended pointer on the parent thread requesting the fork.
+ * @ child_pid          : [out] child process identifier.
+ * @ child_thread_ptr   : [out] local pointer on child thread in target cluster.
+ * @ return 0 if success / return non-zero if error.
+ ********************************************************************************************/
+error_t process_make_fork(  xptr_t             parent_process_xp,
+                            xptr_t             parent_thread_xp,
+                            pid_t            * child_pid,
+                            struct thread_s ** child_thread_ptr );
 /********************   File Management Operations   ****************************************/

trunk/kernel/kern/rpc.c

-                      r407
+                      r408
+{
     &rpc_pmem_get_pages_server,         // 0
     &rpc_process_pid_alloc_server,      // 1
     &rpc_process_exec_server,           // 2
+    &rpc_process_make_exec_server,      // 1
+    &rpc_process_make_fork_server,      // 2
     &rpc_process_kill_server,           // 3
     &rpc_thread_user_create_server,     // 4
 …
     &rpc_vmm_create_vseg_server,        // 26
     &rpc_sched_display_server,          // 27
     &rpc_undefined,                     // 28
+    &rpc_vmm_set_cow_server,            // 28
     &rpc_undefined,                     // 29
 };
 …
 /////////////////////////////////////////////////////////////////////////////////////////
+// [1]           Marshaling functions attached to RPC_PROCESS_PID_ALLOC
+/////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////
+void rpc_process_pid_alloc_client( cxy_t       cxy,
+                                   process_t * process,  // in
+                                   error_t   * error,    // out
+                                   pid_t     * pid )     // out
+{
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
+    CURRENT_THREAD->core->lid , hal_time_stamp() );
+    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
+    // initialise RPC descriptor header
+    rpc_desc_t  rpc;
+    rpc.index    = RPC_PROCESS_PID_ALLOC;
+    rpc.response = 1;
+    // set input arguments in RPC descriptor
+    rpc.args[0] = (uint64_t)(intptr_t)process;
+    // register RPC request in remote RPC fifo (blocking function)
+    rpc_send_sync( cxy , &rpc );
+    // get output arguments RPC descriptor
+    *pid    = (pid_t)rpc.args[1];
+    *error  = (error_t)rpc.args[2];
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
+    CURRENT_THREAD->core->lid , hal_time_stamp() );
+}
+//////////////////////////////////////////////
+void rpc_process_pid_alloc_server( xptr_t xp )
+{
+    process_t * process;   // input  : client process descriptor
+    error_t     error;     // output : error status
+    pid_t       pid;       // output : process identifier
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
+    CURRENT_THREAD->core->lid , hal_time_stamp() );
+    // 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 argument from client RPC descriptor
+    process = (process_t*)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
+    // call local pid allocator
+    xptr_t xp_process = XPTR( client_cxy , process );
+    error = cluster_pid_alloc( xp_process , &pid );
+    // set output arguments into client RPC descriptor
+    hal_remote_sw( XPTR( client_cxy , &desc->args[0] ) , (uint64_t)error );
+    hal_remote_sw( XPTR( client_cxy , &desc->args[1] ) , (uint64_t)pid );
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
+    CURRENT_THREAD->core->lid , hal_time_stamp() );
+}
+/////////////////////////////////////////////////////////////////////////////////////////
+// [2]           Marshaling functions attached to RPC_PROCESS_EXEC
+/////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////
+void rpc_process_exec_client( cxy_t         cxy,
+                              exec_info_t * info,     // in
+                              error_t     * error )   // out
+{
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
+    CURRENT_THREAD->core->lid , hal_time_stamp() );
+    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
+    // initialise RPC descriptor header
+    rpc_desc_t  rpc;
+    rpc.index    = RPC_PROCESS_EXEC;
+// [1]           Marshaling functions attached to RPC_PROCESS_MAKE_EXEC
+/////////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////
+void rpc_process_make_exec_client( cxy_t         cxy,
+                                   exec_info_t * info,     // in
+                                   error_t     * error )   // out
+{
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
+    CURRENT_THREAD->core->lid , hal_time_stamp() );
+    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
+    // initialise RPC descriptor header
+    rpc_desc_t  rpc;
+    rpc.index    = RPC_PROCESS_MAKE_EXEC;
     rpc.response = 1;
 …
+}
 /////////////////////////////////////////
 void rpc_process_exec_server( xptr_t xp )
+//////////////////////////////////////////////
+void rpc_process_make_exec_server( xptr_t xp )
+{
     exec_info_t * ptr;       // local pointer on remote exec_info structure
 …
+}
+/////////////////////////////////////////////////////////////////////////////////////////
+// [2]           Marshaling functions attached to RPC_PROCESS_MAKE_FORK
+/////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////
+void rpc_process_make_fork_client( cxy_t       cxy,
+                                   xptr_t      ref_process_xp,      // in
+                                   xptr_t      parent_thread_xp,    // in
+                                   pid_t     * child_pid,           // out
+                                   thread_t ** child_thread_ptr,    // out
+                                   error_t   * error )              // out
+{
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
+    CURRENT_THREAD->core->lid , hal_time_stamp() );
+    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
+    // initialise RPC descriptor header
+    rpc_desc_t  rpc;
+    rpc.index    = RPC_PROCESS_MAKE_FORK;
+    rpc.response = 1;
+    // set input arguments in RPC descriptor
+    rpc.args[0] = (uint64_t)(intptr_t)ref_process_xp;
+    rpc.args[1] = (uint64_t)(intptr_t)parent_thread_xp;
+    // register RPC request in remote RPC fifo (blocking function)
+    rpc_send_sync( cxy , &rpc );
+    // get output arguments from RPC descriptor
+    *child_pid         = (pid_t)rpc.args[2];
+    *child_thread_ptr  = (thread_t *)(intptr_t)rpc.args[3];
+    *error             = (error_t)rpc.args[4];
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
+    CURRENT_THREAD->core->lid , hal_time_stamp() );
+}
+//////////////////////////////////////////////
+void rpc_process_make_fork_server( xptr_t xp )
+{
+    xptr_t     ref_process_xp;     // extended pointer on reference parent process
+    xptr_t     parent_thread_xp;   // extended pointer on parent thread
+    pid_t      child_pid;          // child process identifier
+    thread_t * child_thread_ptr;   // local copy of exec_info structure
+    error_t    error;              // local error status
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
+    CURRENT_THREAD->core->lid , hal_time_stamp() );
+    // 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 from cient RPC descriptor
+    ref_process_xp   = (xptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
+    parent_thread_xp = (xptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
+    // call local kernel function
+    error = process_make_fork( ref_process_xp,
+                               parent_thread_xp,
+                               &child_pid,
+                               &child_thread_ptr );
+    // set output argument into client RPC descriptor
+    hal_remote_swd( XPTR( client_cxy , &desc->args[2] ) , (uint64_t)child_pid );
+    hal_remote_swd( XPTR( client_cxy , &desc->args[3] ) , (uint64_t)(intptr_t)child_thread_ptr );
+    hal_remote_swd( XPTR( client_cxy , &desc->args[4] ) , (uint64_t)error );
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
+    CURRENT_THREAD->core->lid , hal_time_stamp() );
+}
 /////////////////////////////////////////////////////////////////////////////////////////
 …
+}
+/////////////////////////////////////////////////////////////////////////////////////////
+// [28]          Marshaling functions attached to RPC_VMM_SET_COW
+/////////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////
+void rpc_vmm_set_cow_client( cxy_t       cxy,
+                             process_t * process )
+{
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
+    CURRENT_THREAD->core->lid , hal_time_stamp() );
+    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
+    // initialise RPC descriptor header
+    rpc_desc_t  rpc;
+    rpc.index    = RPC_VMM_SET_COW;
+    rpc.response = 1;
+    // set input arguments in RPC descriptor
+    rpc.args[0] = (uint64_t)(intptr_t)process;
+    // register RPC request in remote RPC fifo (blocking function)
+    rpc_send_sync( cxy , &rpc );
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
+    CURRENT_THREAD->core->lid , hal_time_stamp() );
+}
+////////////////////////////////////////
+void rpc_vmm_set_cow_server( xptr_t xp )
+{
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
+    CURRENT_THREAD->core->lid , hal_time_stamp() );
+    process_t * process;
+    // get client cluster identifier and pointer on RPC descriptor
+    cxy_t        cxy  = (cxy_t)GET_CXY( xp );
+    rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
+    // get input arguments from client RPC descriptor
+    process = (process_t *)(intptr_t)hal_remote_lpt( XPTR(cxy , &desc->args[0]));
+    // call local kernel function
+    vmm_set_cow( process );
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy,
+    CURRENT_THREAD->core->lid , hal_time_stamp() );
+}
 /***************************************************************************************/
 /************ Generic functions supporting RPCs : client side **************************/
 …
             __FUNCTION__ , local_cxy , server_cxy );
             if( thread_can_yield() ) sched_yield();
+            if( thread_can_yield() ) sched_yield("RPC fifo full");
+        }
+    }
 …
         thread_block( this , THREAD_BLOCKED_RPC );
         sched_yield();
+        sched_yield("client blocked on RPC");
 grpc_dmsg("\n[DBG] %s : core[%x,%d] / thread %s resumes after RPC completion\n",
 …
     // interrupted thread deschedule always
         sched_yield();
+        sched_yield("IPI received");
 grpc_dmsg("\n[DBG] %s : core[%x,%d] / interrupted thread %s resume / cycle %d\n",
 …
         // deschedule without blocking
         sched_yield();
+        sched_yield("RPC fifo empty or too much work");
 grpc_dmsg("\n[DBG] %s : core[%x,%d] (RPC thread %x) resumes / cycle %d\n",
 …
-/* deprecated [AG] 29/09/2017
-////////////////////////////////////////////////////
-error_t rpc_activate_thread( remote_fifo_t * rpc_fifo )
+{
-        core_t      * core;
-        thread_t    * thread;
-        thread_t    * this;
-    scheduler_t * sched;
-        error_t       error;
-    bool_t        found;
-    reg_t         sr_save;
-        this   = CURRENT_THREAD;
-    core   = this->core;
-    sched  = &core->scheduler;
-    found  = false;
-    assert( (this->trdid == rpc_fifo->owner) , __FUNCTION__ ,
-    "calling thread is not RPC_FIFO owner\n" );
-    // makes the calling thread not preemptable
-    // during activation / creation of the RPC thread
-        hal_disable_irq( &sr_save );
-grpc_dmsg("\n[DBG] %s : core[%x,%d] enter at cycle %d\n",
-__FUNCTION__ , local_cxy , core->lid , hal_time_stamp() );
-    // search one non blocked RPC thread
-    list_entry_t * iter;
-    LIST_FOREACH( &sched->k_root , iter )
+    {
-        thread = LIST_ELEMENT( iter , thread_t , sched_list );
-        if( (thread->type == THREAD_RPC) && (thread->blocked == 0 ) )
+        {
-            found = true;
-            break;
+        }
+    }
-    if( found == false )                    // create new RPC thread
+    {
-        error = thread_kernel_create( &thread,
-                                      THREAD_RPC,
-                                                  &rpc_thread_func,
-                                      NULL,
-                                                  core->lid );
-            if( error )
+        {
-                hal_restore_irq( sr_save );
-            printk("\n[ERROR] in %s : no memory for new RPC thread in cluster %x\n",
-                   __FUNCTION__ , local_cxy );
-            return ENOMEM;
+        }
-        // unblock thread
-        thread->blocked = 0;
-        // update core descriptor counter
-            hal_atomic_add( &LOCAL_CLUSTER->rpc_threads , 1 );
-grpc_dmsg("\n[DBG] %s : core [%x,%d] creates RPC thread %x at cycle %d\n",
-__FUNCTION__ , local_cxy , core->lid , thread->trdid , hal_time_stamp() );
+    }
-    else                           // create a new RPC thread
+    {
-grpc_dmsg("\n[DBG] %s : core[%x,%d] activates RPC thread %x at cycle %d\n",
-__FUNCTION__ , local_cxy , core->lid , thread->trdid , hal_time_stamp() );
+    }
-    // update rpc_fifo owner
-    rpc_fifo->owner = thread->trdid;
-    // current thread deschedule
-        sched_yield();
-    // restore IRQs for the calling thread
-        hal_restore_irq( sr_save );
-    // return success
-        return 0;
-}  // end rpc_activate_thread()
-////////////////
-void rpc_check()
+{
-        thread_t   * this     = CURRENT_THREAD;
-        remote_fifo_t * rpc_fifo = &LOCAL_CLUSTER->rpc_fifo;
-    error_t      error;
-grpc_dmsg("\n[DBG] %s : core[%x,%d] / thread %x / enter at cycle %d\n",
-__FUNCTION__ , local_cxy , this->core->lid , this->trdid , hal_time_stamp() );
-    // calling thread does nothing if light lock already taken or FIFO empty
-        if( (rpc_fifo->owner != 0) || (local_fifo_is_empty( &rpc_fifo->fifo )) )
+    {
-grpc_dmsg("\n[DBG] %s : core[%x,%d] / thread %x / exit do nothing at cycle %d\n",
-__FUNCTION__ , local_cxy , this->core->lid , this->trdid , hal_time_stamp() );
-        return;
+    }
-        // try to take the light lock, and activates an RPC thread if success
-    if( hal_atomic_test_set( &rpc_fifo->owner , this->trdid ) )
+        {
-        error = rpc_activate_thread( rpc_fifo );
-        if( error )    // cannot activate an RPC_THREAD
+        {
-            rpc_fifo->owner = 0;
-            printk("\n[ERROR] in %s : no memory to create a RPC thread for core %d"
-            " in cluster %x => do nothing\n",
-            __FUNCTION__ , CURRENT_CORE->lid , local_cxy );
+        }
-        return;
+    }
-    else  // light lock taken by another thread
+    {
-grpc_dmsg("\n[DBG] %s : core[%x,%d] / thread %x / exit do nothing at cycle %d\n",
-__FUNCTION__ , local_cxy , this->core->lid , this->trdid , hal_time_stamp() );
-        return;
+    }
-} // end rpc_check()
-//////////////////////
-void rpc_thread_func()
+{
-    // makes the RPC thread not preemptable
-        hal_disable_irq( NULL );
-        thread_t   * this     = CURRENT_THREAD;
-        remote_fifo_t * rpc_fifo = &LOCAL_CLUSTER->rpc_fifo;
-        while(1)
+        {
-        // check fifo ownership (ownership should be given by rpc_activate()
-        assert( (this->trdid == rpc_fifo->owner) , __FUNCTION__ ,
-        "thread %x on core[%x,%d] not owner of RPC_FIFO / owner = %x\n",
-        this->trdid, local_cxy, this->core->lid , rpc_fifo->owner );
-        // executes pending RPC(s)
-        rpc_execute_all( rpc_fifo );
-        // release rpc_fifo ownership if required
-        // (this ownership can be lost during RPC execution)
-        if( rpc_fifo->owner == this->trdid ) rpc_fifo->owner = 0;
-        //  deschedule or sucide
-                if( LOCAL_CLUSTER->rpc_threads >= CONFIG_RPC_THREADS_MAX )  // suicide
+                {
-grpc_dmsg("\n[DBG] %s : core[%x,%d] / thread %x / suicide at cycle %d\n",
-__FUNCTION__, local_cxy, this->core->lid, this->trdid, hal_time_stamp() );
-            // update core descriptor counter
-                hal_atomic_add( &LOCAL_CLUSTER->rpc_threads , -1 );
-            // suicide
-                        thread_exit();
+                }
-        else                                                       // deschedule
+        {
-grpc_dmsg("\n[DBG] %s : core[%x,%d] / thread %x / deschedule at cycle %d\n",
-__FUNCTION__, local_cxy, this->core->lid, this->trdid, hal_time_stamp() );
-            sched_yield();
-grpc_dmsg("\n[DBG] %s : core[%x,%d] / thread %x / wake up at cycle %d\n",
-__FUNCTION__, local_cxy, this->core->lid, this->trdid, hal_time_stamp() );
+        }
-        } // end while
-} // end rpc_thread_func()
-*/

trunk/kernel/kern/rpc.h

-                      r407
+                      r408
+{
     RPC_PMEM_GET_PAGES         = 0,
     RPC_PROCESS_PID_ALLOC      = 1,
     RPC_PROCESS_EXEC           = 2,
+    RPC_PROCESS_MAKE_EXEC      = 1,
+    RPC_PROCESS_MAKE_FORK      = 2,
     RPC_PROCESS_KILL           = 3,
     RPC_THREAD_USER_CREATE     = 4,
 …
     RPC_VMM_CREATE_VSEG        = 26,
     RPC_SCHED_DISPLAY          = 27,
+    RPC_VMM_SET_COW            = 28,
     RPC_MAX_INDEX              = 30,
+}
 …
 /***********************************************************************************
+ * [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.
+ * [1] The RPC_PROCESS_MAKE_EXEC creates a new process descriptor, from an existing
+ * process descriptor in a remote server cluster. This server cluster must be
+ * the owner cluster for the existing process. The new process descriptor is
+ * initialized from informations found in the <exec_info> structure.
+ * A new main thread descriptor is created in the server cluster.
+ * All copies of the old process descriptor and all old threads are destroyed.
  ***********************************************************************************
  * @ cxy     : server cluster identifier.
  * @ process : [in]  local pointer on process descriptor in client cluster.
+ * @ process : [in]  local pointer on the exec_info structure in client cluster.
  * @ error   : [out] error status (0 if success).
+ * @ pid     : [out] new process identifier.
+ **********************************************************************************/
+void rpc_process_pid_alloc_client( cxy_t              cxy,
+                                   struct process_s * process,
+                                   error_t          * error,
+                                   pid_t            * pid );
+void rpc_process_pid_alloc_server( xptr_t xp );
+/***********************************************************************************
+ * [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.
+ ***********************************************************************************
+ * @ cxy     : server cluster identifier.
+ * @ info    : [in]   pointer on local exec_info structure.
+ * @ error   : [out]  error status (0 if success).
+ **********************************************************************************/
+void rpc_process_exec_client( cxy_t                cxy,
+                              struct exec_info_s * info,
+                              error_t            * error );
+void rpc_process_exec_server( xptr_t xp );
+ **********************************************************************************/
+void rpc_process_make_exec_client( cxy_t                cxy,
+                                   struct exec_info_s * info,
+                                   error_t            * error );
+void rpc_process_make_exec_server( xptr_t xp );
+/***********************************************************************************
+ * [2] The RPC_PROCESS_MAKE_FORK creates a "child" process descriptor, and the
+ * associated "child" thread descriptor in a target remote cluster that can be
+ * any cluster.  The child process is initialized from informations found in the
+ * "parent" process descriptor (that must be the parent reference cluster),
+ * and from the "parent" thread descriptor that can be in any cluster.
+ ***********************************************************************************
+ * @ cxy              : server cluster identifier.
+ * @ ref_process_xp   : [in]  extended pointer on reference parent process.
+ * @ parent_thread_xp : [in]  extended pointer on parent thread.
+ * @ child_pid        : [out] child process identifier.
+ * @ child_thread_ptr : [out] local pointer on child thread.
+ * @ error            : [out]  error status (0 if success).
+ **********************************************************************************/
+void rpc_process_make_fork_client( cxy_t              cxy,
+                                   xptr_t             ref_process_xp,
+                                   xptr_t             parent_thread_xp,
+                                   pid_t            * child_pid,
+                                   struct thread_s ** child_thread_ptr,
+                                   error_t          * error );
+void rpc_process_make_fork_server( xptr_t xp );
 /***********************************************************************************
 …
 void rpc_sched_display_server( xptr_t xp );
+/***********************************************************************************
+ * [28] The RPC_VMM_SET_COW allows a client thread to request the remote reference
+ * cluster to set the COW flag and reset the WRITABLE flag of all GPT entries for
+ * the DATA, MMAP and REMOTE vsegs of process identified by the <process> argument.
+ * of a remote scheduler, identified by the <lid> argument.
+ ***********************************************************************************
+ * @ cxy         : server cluster identifier.
+ * @ process     : [in]  local pointer on reference process descriptor.
+ **********************************************************************************/
+void rpc_vmm_set_cow_client( cxy_t              cxy,
+                             struct process_s * process );
+void rpc_vmm_set_cow_server( xptr_t xp );
 #endif

trunk/kernel/kern/scheduler.c

-                      r407
+                      r408
 }  // end sched_remove()
 ////////////////////////////////////////
 thread_t * sched_select( core_t * core )
+{
     thread_t    * thread;
     scheduler_t * sched = &core->scheduler;
+//////////////////////////////////////////////
+thread_t * sched_select( scheduler_t * sched )
+{
+    thread_t     * thread;
+    list_entry_t * current;
+    list_entry_t * last;
     // take lock protecting sheduler lists
     spinlock_lock( &sched->lock );
-    list_entry_t * current;
-    list_entry_t * last;
     // first loop : scan the kernel threads list if not empty
 …
                 break;
+                default:          // DEV thread if non blocked
+                if( thread->blocked == 0 )
+                default:          // DEV thread if non blocked and waiting queue non empty
+                if( (thread->blocked == 0) &&
+                    (xlist_is_empty( XPTR( local_cxy , &thread->chdev->wait_root)) == 0) )
+                {
                     spinlock_unlock( &sched->lock );
 …
     scheduler_t  * sched = &core->scheduler;
+// signal_dmsg("\n@@@ %s enter at cycle %d\n",
+// __FUNCTION__ , hal_time_stamp() );
     // take lock protecting threads lists
     spinlock_lock( &sched->lock );
 …
+    {
         thread = LIST_ELEMENT( iter , thread_t , sched_list );
+        if( thread->signals ) sched_kill_thread( thread );
+        if( thread->signals ) // sched_kill_thread( thread );
+        {
+            printk("\n[WARNING] %s : thread %x has signal %x at cycle %d\n",
+            __FUNCTION__, thread, thread->signals, hal_time_stamp() );
+        }
+    }
 …
+    {
         thread = LIST_ELEMENT( iter , thread_t , sched_list );
+        if( thread->signals ) sched_kill_thread( thread );
+        if( thread->signals )  // sched_kill_thread( thread );
+        {
+            printk("\n[WARNING] %s : thread %x has signal %x at cycle %d\n",
+            __FUNCTION__, thread, thread->signals, hal_time_stamp() );
+        }
+    }
 …
     spinlock_unlock( &sched->lock );
+// signal_dmsg("\n@@@ %s exit at cycle %d\n",
+// __FUNCTION__ , hal_time_stamp() );
 } // end sched_handle_signals()
+//////////////////////////////////////
+void sched_update( thread_t * current,
+                   thread_t * next )
+{
+    scheduler_t * sched = &current->core->scheduler;
+    if( current->type == THREAD_USER ) sched->u_last = &current->sched_list;
+    else                               sched->k_last = &current->sched_list;
+    sched->current = next;
+}
+//////////////////
+void sched_yield()
+////////////////////////////////
+void sched_yield( char * cause )
+{
     thread_t    * next;
     thread_t    * current = CURRENT_THREAD;
+    scheduler_t * sched   = &current->core->scheduler;
 #if( CONFIG_SCHED_DEBUG & 0x1 )
 …
+    }
+    // enter critical section / save SR in current thread context
+    hal_disable_irq( &current->save_sr );
     // loop on threads to select next thread
     next = sched_select( current->core );
+    next = sched_select( sched );
     // check next thread attached to same core as the calling thread
 …
         if( next != current )
+    {
+        // current thread desactivate IRQs
+        hal_disable_irq( &switch_save_sr[CURRENT_THREAD->core->lid] );
+sched_dmsg("\n[DBG] %s : core[%x,%d] / trd %x (%s) (%x,%x) => trd %x (%s) (%x,%x) / cycle %d\n",
+__FUNCTION__, local_cxy, current->core->lid,
+sched_dmsg("\n[DBG] %s : core[%x,%d] / cause = %s\n"
+"      thread %x (%s) (%x,%x) => thread %x (%s) (%x,%x) / cycle %d\n",
+__FUNCTION__, local_cxy, current->core->lid, cause,
 current, thread_type_str(current->type), current->process->pid, current->trdid,
 next   , thread_type_str(next->type)   , next->process->pid   , next->trdid,
 hal_time_stamp() );
+(uint32_t)hal_get_cycles() );
         // update scheduler
+        sched_update( current , next );
+        sched->current = next;
+        if( next->type == THREAD_USER ) sched->u_last = &next->sched_list;
+        else                            sched->k_last = &next->sched_list;
         // handle FPU ownership
 …
         // switch CPU from calling thread context to new thread context
         hal_do_cpu_switch( current->cpu_context, next->cpu_context );
-        // restore IRQs when next thread resume
-        hal_restore_irq( switch_save_sr[CURRENT_THREAD->core->lid] );
+    }
     else
+    {
+sched_dmsg("\n[DBG] %s : core[%x,%d] / thread %x (%s) continue / cycle %d\n",
+__FUNCTION__, local_cxy, current->core->lid, current->trdid,
+thread_type_str(current->type) ,hal_time_stamp() );
+    }
+sched_dmsg("\n[DBG] %s : core[%x,%d] / cause = %s\n"
+"      thread %x (%s) (%x,%x) continue / cycle %d\n",
+__FUNCTION__, local_cxy, current->core->lid, cause,
+current, thread_type_str(current->type), current->process->pid, current->trdid,
+(uint32_t)hal_get_cycles() );
+    }
+    // exit critical section / restore SR from next thread context
+    hal_restore_irq( next->save_sr );
 }  // end sched_yield()
 …
     nolock_printk("\n***** scheduler state for core[%x,%d] at cycle %d\n"
            "kernel_threads = %d / user_threads = %d / current = %x / idle = %x\n",
+           "kernel_threads = %d / user_threads = %d / current = (%x,%x)\n",
             local_cxy , core->lid, hal_time_stamp(),
             sched->k_threads_nr, sched->u_threads_nr,
             sched->current->trdid , sched->idle->trdid );
+            sched->current->process->pid , sched->current->trdid );
     // display kernel threads
 …
+    {
         thread = LIST_ELEMENT( iter , thread_t , sched_list );
+        nolock_printk(" - type = %s / trdid = %X / pid = %X / func = %X / blocked = %X\n",
+        thread_type_str( thread->type ), thread->trdid, thread->process->pid,
+        thread->entry_func, thread->blocked );
+        if (thread->type == THREAD_DEV)
+        {
+            nolock_printk(" - %s / pid %X / trdid %X / desc %X / blocked %X / %s\n",
+            thread_type_str( thread->type ), thread->process->pid, thread->trdid,
+            thread, thread->blocked , thread->chdev->name );
+        }
+        else
+        {
+            nolock_printk(" - %s / pid %X / trdid %X / desc %X / blocked %X\n",
+            thread_type_str( thread->type ), thread->process->pid, thread->trdid,
+            thread, thread->blocked );
+        }
+    }
 …
+    {
         thread = LIST_ELEMENT( iter , thread_t , sched_list );
         nolock_printk(" - type = %s / trdid = %X / pid = %X / func = %X / blocked = %X\n",
         thread_type_str( thread->type ), thread->trdid, thread->process->pid,
         thread->entry_func, thread->blocked );
+        nolock_printk(" - %s / pid %X / trdid %X / desc %X / blocked %X\n",
+        thread_type_str( thread->type ), thread->process->pid, thread->trdid,
+        thread, thread->blocked );
+    }

trunk/kernel/kern/scheduler.h

-                      r407
+                      r408
 /*********************************************************************************************
+ * This function handles pending signals for all registered threads, and calls the
+ * sched_select() function to make a context switch for the core running the calling thread.
+ * This function is the only method to make a context switch. It is called in cas of TICK,
+ * or when when a thread explicitely requires a scheduling.
+ * It handles the pending signals for all threads attached to the core running the calling
+ * thread, and calls the sched_select() function to select a new thread.
+ * The cause argument is only used for debug by the sched_display() function, and
+ * indicates the scheduling cause.
+ *********************************************************************************************
+ * @ cause    : character string defining the scheduling cause.
  ********************************************************************************************/
 void sched_yield();
+void sched_yield( char * cause );
 /*********************************************************************************************
 …
 /*********************************************************************************************
  * This function does NOT modify the scheduler state.
+ * It just select a thread in the list of attached threads, implementing the following policy:
+ * 1) it scan the list of kernel threads, from the next thread after the last executed one,
+ *    and returns the first runnable found (can be the current thread).
+ * 2) if no kernel thread found, it scan the list of user thread, from the next thread after
+ *    the last executed one, and returns the first runable found (can be the current thread).
+ * 3) if no runable thread found, it returns the idle thread.
+ * It just select a thread in the list of attached threads, implementing the following
+ * three steps policy:
+ * 1) It scan the list of kernel threads, from the next thread after the last executed one,
+ *    and returns the first runnable found : not IDLE, not blocked, client queue not empty.
+ *    It can be the current thread.
+ * 2) If no kernel thread found, it scan the list of user thread, from the next thread after
+ *    the last executed one, and returns the first runable found : not blocked.
+ *    It can be the current thread.
+ * 3) If no runable thread found, it returns the idle thread.
  *********************************************************************************************
  * @ core    : local pointer on the core descriptor.
+ * @ core    : local pointer on scheduler.
  * @ returns pointer on selected thread descriptor
  ********************************************************************************************/
 struct thread_s * sched_select( struct core_s * core );
+struct thread_s * sched_select( struct scheduler_s * sched );
 /*********************************************************************************************

trunk/kernel/kern/thread.c

-                      r407
+                      r408
 // - thread_user_fork()
 // - thread_kernel_create()
-// - thread_user_init()
 /////////////////////////////////////////////////////////////////////////////////////
 // @ thread       : pointer on thread descriptor
 …
         thread->signature = THREAD_SIGNATURE;
+    // FIXME call hal_thread_init() function to initialise the save_sr field
+    thread->save_sr = 0xFF13;
     // update local DQDT
     dqdt_local_update_threads( 1 );
 …
+    }
+        // update DQDT for new thread
+    dqdt_local_update_threads( 1 );
 thread_dmsg("\n[DBG] %s : core[%x,%d] exit / trdid = %x / process %x / core = %d\n",
 __FUNCTION__, local_cxy, CURRENT_THREAD->core->lid,
 …
 }  // end thread_user_create()
+////////////////////////////////////////////////////
+error_t thread_user_fork( process_t * process,
+                          intptr_t    stack_base,
+                          uint32_t    stack_size,
+                          thread_t ** new_thread )
+///////////////////////////////////////////////////////
+error_t thread_user_fork( xptr_t      parent_thread_xp,
+                          process_t * child_process,
+                          thread_t ** child_thread )
+{
     error_t        error;
+        thread_t     * child;       // pointer on new thread descriptor
+    lid_t          core_lid;     // selected core local index
+thread_dmsg("\n[DBG] %s : core[%x,%d] enters\n",
+__FUNCTION__ , local_cxy , core_lid );
+        thread_t     * child_ptr;        // local pointer on local child thread
+    lid_t          core_lid;         // selected core local index
+    thread_t     * parent_ptr;       // local pointer on remote parent thread
+    cxy_t          parent_cxy;       // parent thread cluster
+    process_t    * parent_process;   // local pointer on parent process
+    xptr_t         parent_gpt_xp;    // extended pointer on parent thread GPT
+    void         * func;             // parent thread entry_func
+    void         * args;             // parent thread entry_args
+    intptr_t       base;             // parent thread u_stack_base
+    uint32_t       size;             // parent thread u_stack_size
+    uint32_t       flags;            // parent_thread flags
+    vpn_t          vpn_base;         // parent thread stack vpn_base
+    vpn_t          vpn_size;         // parent thread stack vpn_size
+    reg_t        * uzone;            // parent thread pointer on uzone
+    vseg_t       * vseg;             // child thread STACK vseg
+thread_dmsg("\n[DBG] %s : core[%x,%d] enters at cycle %d\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , hal_get_cycles() );
     // select a target core in local cluster
     core_lid = cluster_select_local_core();
+    // get pointer on parent thread descriptor
+    thread_t * parent = CURRENT_THREAD;
+    // allocate memory for new thread descriptor
+    child = thread_alloc();
+    if( child == NULL )
+    // get cluster and local pointer on parent thread descriptor
+    parent_cxy = GET_CXY( parent_thread_xp );
+    parent_ptr = (thread_t *)GET_PTR( parent_thread_xp );
+    // get relevant fields from parent thread
+    func  = (void *)  hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->entry_func   ) );
+    args  = (void *)  hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->entry_args   ) );
+    base  = (intptr_t)hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->u_stack_base ) );
+    size  = (uint32_t)hal_remote_lw ( XPTR( parent_cxy , &parent_ptr->u_stack_size ) );
+    flags =           hal_remote_lw ( XPTR( parent_cxy , &parent_ptr->flags        ) );
+    uzone = (reg_t *) hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->uzone        ) );
+    vpn_base = base >> CONFIG_PPM_PAGE_SHIFT;
+    vpn_size = size >> CONFIG_PPM_PAGE_SHIFT;
+    // get pointer on parent process in parent thread cluster
+    parent_process = (process_t *)hal_remote_lpt( XPTR( parent_cxy,
+                                                        &parent_ptr->process ) );
+    // get extended pointer on parent GPT in parent thread cluster
+    parent_gpt_xp = XPTR( parent_cxy , &parent_process->vmm.gpt );
+    // allocate memory for child thread descriptor
+    child_ptr = thread_alloc();
+    if( child_ptr == NULL )
+    {
         printk("\n[ERROR] in %s : cannot allocate new thread\n", __FUNCTION__ );
         return ENOMEM;
+        return -1;
+    }
     // initialize thread descriptor
     error = thread_init( child,
                          process,
+    error = thread_init( child_ptr,
+                         child_process,
                          THREAD_USER,
                          parent->entry_func,
                          parent->entry_args,
+                         func,
+                         args,
                          core_lid,
+                         stack_base,
+                         stack_size );
+                         base,
+                         size );
     if( error )
+    {
             printk("\n[ERROR] in %s : cannot initialize new thread\n", __FUNCTION__ );
         thread_release( child );
+            printk("\n[ERROR] in %s : cannot initialize child thread\n", __FUNCTION__ );
+        thread_release( child_ptr );
         return EINVAL;
+    }
     // return child pointer
+    *new_thread = child;
+    // set DETACHED flag if required
+    if( parent->flags & THREAD_FLAG_DETACHED ) child->flags = THREAD_FLAG_DETACHED;
+    *child_thread = child_ptr;
+    // set detached flag if required
+    if( flags & THREAD_FLAG_DETACHED ) child_ptr->flags = THREAD_FLAG_DETACHED;
+    // update uzone pointer in child thread descriptor
+    child_ptr->uzone = (char *)((intptr_t)uzone +
+                                (intptr_t)child_ptr -
+                                (intptr_t)parent_ptr );
     // allocate CPU context for child thread
         if( hal_cpu_context_alloc( child ) )
+        if( hal_cpu_context_alloc( child_ptr ) )
+    {
             printk("\n[ERROR] in %s : cannot allocate CPU context\n", __FUNCTION__ );
         thread_release( child );
         return ENOMEM;
+        thread_release( child_ptr );
+        return -1;
+    }
     // allocate FPU context for child thread
         if( hal_fpu_context_alloc( child ) )
+        if( hal_fpu_context_alloc( child_ptr ) )
+    {
             printk("\n[ERROR] in %s : cannot allocate FPU context\n", __FUNCTION__ );
+        thread_release( child );
+        return ENOMEM;
+    }
+    // copy kernel stack content from parent to child thread descriptor
+    void * dst = (void *)(&child->signature) + 4;
+    void * src = (void *)(&parent->signature) + 4;
+    memcpy( dst , src , parent->k_stack_size );
+        thread_release( child_ptr );
+        return -1;
+    }
+    // create and initialize STACK vseg
+    vseg = vseg_alloc();
+    vseg_init( vseg,
+               VSEG_TYPE_STACK,
+               base,
+               size,
+               vpn_base,
+               vpn_size,
+, 0, XPTR_NULL,                         // not a file vseg
+               local_cxy );
+    // register STACK vseg in local child VSL
+    vseg_attach( &child_process->vmm , vseg );
+    // copy all valid STACK GPT entries
+    vpn_t          vpn;
+    bool_t         mapped;
+    ppn_t          ppn;
+    for( vpn = vpn_base ; vpn < (vpn_base + vpn_size) ; vpn++ )
+    {
+        error = hal_gpt_pte_copy( &child_process->vmm.gpt,
+                                  parent_gpt_xp,
+                                  vpn,
+                                  true,                 // set cow
+                                  &ppn,
+                                  &mapped );
+        if( error )
+        {
+            vseg_detach( &child_process->vmm , vseg );
+            vseg_free( vseg );
+            thread_release( child_ptr );
+            printk("\n[ERROR] in %s : cannot update child GPT\n", __FUNCTION__ );
+            return -1;
+        }
+        // increment page descriptor fork_nr for the referenced page if mapped
+        if( mapped )
+        {
+            xptr_t   page_xp  = ppm_ppn2page( ppn );
+            cxy_t    page_cxy = GET_CXY( page_xp );
+            page_t * page_ptr = (page_t *)GET_PTR( page_xp );
+            hal_remote_atomic_add( XPTR( page_cxy , &page_ptr->fork_nr ) , 1 );
+thread_dmsg("\n[DBG] %s : core[%x,%d] copied PTE to child GPT : vpn %x\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn );
+        }
+    }
+    // set COW flag for STAK vseg in parent thread GPT
+    hal_gpt_flip_cow( true,                               // set cow
+                      parent_gpt_xp,
+                      vpn_base,
+                      vpn_size );
+        // update DQDT for child thread
+    dqdt_local_update_threads( 1 );
 thread_dmsg("\n[DBG] %s : core[%x,%d] exit / created main thread %x for process %x\n",
 __FUNCTION__, local_cxy , core_lid , child->trdid , process->pid );
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, child_ptr->trdid, child_process->pid );
         return 0;
 …
         hal_cpu_context_create( thread );
+        // update DQDT for kernel thread
+    dqdt_local_update_threads( 1 );
 thread_dmsg("\n[DBG] %s : core = [%x,%d] exit / trdid = %x / type %s / cycle %d\n",
 __FUNCTION__, local_cxy, core_lid, thread->trdid, thread_type_str(type), hal_time_stamp() );
 …
     // update intrumentation values
+    uint32_t pgfaults = thread->info.pgfault_nr;
+    uint32_t u_errors = thread->info.u_err_nr;
+    uint32_t m_errors = thread->info.m_err_nr;
+        process->vmm.pgfault_nr += pgfaults;
+        process->vmm.u_err_nr   += u_errors;
+        process->vmm.m_err_nr   += m_errors;
+        process->vmm.pgfault_nr += thread->info.pgfault_nr;
     // release memory allocated for CPU context and FPU context
 …
+    {
         this->flags &= ~THREAD_FLAG_SCHED;
         sched_yield();
+        sched_yield( "delayed scheduling" );
+    }
 …
     // deschedule
     sched_yield();
+    sched_yield( "exit" );
     return 0;
 …
     while( 1 )
+    {
+        // unmask IRQs
+        hal_enable_irq( NULL );
         if( CONFIG_THREAD_IDLE_MODE_SLEEP ) // force core to low-power mode
+        {
 …
         // force scheduling at each iteration
         sched_yield();
+        sched_yield( "idle" );
+   }
 }  // end thread_idle()
 …
 ///////////////////////////////////////////////////
 void thread_kernel_time_update( thread_t * thread )
+{
-    // TODO
-    // printk("\n[WARNING] function %s not implemented\n", __FUNCTION__ );
+}
-////////////////////////////////////////////////
-void thread_signals_handle( thread_t * thread )
+{
     // TODO

trunk/kernel/kern/thread.h

-                      r407
+                      r408
 #include <spinlock.h>
 #include <core.h>
+#include <chdev.h>
 #include <cluster.h>
 #include <process.h>
 …
 #define THREAD_BLOCKED_RPC       0x0200  /*! thread wait RPC completion               */
-#define THREAD_BLOCKED_DEV_QUEUE 0x2000  /*! thread DEV wait queue                    */
 #define THREAD_BLOCKED_DEV_ISR   0x4000  /*! thread DEV wait ISR                      */
 …
  * thread is registered in the local copy of the process descriptor.
+ *
  * WARNING : Don't modify the first 4 fields order, as this order is used by the
+ * WARNING : Don't modify the first 3 fields order, as this order is used by the
  * hal_kentry assembly code for the TSAR architecture.
  **************************************************************************************/
 …
 typedef struct thread_s
+{
+        void              * cpu_context;     /*! used for context switch                  */
+        void              * fpu_context;     /*! used for dynamic FPU allocation          */
+        void              * cpu_context;     /*! pointer on CPU context switch            */
+        void              * fpu_context;     /*! pointer on FPU context switch            */
+    void              * uzone;           /*! pointer on uzone for hal_kentry          */
         intptr_t            k_stack_base;    /*! kernel stack base address                */
 …
     uint32_t            flags;           /*! bit vector of flags                      */
     volatile uint32_t   blocked;         /*! bit vector of blocking causes            */
     volatile uint32_t   signals;         /*! bit vector of (KILL / SUICIDE) signals   */
+    uint32_t            signals;         /*! bit vector of (KILL / SUICIDE) signals   */
+    uint32_t            blocked;         /*! bit vector of blocking causes            */
         error_t             errno;           /*! errno value set by last system call      */
 …
         list_entry_t        sched_list;      /*! member of threads attached to same core  */
+    uint32_t            dev_channel;     /*! device channel for a DEV thread          */
+    chdev_t           * chdev;           /*! chdev pointer (for a DEV thread only)    */
+    reg_t               save_sr;         /*! used by sched_yield() function           */
     ioc_command_t       ioc_cmd;         /*! IOC device generic command               */
 …
 /***************************************************************************************
  * This function allocates memory for a user thread descriptor in the local cluster,
  * and initializes it from information contained in the arguments.
  * It is used by the "pthread_create" system call.
  * The CPU context is initialized from scratch, and the "loadable" field is set.
  * The new thread is attached to the core specified in the <attr> argument.
+ * This function is used by the pthread_create() system call to create a "new" thread
+ * in an existing process. It allocates memory for an user thread descriptor in the
+ * local cluster, and initializes it from information contained in the arguments.
+ * The CPU context is initialized from scratch. If required by the <attr> argument,
+ * the new thread is attached to the core specified in <attr>.
  * 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
 …
 /***************************************************************************************
  * This function is used by the fork() system call to create the child process main
  * thread. It allocates memory for an user thread descriptor in the local cluster,
  * and initializes it from information contained in the calling thread descriptor.
+ * This function is used by the sys_fork() system call to create the "child" thread
+ * in the local cluster. It allocates memory for a thread descriptor, and initializes
+ * it from the "parent" thread descriptor defined by the <parent_thread_xp> argument.
  * The new thread is attached to the core that has the lowest load in local cluster.
  * It is registered in the child process descriptor defined by the <process> argument.
+ * It is registered in the "child" process defined by the <child_process> argument.
  * This new thread inherits its user stack from the parent thread, as it uses the
  * Copy-On-Write mechanism to get a private stack when required.
 …
  * the Copy-On-Write mechanism cannot be used for kernel segments (because kernel
  * uses physical addressing on some architectures).
+ * The CPU and FPU execution contexts are created and linked to the new thread,
+ * but the actual context copy is NOT done. The THREAD_BLOCKED_GLOBAL bit is set,
+ * and the thread must be explicitely unblocked later to make the new thread runable.
+ ***************************************************************************************
+ * @ process      : local pointer on owner process descriptor.
+ * @ stack_base   : user stack base address (from parent).
+ * @ stack_size   : user stack size (from parent).
+ * @ new_thread   : [out] address of buffer for new thread descriptor pointer.
+ * @ returns 0 if success / returns ENOMEM if error.
+ **************************************************************************************/
+error_t thread_user_fork( process_t * process,
+                          intptr_t    stack_base,
+                          uint32_t    stack_size,
+                          thread_t ** new_thread );
+ * The CPU and FPU execution contexts are created and linked to the new thread.
+ * but the actual context copy is NOT done, and must be done by by the sys_fork().
+ * The THREAD_BLOCKED_GLOBAL bit is set => the thread must be activated to start.
+ ***************************************************************************************
+ * @ parent_thread_xp  : extended pointer on parent thread descriptor.
+ * @ child_process     : local pointer on child process descriptor.
+ * @ child_thread      : [out] address of buffer for child thread descriptor pointer.
+ * @ returns 0 if success / returns -1 if error.
+ **************************************************************************************/
+error_t thread_user_fork( xptr_t      parent_thread_xp,
+                          process_t * child_process,
+                          thread_t ** child_thread );
 /***************************************************************************************
  * This function allocates memory for a kernel thread descriptor in the local cluster,
+ * and initializes it from arguments values, calling the thread_kernel_init() function,
+ * that also allocates and initializes the CPU context.
+ * and initializes it from arguments values.
+ * It is called by kernel_init() to statically create all DEV server threads
+ * It is also called to dynamically create RPC threads when required.
  * The THREAD_BLOCKED_GLOBAL bit is set, and the thread must be activated to start.
  ***************************************************************************************
 …
 /***************************************************************************************
  * This function initializes an existing kernel thread descriptor from arguments values.
+ * This function initializes an existing thread descriptor from arguments values.
  * The THREAD_BLOCKED_GLOBAL bit is set, and the thread must be activated to start.
+ * It is called by the kernel_init() function to initialize the IDLE thread.
  ***************************************************************************************
  * @ thread   : pointer on existing thread descriptor.

trunk/kernel/libk/remote_barrier.c

r407	r408
274	274	// block & deschedule the calling thread
275	275	thread_block( thread_ptr , THREAD_BLOCKED_USERSYNC );
276		sched_yield();
	276	sched_yield("blocked on barrier");
277	277
278	278	// restore interrupts

trunk/kernel/libk/remote_condvar.c

r407	r408
189	189	// block the calling thread
190	190	thread_block( CURRENT_THREAD , THREAD_BLOCKED_USERSYNC );
191		sched_yield();
	191	sched_yield("blocked on condvar");
192	192
193	193	// lock the mutex before return

trunk/kernel/libk/remote_fifo.c

r407	r408
89	89	// - deschedule without blocking if possible
90	90	// - wait ~1000 cycles otherwise
91		if( thread_can_yield() ) sched_yield();
	91	if( thread_can_yield() ) sched_yield( "wait RPC fifo" );
92	92	else hal_fixed_delay( 1000 );
93	93

trunk/kernel/libk/remote_mutex.c

r407	r408
208	208	// block & deschedule the calling thread
209	209	thread_block( thread_ptr , THREAD_BLOCKED_USERSYNC );
210		sched_yield();
	210	sched_yield("blocked on mutex");
211	211
212	212	// restore interrupts

trunk/kernel/libk/remote_sem.c

r407	r408
219	219	// block and deschedule
220	220	thread_block( this , THREAD_BLOCKED_SEM );
221		sched_yield();
	221	sched_yield("blocked on semaphore");
222	222	}
223	223	} // end remote_sem_wait()

trunk/kernel/libk/remote_spinlock.c

r407	r408
179	179	{
180	180	hal_restore_irq( mode );
181		if( thread_can_yield() ) sched_yield();
	181	if( thread_can_yield() ) sched_yield("waiting spinlock");
182	182	hal_disable_irq( &mode );
183	183	continue;

trunk/kernel/libk/spinlock.c

r407	r408
111	111	{
112	112	hal_restore_irq( mode );
113		if( thread_can_yield() ) sched_yield();
	113	if( thread_can_yield() ) sched_yield("waiting spinlock");
114	114	hal_disable_irq( &mode );
115	115	continue;

trunk/kernel/mm/mapper.c

r407	r408
240	240	rwlock_wr_unlock( &mapper->lock );
241	241
242		// ~~deschedule to~~ wait load completion
	242	// wait load completion
243	243	while( 1 )
244	244	{
245	245	// exit waiting loop when loaded
246		if( ~~page_is_flag( page , PG_INLOAD )~~ ) break;
	246	if( page_is_flag( page , PG_INLOAD ) == false ) break;
247	247
248	248	// deschedule
249		sched_yield();
	249	sched_yield("waiting page loading");
250	250	}
251	251	}
…	…
253	253	else // page available in mapper
254	254	{
255
256	255	rwlock_rd_unlock( &mapper->lock );
257	256	}

trunk/kernel/mm/page.c

-                      r407
+                      r408
         page->index    = 0;
         page->refcount = 0;
+        page->fork_nr  = 0;
         spinlock_init( &page->lock );
 …
                 // deschedule the calling thread
                 thread_block( thread , THREAD_BLOCKED_PAGE );
                 sched_yield();
+                sched_yield("cannot lock a page");
+        }
         else                                    // page is not locked

trunk/kernel/mm/page.h

r407	r408
67	67	xlist_entry_t wait_root; /! root of list of waiting threads (16) /
68	68	uint32_t refcount; /! reference counter (4) /
69		uint32_t ~~reserved; /! UNUSED~~ (4) /
	69	uint32_t fork_nr; /! number of pending forks (4) /
70	70	spinlock_t lock; /! only used to set the PG_LOCKED flag (16) /
71	71	}

trunk/kernel/mm/vmm.c

-                      r407
+                      r408
 #include <rwlock.h>
 #include <list.h>
+#include <xlist.h>
 #include <bits.h>
 #include <process.h>
 …
     // initialize local list of vsegs
     vmm->vsegs_nr = 0;
         list_root_init( &vmm->vsegs_root );
         rwlock_init( &vmm->vsegs_lock );
+        xlist_root_init( XPTR( local_cxy , &vmm->vsegs_root ) );
+        remote_rwlock_init( XPTR( local_cxy , &vmm->vsegs_lock ) );
     assert( ((CONFIG_VMM_KENTRY_SIZE + CONFIG_VMM_ARGS_SIZE + CONFIG_VMM_ENVS_SIZE)
 …
     // initialize instrumentation counters
         vmm->pgfault_nr          = 0;
-        vmm->u_err_nr            = 0;
-        vmm->m_err_nr            = 0;
     hal_fence();
 …
     // get lock protecting the vseg list
     rwlock_rd_lock( &vmm->vsegs_lock );
+    remote_rwlock_rd_lock( XPTR( local_cxy , &vmm->vsegs_lock ) );
     // scan the list of vsegs
+    list_entry_t * iter;
+    xptr_t         root_xp = XPTR( local_cxy , &vmm->vsegs_root );
+    xptr_t         iter_xp;
+    xptr_t         vseg_xp;
     vseg_t       * vseg;
+    LIST_FOREACH( &vmm->vsegs_root , iter )
+    {
+        vseg = LIST_ELEMENT( iter , vseg_t , list );
+    XLIST_FOREACH( root_xp , iter_xp )
+    {
+        vseg_xp = XLIST_ELEMENT( iter_xp , vseg_t , xlist );
+        vseg    = (vseg_t *)GET_PTR( vseg_xp );
         printk(" - %s : base = %X / size = %X / npages = %d\n",
         vseg_type_str( vseg->type ) , vseg->min , vseg->max - vseg->min , vseg->vpn_size );
 …
     // release the lock
+    rwlock_rd_unlock( &vmm->vsegs_lock );
+}
+//////////////////////////////////////////
+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 );
+    // initialize dst_vmm vsegs_lock
+    rwlock_init( &dst_vmm->vsegs_lock );
+    // initialize the dst_vmm vsegs list
+    dst_vmm->vsegs_nr = 0;
+    list_root_init( &dst_vmm->vsegs_root );
+    // initialize generic page table
+    error = hal_gpt_create( &dst_vmm->gpt );
+    remote_rwlock_rd_unlock( XPTR( local_cxy , &vmm->vsegs_lock ) );
+}  // vmm_display()
+/////////////////////i////////////////////
+void vmm_update_pte( process_t * process,
+                     vpn_t       vpn,
+                     uint32_t    attr,
+                     ppn_t       ppn )
+{
+    xlist_entry_t * process_root_ptr;
+    xptr_t          process_root_xp;
+    xptr_t          process_iter_xp;
+    xptr_t          remote_process_xp;
+    cxy_t           remote_process_cxy;
+    process_t     * remote_process_ptr;
+    xptr_t          remote_gpt_xp;
+    pid_t           pid;
+    cxy_t           owner_cxy;
+    lpid_t          owner_lpid;
+    // get extended pointer on root of process copies xlist in owner cluster
+    pid              = process->pid;
+    owner_cxy        = CXY_FROM_PID( pid );
+    owner_lpid       = LPID_FROM_PID( pid );
+    process_root_ptr = &LOCAL_CLUSTER->pmgr.copies_root[owner_lpid];
+    process_root_xp  = XPTR( owner_cxy , process_root_ptr );
+    // loop on destination process copies
+    XLIST_FOREACH( process_root_xp , process_iter_xp )
+    {
+        // get cluster and local pointer on remote process
+        remote_process_xp  = XLIST_ELEMENT( process_iter_xp , process_t , copies_list );
+        remote_process_ptr = (process_t *)GET_PTR( remote_process_xp );
+        remote_process_cxy = GET_CXY( remote_process_xp );
+        // get extended pointer on remote gpt
+        remote_gpt_xp = XPTR( remote_process_cxy , &remote_process_ptr->vmm.gpt );
+        hal_gpt_update_pte( remote_gpt_xp,
+                            vpn,
+                            attr,
+                            ppn );
+    }
+}  // end vmm_update_pte()
+///////////////////////////////////////
+void vmm_set_cow( process_t * process )
+{
+    vmm_t         * vmm;
+    xlist_entry_t * process_root_ptr;
+    xptr_t          process_root_xp;
+    xptr_t          process_iter_xp;
+    xptr_t          remote_process_xp;
+    cxy_t           remote_process_cxy;
+    process_t     * remote_process_ptr;
+    xptr_t          remote_gpt_xp;
+    xptr_t          vseg_root_xp;
+    xptr_t          vseg_iter_xp;
+    xptr_t          vseg_xp;
+    vseg_t        * vseg;
+    pid_t           pid;
+    cxy_t           owner_cxy;
+    lpid_t          owner_lpid;
+vmm_dmsg("\n[DBG] %s : core[%x,%d] enters for process %x\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , process->pid );
+    // check cluster is reference
+    assert( (GET_CXY( process->ref_xp ) == local_cxy) , __FUNCTION__,
+    "local cluster is not process reference cluster\n");
+    // get pointer on reference VMM
+    vmm = &process->vmm;
+    // get extended pointer on root of process copies xlist in owner cluster
+    pid              = process->pid;
+    owner_cxy        = CXY_FROM_PID( pid );
+    owner_lpid       = LPID_FROM_PID( pid );
+    process_root_ptr = &LOCAL_CLUSTER->pmgr.copies_root[owner_lpid];
+    process_root_xp  = XPTR( owner_cxy , process_root_ptr );
+    // get extended pointer on root of vsegs xlist from reference VMM
+    vseg_root_xp  = XPTR( local_cxy , &vmm->vsegs_root );
+    // loop on destination process copies
+    XLIST_FOREACH( process_root_xp , process_iter_xp )
+    {
+        // get cluster and local pointer on remote process
+        remote_process_xp  = XLIST_ELEMENT( process_iter_xp , process_t , copies_list );
+        remote_process_ptr = (process_t *)GET_PTR( remote_process_xp );
+        remote_process_cxy = GET_CXY( remote_process_xp );
+vmm_dmsg("\n[DBG] %s : core[%x,%d] handling process %x in cluster %x\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , process->pid , remote_process_cxy );
+        // get extended pointer on remote gpt
+        remote_gpt_xp = XPTR( remote_process_cxy , &remote_process_ptr->vmm.gpt );
+        // loop on vsegs in (local) reference process VSL
+        XLIST_FOREACH( vseg_root_xp , vseg_iter_xp )
+        {
+            // get pointer on vseg
+            vseg_xp  = XLIST_ELEMENT( vseg_iter_xp , vseg_t , xlist );
+            vseg     = (vseg_t *)GET_PTR( vseg_xp );
+            assert( (GET_CXY( vseg_xp ) == local_cxy) , __FUNCTION__,
+            "all vsegs in reference VSL must be local\n" );
+            // get vseg type, base and size
+            uint32_t type     = vseg->type;
+            vpn_t    vpn_base = vseg->vpn_base;
+            vpn_t    vpn_size = vseg->vpn_size;
+vmm_dmsg("\n[DBG] %s : core[%x,%d] handling vseg %s / vpn_base = %x / vpn_size = %x\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, vseg_type_str(type), vpn_base, vpn_size );
+            // set COW flag on the remote GPT depending on vseg type
+            if( (type == VSEG_TYPE_DATA)  ||
+                (type == VSEG_TYPE_ANON)  ||
+                (type == VSEG_TYPE_REMOTE) )
+            {
+                hal_gpt_flip_cow( true,             // set_cow
+                                  remote_gpt_xp,
+                                  vpn_base,
+                                  vpn_size );
+            }
+        }    // en loop on vsegs
+    }   // end loop on process copies
+vmm_dmsg("\n[DBG] %s : core[%x,%d] exit for process %x\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , process->pid );
+}  // end vmm_set-cow()
+/////////////////////////////////////////////////
+error_t vmm_fork_copy( process_t * child_process,
+                       xptr_t      parent_process_xp )
+{
+    error_t     error;
+    cxy_t       parent_cxy;
+    process_t * parent_process;
+    vmm_t     * parent_vmm;
+    xptr_t      parent_lock_xp;
+    vmm_t     * child_vmm;
+    xptr_t      iter_xp;
+    xptr_t      parent_vseg_xp;
+    vseg_t    * parent_vseg;
+    vseg_t    * child_vseg;
+    uint32_t    type;
+    bool_t      cow;
+    vpn_t       vpn;
+    vpn_t       vpn_base;
+    vpn_t       vpn_size;
+    xptr_t      page_xp;
+    page_t    * page_ptr;
+    cxy_t       page_cxy;
+    xptr_t      parent_root_xp;
+    bool_t      mapped;
+    ppn_t       ppn;
+vmm_dmsg("\n[DBG] %s : core[%x,%d] enter\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid );
+    // get parent process cluster and local pointer
+    parent_cxy     = GET_CXY( parent_process_xp );
+    parent_process = (process_t *)GET_PTR( parent_process_xp );
+    // get local pointers on parent and child VMM
+    parent_vmm = &parent_process->vmm;
+    child_vmm  = &child_process->vmm;
+    // get extended pointer on lock protecting the parent VSL
+    parent_lock_xp = XPTR( parent_cxy , &parent_vmm->vsegs_lock );
+    // take the lock protecting the parent VSL
+    remote_rwlock_rd_lock( parent_lock_xp );
+    // initialize the lock protecting the child VSL
+    remote_rwlock_init( XPTR( local_cxy , &child_vmm->vsegs_lock ) );
+    // initialize the child VSL as empty
+    xlist_root_init( XPTR( local_cxy, &child_vmm->vsegs_root ) );
+    child_vmm->vsegs_nr = 0;
+    // create & initialize the child GPT as empty
+    error = hal_gpt_create( &child_vmm->gpt );
     if( error )
+    {
+        printk("\n[ERROR] in %s : cannot initialize page table\n", __FUNCTION__ );
+        return ENOMEM;
+    }
+    // loop on SRC VSL to register vsegs copies in DST VSL
+    // and copy valid PTEs from SRC GPT to DST GPT
+    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 )
+        printk("\n[ERROR] in %s : cannot create GPT\n", __FUNCTION__ );
+        return -1;
+    }
+    // build extended pointer on parent VSL
+    parent_root_xp = XPTR( parent_cxy , &parent_vmm->vsegs_root );
+    // loop on parent VSL xlist
+    XLIST_FOREACH( parent_root_xp , iter_xp )
+    {
+        // get local and extended pointers on current parent vseg
+        parent_vseg_xp = XLIST_ELEMENT( iter_xp , vseg_t , xlist );
+        parent_vseg    = (vseg_t *)GET_PTR( parent_vseg_xp );
+        // get vseg type
+        type = hal_remote_lw( XPTR( parent_cxy , &parent_vseg->type ) );
+vmm_dmsg("\n[DBG] %s : core[%x,%d] found parent vseg %s / vpn_base = %x\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vseg_type_str(type),
+hal_remote_lw( XPTR( parent_cxy , &parent_vseg->vpn_base ) ) );
+        // all parent vsegs - but STACK - must be copied in child VSL
+        if( type != VSEG_TYPE_STACK )
+        {
+            // release all allocated vsegs
+            LIST_FOREACH( &dst_vmm->vsegs_root , iter )
+            // allocate memory for a new child vseg
+            child_vseg = vseg_alloc();
+            if( child_vseg == NULL )   // release all allocated vsegs
+            {
+                dst_vseg = LIST_ELEMENT( iter , vseg_t , list );
+                vseg_free( dst_vseg );
+                vmm_destroy( child_process );
+                printk("\n[ERROR] in %s : cannot create vseg for child\n", __FUNCTION__ );
+                return -1;
+            }
+            return ENOMEM;
+        }
+        // copy src_vseg to dst_vseg
+        vseg_init_from_ref( dst_vseg , XPTR( local_cxy , src_vseg ) );
+        // register dst_vseg in DST VSL
+        vseg_attach( dst_vmm , dst_vseg );
+        // copy SRC GPT to DST GPT / set COW for all writable vsegs, but the FILE type
+        bool_t cow = (src_vseg->type != VSEG_TYPE_FILE) && (src_vseg->flags & VSEG_WRITE);
+        error = hal_gpt_copy( &dst_vmm->gpt,
+                              &src_vmm->gpt,
+                              src_vseg->vpn_base,
+                              src_vseg->vpn_size,
+                              cow );
+        if( error )
+        {
+            printk("\n[ERROR] in %s : cannot copy page GPT\n", __FUNCTION__ );
+            hal_gpt_destroy( &dst_vmm->gpt );
+            return ENOMEM;
+        }
+    }
+    // release the src_vmm vsegs_lock
+    rwlock_wr_unlock( &src_vmm->vsegs_lock );
+    // 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_HEAP_BASE;
+    dst_vmm->mmap_mgr.vpn_size        = CONFIG_VMM_STACK_BASE - CONFIG_VMM_HEAP_BASE;
+    dst_vmm->mmap_mgr.first_free_vpn  = CONFIG_VMM_HEAP_BASE;
+            // copy parent vseg to child vseg
+            vseg_init_from_ref( child_vseg , parent_vseg_xp );
+            // register child vseg in child VSL
+            vseg_attach( child_vmm , child_vseg );
+vmm_dmsg("\n[DBG] %s : core[%x,%d] copied to child VSL : vseg %s / vpn_base = %x\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vseg_type_str(type),
+hal_remote_lw( XPTR( parent_cxy , &parent_vseg->vpn_base ) ) );
+            // copy DATA, MMAP, REMOTE, FILE parent GPT entries to child GPT
+            if( type != VSEG_TYPE_CODE )
+            {
+                // activate the COW for DATA, MMAP, REMOTE vsegs only
+                cow = ( type != VSEG_TYPE_FILE );
+                vpn_base = child_vseg->vpn_base;
+                vpn_size = child_vseg->vpn_size;
+                // scan pages in parent vseg
+                for( vpn = vpn_base ; vpn < (vpn_base + vpn_size) ; vpn++ )
+                {
+                    error = hal_gpt_pte_copy( &child_vmm->gpt,
+                                              XPTR( parent_cxy , &parent_vmm->gpt ),
+                                              vpn,
+                                              cow,
+                                              &ppn,
+                                              &mapped );
+                    if( error )
+                    {
+                        vmm_destroy( child_process );
+                        printk("\n[ERROR] in %s : cannot copy GPT\n", __FUNCTION__ );
+                        return -1;
+                    }
+                    // increment page descriptor fork_nr for the referenced page if mapped
+                    if( mapped )
+                    {
+                        page_xp = ppm_ppn2page( ppn );
+                        page_cxy = GET_CXY( page_xp );
+                        page_ptr = (page_t *)GET_PTR( page_xp );
+                        hal_remote_atomic_add( XPTR( page_cxy , &page_ptr->fork_nr ) , 1 );
+vmm_dmsg("\n[DBG] %s : core[%x,%d] copied to child GPT : vpn %x\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn );
+                    }
+                }
+            }   // end if no code & no stack
+        }   // end if no stack
+    }   // end loop on vsegs
+    // release the parent vsegs lock
+    remote_rwlock_rd_unlock( parent_lock_xp );
+    // initialize the child VMM STACK allocator
+    child_vmm->stack_mgr.bitmap   = 0;
+    child_vmm->stack_mgr.vpn_base = CONFIG_VMM_STACK_BASE;
+    // initialize the child VMM MMAP allocator
     uint32_t i;
+    for( i = 0 ; i < 32 ; i++ ) list_root_init( &dst_vmm->mmap_mgr.zombi_list[i] );
+    child_vmm->mmap_mgr.vpn_base        = CONFIG_VMM_HEAP_BASE;
+    child_vmm->mmap_mgr.vpn_size        = CONFIG_VMM_STACK_BASE - CONFIG_VMM_HEAP_BASE;
+    child_vmm->mmap_mgr.first_free_vpn  = CONFIG_VMM_HEAP_BASE;
+    for( i = 0 ; i < 32 ; i++ ) list_root_init( &child_vmm->mmap_mgr.zombi_list[i] );
     // initialize 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;
+        child_vmm->pgfault_nr    = 0;
+    // copy base addresses from parent VMM to child VMM
+    child_vmm->kent_vpn_base = (vpn_t)hal_remote_lpt(XPTR(parent_cxy, &parent_vmm->kent_vpn_base));
+    child_vmm->args_vpn_base = (vpn_t)hal_remote_lpt(XPTR(parent_cxy, &parent_vmm->args_vpn_base));
+    child_vmm->envs_vpn_base = (vpn_t)hal_remote_lpt(XPTR(parent_cxy, &parent_vmm->envs_vpn_base));
+    child_vmm->heap_vpn_base = (vpn_t)hal_remote_lpt(XPTR(parent_cxy, &parent_vmm->heap_vpn_base));
+    child_vmm->code_vpn_base = (vpn_t)hal_remote_lpt(XPTR(parent_cxy, &parent_vmm->code_vpn_base));
+    child_vmm->data_vpn_base = (vpn_t)hal_remote_lpt(XPTR(parent_cxy, &parent_vmm->data_vpn_base));
+    child_vmm->entry_point = (intptr_t)hal_remote_lpt(XPTR(parent_cxy, &parent_vmm->entry_point));
     hal_fence();
 …
     return 0;
 }  // vmm_copy()
+}  // vmm_fork_copy()
 ///////////////////////////////////////
 void vmm_destroy( process_t * process )
+{
+    xptr_t   vseg_xp;
         vseg_t * vseg;
 …
     vmm_t  * vmm = &process->vmm;
+    // get extended pointer on VSL root and VSL lock
+    xptr_t   root_xp = XPTR( local_cxy , &vmm->vsegs_root );
+        xptr_t   lock_xp = XPTR( local_cxy , &vmm->vsegs_lock );
     // get lock protecting vseg list
         rwlock_wr_lock( &vmm->vsegs_lock );
     // remove all vsegs registered in vmm
         while( !list_is_empty( &vmm->vsegs_root ) )
+        remote_rwlock_wr_lock( lock_xp );
+    // remove all vsegs registered in VSL
+        while( !xlist_is_empty( root_xp ) )
+        {
+                vseg = LIST_FIRST( &vmm->vsegs_root ,  vseg_t , list );
+                vseg_xp = XLIST_FIRST_ELEMENT( root_xp , vseg_t , xlist );
+        vseg = (vseg_t *)GET_PTR( vseg_xp );
                 vseg_detach( vmm , vseg );
         vseg_free( vseg );
 …
     // release lock
         rwlock_wr_unlock(&vmm->vsegs_lock);
+        remote_rwlock_wr_unlock( lock_xp );
     // remove all vsegs from zombi_lists in MMAP allocator
 …
             while( !list_is_empty( &vmm->mmap_mgr.zombi_list[i] ) )
+            {
                     vseg = LIST_FIRST( &vmm->mmap_mgr.zombi_list[i] , vseg_t , list );
+                    vseg = LIST_FIRST( &vmm->mmap_mgr.zombi_list[i] , vseg_t , zlist );
                     vseg_detach( vmm , vseg );
             vseg_free( vseg );
 …
+{
     vmm_t        * vmm = &process->vmm;
+    // scan the VSL
         vseg_t       * vseg;
+    list_entry_t * iter;
+    // scan the list of registered vsegs
+        LIST_FOREACH( &vmm->vsegs_root , iter )
+    xptr_t         iter_xp;
+    xptr_t         vseg_xp;
+    xptr_t         root_xp = XPTR( local_cxy , &vmm->vsegs_root );
+        XLIST_FOREACH( root_xp , iter_xp )
+        {
+                vseg = LIST_ELEMENT( iter , vseg_t , list );
+                vseg_xp = XLIST_ELEMENT( iter_xp , vseg_t , xlist );
+        vseg    = (vseg_t *)GET_PTR( vseg_xp );
                 if( ((vpn_base + vpn_size) > vseg->vpn_base) &&
 …
+    {
         // get pointer on zombi vseg from zombi_list
         vseg = LIST_FIRST( &mgr->zombi_list[index] , vseg_t , list );
+        vseg = LIST_FIRST( &mgr->zombi_list[index] , vseg_t , zlist );
         // remove vseg from free-list
         list_unlink( &vseg->list );
+        list_unlink( &vseg->zlist );
         // compute base
 …
                cxy );
+    // attach vseg to vmm
+        rwlock_wr_lock( &vmm->vsegs_lock );
+    // attach vseg to VSL
+    xptr_t lock_xp = XPTR( local_cxy , &vmm->vsegs_lock );
+        remote_rwlock_wr_lock( lock_xp );
         vseg_attach( vmm , vseg );
         rwlock_wr_unlock( &vmm->vsegs_lock );
+        remote_rwlock_wr_unlock( lock_xp );
 vmm_dmsg("\n[DBG] %s : core[%x,%d] exit / process %x / base %x / size %x / type %s\n",
 …
     uint32_t     type    = vseg->type;
+    // detach vseg from VMM
+        rwlock_wr_lock( &vmm->vsegs_lock );
+    vseg_detach( &process->vmm , vseg );
+        rwlock_wr_unlock( &vmm->vsegs_lock );
+    // detach vseg from VSL
+    xptr_t lock_xp = XPTR( local_cxy , &vmm->vsegs_lock );
+        remote_rwlock_wr_lock( lock_xp );
+        vseg_detach( &process->vmm , vseg );
+        remote_rwlock_wr_unlock( lock_xp );
     // release the stack slot to VMM stack allocator if STACK type
 …
         // update zombi_list
         spinlock_lock( &mgr->lock );
         list_add_first( &mgr->zombi_list[index] , &vseg->list );
+        list_add_first( &mgr->zombi_list[index] , &vseg->zlist );
         spinlock_unlock( &mgr->lock );
+    }
 …
         // set page table entry
         ppn = ppm_page2ppn( XPTR( local_cxy , page ) );
+        error = hal_gpt_set_pte( gpt , vpn , ppn , attr );
+        error = hal_gpt_set_pte( gpt,
+                                 vpn,
+                                 attr,
+                                 ppn );
                 if( error )
+        {
 …
         return 0;
+}
+}  // end vmm_map_kernel_vseg()
 /////////////////////////////////////////
 …
                                  intptr_t   vaddr )
+{
+    list_entry_t * iter;
+    vseg_t       * vseg = NULL;
+    // get lock protecting the vseg list
+    rwlock_rd_lock( &vmm->vsegs_lock );
+    // scan the list of vsegs
+    LIST_FOREACH( &vmm->vsegs_root , iter )
+    {
+        vseg = LIST_ELEMENT( iter , vseg_t , list );
+        if( (vaddr >= vseg->min) && (vaddr < vseg->max) ) break;
+    }
+    // release the lock
+    rwlock_rd_unlock( &vmm->vsegs_lock );
+    return vseg;
+}
+    xptr_t   iter_xp;
+    xptr_t   vseg_xp;
+    vseg_t * vseg;
+    // get extended pointers on VSL lock and root
+    xptr_t lock_xp = XPTR( local_cxy , &vmm->vsegs_lock );
+    xptr_t root_xp = XPTR( local_cxy , &vmm->vsegs_root );
+    // get lock protecting the VSL
+    remote_rwlock_rd_lock( lock_xp );
+    // scan the list of vsegs in VSL
+    XLIST_FOREACH( root_xp , iter_xp )
+    {
+        vseg_xp = XLIST_ELEMENT( iter_xp , vseg_t , xlist );
+        vseg    = (vseg_t *)GET_PTR( vseg_xp );
+        if( (vaddr >= vseg->min) && (vaddr < vseg->max) )
+        {
+            // return success
+            remote_rwlock_rd_unlock( lock_xp );
+            return vseg;
+        }
+    }
+    // return failure
+    remote_rwlock_rd_unlock( lock_xp );
+    return NULL;
+}  // end vseg_from_vaddr()
 /////////////////////////////////////////////
 …
         if( vseg == NULL)  return EINVAL;
+    // get VMM lock protecting vsegs list
+        rwlock_wr_lock( &vmm->vsegs_lock );
+    // get extended pointer on VSL lock
+    xptr_t lock_xp = XPTR( local_cxy , &vmm->vsegs_lock );
+    // get lock protecting VSL
+        remote_rwlock_wr_lock( lock_xp );
         if( (vseg->min > addr_min) || (vseg->max < addr_max) )   // region not included in vseg
 …
     // release VMM lock
         rwlock_wr_unlock( &vmm->vsegs_lock );
+        remote_rwlock_wr_unlock( lock_xp );
         return error;
 …
     ppn_t     new_ppn;    // new PTE_PPN
     uint32_t  new_attr;   // new PTE_ATTR
-    xptr_t    page_xp;    // extended pointer on allocated page descriptor
     error_t   error;
 …
 vmm_dmsg("\n[DBG] %s : core[%x,%d] enter for vpn = %x in process %x / cow = %d\n",
 __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn , process->pid , %d);
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn , process->pid , cow );
     // get VMM pointer
 …
     hal_gpt_get_pte( &vmm->gpt , vpn , &old_attr , &old_ppn );
+    // for both copy_on_write and page_fault events, we allocate a physical page,
+    // initialize it, register it in the GPT, and return the new_ppn and new_attr
+    // for both "copy_on_write" and "page_fault" events, allocate a physical page,
+    // initialize it, register it in the reference GPT, update GPT copies in all
+    // clusters containing a copy, and return the new_ppn and new_attr
     if( cow )               ////////////// copy_on_write request ///////////
+    {
         assert( (*attr & GPT_MAPPED) , __FUNCTION__ ,
         "PTE must be mapped for a copy-on-write\n" );
 vmm_dmsg("\n[DBG] %s : core[%x,%d] page %x must be copied => do it\n",
+        assert( (old_attr & GPT_MAPPED) , __FUNCTION__ ,
+        "PTE must be mapped for a copy-on-write exception\n" );
+excp_dmsg("\n[DBG] %s : core[%x,%d] handling COW for vpn %x\n",
 __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn );
+        // allocate a physical page depending on vseg type
+        page_xp = vmm_page_allocate( vseg , vpn );
+        if( page_xp == XPTR_NULL )
+        // get extended pointer, cluster and local pointer on page descriptor
+        xptr_t   page_xp  = ppm_ppn2page( old_ppn );
+        cxy_t    page_cxy = GET_CXY( page_xp );
+        page_t * page_ptr = (page_t *)GET_PTR( page_xp );
+        // get number of pending forks in page descriptor
+        uint32_t count = hal_remote_lw( XPTR( page_cxy , &page_ptr->fork_nr ) );
+        if( count )        // pending fork => allocate a new page, copy it, reset COW
+        {
+            printk("\n[ERROR] in %s : no memory / process = %x / vpn = %x\n",
+            __FUNCTION__ , process->pid , vpn );
+            return ENOMEM;
+            // allocate a new physical page
+            page_xp = vmm_page_allocate( vseg , vpn );
+            if( page_xp == XPTR_NULL )
+            {
+                printk("\n[ERROR] in %s : no memory / process = %x / vpn = %x\n",
+                __FUNCTION__ , process->pid , vpn );
+                return -1;
+            }
+            // compute allocated page PPN
+            new_ppn = ppm_page2ppn( page_xp );
+            // copy old page content to new page
+            xptr_t  old_base_xp = ppm_ppn2base( old_ppn );
+            xptr_t  new_base_xp = ppm_ppn2base( new_ppn );
+            memcpy( GET_PTR( new_base_xp ),
+                    GET_PTR( old_base_xp ),
+                    CONFIG_PPM_PAGE_SIZE );
+        }
+        else               // no pending fork => keep the existing page, reset COW
+        {
+            new_ppn = old_ppn;
+        }
+        // compute allocated page PPN
+        new_ppn = ppm_page2ppn( page_xp );
+        // copy old page content to new page
+        xptr_t  old_base_xp = ppm_ppn2base( old_ppn );
+        xptr_t  new_base_xp = ppm_ppn2base( new_ppn );
+        memcpy( GET_PTR( new_base_xp ),
+                GET_PTR( old_base_xp ),
+                CONFIG_PPM_PAGE_SIZE );
+        // update attributes: reset COW and set WRITABLE
+        new_attr = old_attr & ~GPT_COW;
+        new_attr = new_attr | GPT_WRITABLE;
+        // register PTE in GPT
+        error = hal_gpt_set_pte( &vmm->gpt , vpn , new_ppn , new_attr );
+        if( error )
+        // build new_attr : reset COW and set WRITABLE,
+        new_attr = (old_attr | GPT_WRITABLE) & (~GPT_COW);
+        // update GPT[vpn] for all GPT copies
+        // to maintain coherence of copies
+        vmm_update_pte( process,
+                        vpn,
+                        new_attr,
+                        new_ppn );
+        // decrement fork_nr in page descriptor
+        hal_remote_atomic_add( XPTR( page_cxy , &page_ptr->fork_nr ) , -1 );
+    }
+    else                         /////////////// page_fault request ///////////
+    {
+        if( (old_attr & GPT_MAPPED) == 0 )   // true page_fault => map it
+        {
+            printk("\n[ERROR] in %s : cannot update GPT / process = %x / vpn = %x\n",
+            __FUNCTION__ , process->pid , vpn );
+            return error;
+        }
+    }
+    else                    //////////////////// page_fault request ///////////
+    {
+        if( (old_attr & GPT_MAPPED) == 0 )    // PTE unmapped in ref GPT
+        {
+vmm_dmsg("\n[DBG] %s : core[%x,%d] page %x unmapped => try to map it\n",
+excp_dmsg("\n[DBG] %s : core[%x,%d] handling page fault for vpn %x\n",
 __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn );
             // allocate one physical page, depending on vseg type
+            // allocate new_ppn, depending on vseg type
             error = vmm_get_one_ppn( vseg , vpn , &new_ppn );
             if( error )
+            {
                 printk("\n[ERROR] in %s : no memory / process = %x / vpn = %x\n",
                 __FUNCTION__ , process->pid , vpn );
                 return error;
+                return -1;
+            }
             // define attributes from vseg flags
+            // define new_attr from vseg flags
             new_attr = GPT_MAPPED | GPT_SMALL;
             if( vseg->flags & VSEG_USER  ) new_attr |= GPT_USER;
 …
             if( vseg->flags & VSEG_CACHE ) new_attr |= GPT_CACHABLE;
+            // register PTE in GPT
+            error = hal_gpt_set_pte( &vmm->gpt , vpn , new_ppn , new_attr );
+            // register new PTE in reference GPT
+            // on demand policy => no update of GPT copies
+            error = hal_gpt_set_pte( &vmm->gpt,
+                                     vpn,
+                                     new_attr,
+                                     new_ppn );
             if( error )
+            {
                 printk("\n[ERROR] in %s : cannot update GPT / process = %x / vpn = %x\n",
                 __FUNCTION__ , process->pid , vpn );
                 return error;
+                return -1;
+            }
+        }
         else
+        else                                  // mapped in reference GPT => get it
+        {
+            new_ppn  = old_ppn;
             new_attr = old_attr;
-            new_ppn  = old_ppn;
+        }
+    }
 vmm_dmsg("\n[DBG] %s : core[%x,%d] exit for vpn = %x / ppn = %x / attr = %x\n",
+excp_dmsg("\n[DBG] %s : core[%x,%d] update GPT for vpn %x / ppn = %x / attr = %x\n",
 __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn , new_ppn , new_attr );
+    // retur success
     *ppn  = new_ppn;
     *attr = new_attr;
 …
         // update local GPT
+        error |= hal_gpt_set_pte( &vmm->gpt , vpn , ppn , attr );
+        error |= hal_gpt_set_pte( &vmm->gpt,
+                                  vpn,
+                                  attr,
+                                  ppn );
+    }
     else   // local cluster is the reference cluster
 …
 }  // end vmm_handle_page_fault()
 ///////////////////////////////////////////////
 error_t vmm_copy_on_write( process_t * process,
                            vpn_t       vpn )
+////////////////////////////////////////////
+error_t vmm_handle_cow( process_t * process,
+                        vpn_t       vpn )
+{
     uint32_t         attr;          // missing page attributes
 …
         // update local GPT
+        error |= hal_gpt_set_pte( &vmm->gpt , vpn , ppn , attr );
+        error |= hal_gpt_set_pte( &vmm->gpt,
+                                  vpn,
+                                  attr,
+                                  ppn );
+    }
     else   // local cluster is the reference cluster
 …
     return error;
 }  // end vmm_copy_on_write()
+}  // end vmm_handle_cow()
 ///////////////////////////////////////////

trunk/kernel/mm/vmm.h

-                      r407
+                      r408
 /*********************************************************************************************
  * This structure defines the Virtual Memory Manager for a given process in a given cluster.
+ * This local VMM provides three main services:
+ * 1) It registers all vsegs statically or dynamically defined in the vseg list.
+ * 2) It allocates virtual memory space for the STACKS and MMAP vsegs (FILE/ANON/REMOTE).
+ * 3) It contains the local copy of the generic page table descriptor.
+ * This local VMM provides four main services:
+ * 1) It registers all vsegs in the local copy of the vseg list (VSL).
+ * 2) It contains the local copy of the generic page table (GPT).
+ * 3) The stack manager dynamically allocates virtual memory space for the STACK vsegs.
+ * 4) The mmap manager dynamically allocates virtual memory for the (FILE/ANON/REMOTE) vsegs.
+ ******************************************************a**************************************
+ * Implementation notes:
+ * 1. The VSL contains only local vsegs, but it is implemented as an xlist, and protected by
+ *    a remote_rwlock, because it can be accessed by a thread running in a remote cluster.
+ *    An exemple is the vmm_fork_copy() function.
+ * 2. In most custers, the VSL and GPT are only partial copies of the reference VSL and GPT
+ *    structures, stored in the reference cluster.
  ********************************************************************************************/
 typedef struct vmm_s
+{
+        rwlock_t       vsegs_lock;         /*! lock protecting the vsegs list                   */
+        list_entry_t   vsegs_root;         /*! all vsegs in same process and same cluster       */
+        uint32_t       vsegs_nr;           /*! total number of local vsegs                      */
+    gpt_t          gpt;                /*! embedded generic page table descriptor           */
+    stack_mgr_t    stack_mgr;          /*! embedded STACK vsegs allocator                   */
+    mmap_mgr_t     mmap_mgr;           /*! embedded MMAP vsegs allocator                    */
+        uint32_t       pgfault_nr;         /*! page fault counter (instrumentation)             */
+        uint32_t       u_err_nr;           /*! TODO ??? [AG]                                    */
+        uint32_t       m_err_nr;           /*! TODO ??? [AG]                                    */
+    vpn_t          kent_vpn_base;      /*! kentry vseg first page                           */
+    vpn_t          args_vpn_base;      /*! args vseg first page                             */
+    vpn_t          envs_vpn_base;      /*! envs zone first page                             */
+    vpn_t          heap_vpn_base;      /*! envs zone first page                             */
+        vpn_t          code_vpn_base;      /*! code zone first page                             */
+        vpn_t          data_vpn_base;      /*! data zone first page                             */
+        intptr_t       entry_point;        /*! main thread entry point                          */
+        remote_rwlock_t  vsegs_lock;         /*! lock protecting the vsegs list                 */
+        xlist_entry_t    vsegs_root;         /*! VSL root (VSL only complete in reference)      */
+        uint32_t         vsegs_nr;           /*! total number of local vsegs                    */
+    gpt_t            gpt;                /*! Generic Page Table (complete in reference)     */
+    stack_mgr_t      stack_mgr;          /*! embedded STACK vsegs allocator                 */
+    mmap_mgr_t       mmap_mgr;           /*! embedded MMAP vsegs allocator                  */
+        uint32_t         pgfault_nr;         /*! page fault counter (instrumentation)           */
+    vpn_t            kent_vpn_base;      /*! kentry vseg first page                         */
+    vpn_t            args_vpn_base;      /*! args vseg first page                           */
+    vpn_t            envs_vpn_base;      /*! envs zone first page                           */
+    vpn_t            heap_vpn_base;      /*! envs zone first page                           */
+        vpn_t            code_vpn_base;      /*! code zone first page                           */
+        vpn_t            data_vpn_base;      /*! data zone first page                           */
+        intptr_t         entry_point;        /*! main thread entry point                        */
+}
 vmm_t;
 …
 /*********************************************************************************************
+ * This function is called by the sys_fork() system call.
+ * It copies the content of a parent process descriptor VMM to a child process VMM.
+ * - All vsegs registered in the source VSL are copied in the destination VSL.
+ * - All PTEs registered in the source GPT are copied in destination GPT. For all writable
+ *   PTEs - but the FILE vsegs - the WRITABLE flag is reset and the COW flag is set in
+ *   the destination GPT.
+ *********************************************************************************************
+ * @ dst_process   : pointer on destination process descriptor.
+ * @ src_process   : pointer on source process descriptor.
+ * This function is called by the process_fork_create() function. It partially copies
+ * the content of a remote parent process VMM to the local child process VMM:
+ * - all DATA, MMAP, REMOTE vsegs registered in the parent VSL are registered in the child
+ *   VSL, and all valid GPT entries in parent GPT are copied to the child GPT.
+ *   The WRITABLE flag is reset and the COW flag is set in child GPT.
+ * - all CODE vsegs registered in the parent VSL are registered in the child VSL, but the
+ *   GPT entries are not copied in the chilf GPT, that will be dynamically updated from
+ *   the .elf file when a page fault is reported.
+ * - all FILE vsegs registered in the parent VSL are registered in the child VSL, and all
+ *   valid GPT entries in parent GPT are copied to the child GPT. The COW flag is not set.
+ * - no STACK vseg is copied from  parent VMM to child VMM, because the child STACK vseg
+ *   must be copied from the cluster containing the user thread requesting the fork().
+ *********************************************************************************************
+ * @ child_process     : local pointer on local child process descriptor.
+ * @ parent_process_xp : extended pointer on remote parent 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.
+error_t vmm_fork_copy( struct process_s * child_process,
+                       xptr_t             parent_process_xp );
+/*********************************************************************************************
+ * This function is called by the process_make_fork() function to handle the fork syscall.
+ * It set the COW flag, and reset the WRITABLE flag of all GPT entries of the DATA, MMAP,
+ * and REMOTE vsegs of a process identified by the <process> argument.
+ * It must be called by a thread running in the reference cluster, that contains the complete
+ * list of vsegs. Use the rpc_vmm_set_cow_client() when the calling thread client is remote.
+ * It updates all copies of the process in all clusters, to maintain coherence in GPT copies,
+ * using the list of copies stored in the owner process, and using remote_write accesses to
+ * update the remote GPTs. It cannot fail, as only mapped entries in GPT copies are updated.
+ *********************************************************************************************
+ * @ process   : local pointer on local reference process descriptor.
+ ********************************************************************************************/
+void vmm_set_cow( struct process_s * process );
+/*********************************************************************************************
+ * This function is called by the vmm_get_pte() function in case of COW exception.
+ * It modifies both the PPN an the attributes for a GPT entry identified by the <process>
+ * and <vpn> arguments.
+ * It updates all copies of the process in all clusters, to maintain coherence in GPT copies,
+ * using the list of copies stored in the owner process, and using remote_write accesses to
+ * update the remote GPTs. It cannot fail, as only mapped entries in GPT copies are updated.
+ *********************************************************************************************
+ * @ process   : local pointer on local process descriptor.
+ * @ vpn       : PTE index.
+ * @ attr      : PTE / attributes.
+ * @ ppn       : PTE / physical page index.
+ ********************************************************************************************/
+void vmm_update_pte( struct process_s * process,
+                     vpn_t              vpn,
+                     uint32_t           attr,
+                     ppn_t              ppn );
+/*********************************************************************************************
+ * This function removes all vsegs registered in in the virtual memory manager of the
+ * process identified by the <process> argument.
+ * It releases the memory allocated to the local generic page table.
  *********************************************************************************************
  * @ process   : pointer on process descriptor.
 …
  * @ returns 0 if success / returns ENOMEM if no memory.
  ********************************************************************************************/
 error_t vmm_copy_on_write( struct process_s * process,
                            vpn_t              vpn );
+error_t vmm_handle_cow( struct process_s * process,
+                        vpn_t              vpn );
 /*********************************************************************************************

trunk/kernel/mm/vseg.c

-                      r407
+                      r408
     // add vseg in vmm list
+    list_add_last( &vmm->vsegs_root , &vseg->list );
+    xlist_add_last( XPTR( local_cxy , &vmm->vsegs_root ),
+                    XPTR( local_cxy , &vseg->xlist ) );
+}
 …
     // remove vseg from vmm list
     list_unlink( &vseg->list );
+}
+    xlist_unlink( XPTR( local_cxy , &vseg->xlist ) );
+}

trunk/kernel/mm/vseg.h

-                      r407
+                      r408
 /**********************************************************************************************
  * This structure defines a virtual segment descriptor.
+ * - The VSL contains only local vsegs, but is implemented as an xlist, because it can be
+ *   accessed by thread running in a remote cluster.
+ * - The zombi list is used by the local MMAP allocator. It is implemented as a local list.
  *********************************************************************************************/
 typedef struct vseg_s
+{
+        list_entry_t      list;         /*! all vsegs in same process / same free list if mmap   */
+        xlist_entry_t     xlist;        /*! all vsegs in same VSL (or same zombi list)           */
+        list_entry_t      zlist;        /*! all vsegs in same zombi list                         */
         struct vmm_s    * vmm;          /*! pointer on associated VM manager                     */
     uint32_t          type;         /*! vseg type                                            */

trunk/kernel/syscalls/sys_exec.c

-                      r407
+                      r408
 // Implementation note:
 // This function build an exec_info_t structure containing all informations
+// required to create the new process descriptor and the associated thread.
+// required to initialize the new process descriptor and the associated thread.
+// It includes the process PID (unchanged), main() arguments, environment variables,
+// and the pathname to the new process .elf file.
 // It calls the process_exec_get_strings() functions to copy the main() arguments and
 // the environment variables from user buffers to the exec_info_t structure, allocate
 // and call the process_make_exec() function.
+// Finally, it destroys the calling thread and process.
+// As it must destroy all parent process copies, and all parent threads in all clusters,
+// the process_make_exec() function must be executed in the parent owner cluster,
+// and this sys_exec() function uses a RPC to access the owner cluster if required.
+//
 // TODO : the args & envs arguments are not supported yet : both must be NULL
 /////////////////////////////////////////////////////////////////////////////////////////
 …
         tm_start = hal_get_cycles();
     // get pointers on parent process and thread
+    // get parent process pid
     thread_t   * this    = CURRENT_THREAD;
     process_t  * process = this->process;
 …
 __FUNCTION__, local_cxy, this->core->lid, pid, (uint32_t)hal_get_cycles() );
+sched_display( 0 );
+    // get owner cluster
+    cxy_t  owner_cxy = CXY_FROM_PID( pid );
     // check pathname length
 …
     // copy pathname in exec_info structure (kernel space)
     hal_strcpy_from_uspace( exec_info.path , pathname , CONFIG_VFS_MAX_PATH_LENGTH );
     // check args argument
     assert( (args == NULL) , __FUNCTION__ ,
 …
     assert( (envs == NULL) , __FUNCTION__ ,
     "args not supported yet\n" );
-    // compute client_cxy (local cluster) and server_cxy (target cluster)
-    cxy_t     cxy_server = CXY_FROM_PID( pid );
-    cxy_t     cxy_client = local_cxy;
-    // register parent process in exec_info
-    exec_info.parent_xp   = process->ref_xp;
-    // new process keep the parent process PID
-    exec_info.keep_pid   = true;
     // check and store args in exec_info structure if required
 …
+    }
+    // register PID in exec_info
+    exec_info.pid = pid;
     // call process_make_exec (local or remote)
     if( cxy_server == cxy_client )
+    if( owner_cxy == local_cxy )
+    {
         error = process_make_exec( &exec_info );
 …
     else
+    {
+        rpc_process_exec_client( cxy_server , &exec_info , &error );
+        rpc_process_make_exec_client( owner_cxy,
+                                      &exec_info,
+                                      &error );
+    }
 …
+    {
         printk("\n[ERROR] in %s : cannot create new process %x in cluster %x\n",
         __FUNCTION__, pid, cxy_server );
+        __FUNCTION__, pid, owner_cxy );
         this->errno = error;
         return -1;
+    }
-    // FIXME delete the local process descriptor
-    // process_kill( process );
     tm_end = hal_get_cycles();

trunk/kernel/syscalls/sys_fork.c

-                      r407
+                      r408
 int sys_fork()
+{
+        process_t          * parent_process;  // pointer on parent process descriptor
+    pid_t                parent_pid;      // parent process identifier
+    thread_t           * parent_thread;   // pointer on parent thread descriptor
+        process_t          * child_process;   // pointer on child process descriptor
+    pid_t                child_pid;       // child process identifier
+        thread_t           * child_thread;    // pointer on child main thread descriptor
+    cxy_t                target_cxy;      // target cluster for forked child process
+        error_t              error;
+        process_t       * parent_process_ptr;   // pointer on local parent process descriptor
+    xptr_t            parent_thread_xp;     // extended pointer on parent thread descriptor
+    pid_t             parent_pid;           // parent process identifier
+    thread_t        * parent_thread_ptr;    // local pointer on local parent thread descriptor
+        uint64_t      tm_start;
+        uint64_t      tm_end;
+    pid_t             child_pid;            // child process identifier
+    thread_t        * child_thread_ptr;     // local pointer on remote child thread descriptor
+    cxy_t             target_cxy;           // target cluster for forked child process
+    xptr_t            ref_process_xp;       // extended pointer on reference parent process
+    cxy_t             ref_process_cxy;      // cluster of reference parent process
+    process_t       * ref_process_ptr;      // local pointer on reference parent process
+        error_t           error;
+        uint64_t          tm_start;
+        uint64_t          tm_end;
         tm_start = hal_get_cycles();
+    // get pointers on parent process and thread
+        parent_thread  = CURRENT_THREAD;
+        parent_process = parent_thread->process;
+    parent_pid     = parent_process->pid;
+    // get pointers on local parent process and thread
+        parent_thread_ptr  = CURRENT_THREAD;
+    parent_thread_xp   = XPTR( local_cxy , parent_thread_ptr );
+        parent_process_ptr = parent_thread_ptr->process;
+    parent_pid         = parent_process_ptr->pid;
 fork_dmsg("\n[DBG] %s : core[%x,%d] enters for process %x / cycle %d\n",
 __FUNCTION__ , local_cxy , parent_thread->core->lid , parent_pid , (uint32_t)tm_start );
+fork_dmsg("\n[DBG] %s : core[%x,%d] parent process %x enters / cycle %d\n",
+__FUNCTION__, local_cxy, parent_thread_ptr->core->lid, parent_pid, (uint32_t)tm_start );
+    // check parent process children number
+        if( hal_atomic_add( &parent_process->children_nr , 1 ) >= CONFIG_PROCESS_MAX_CHILDREN )
+    // get infos on reference process
+    ref_process_xp  = parent_process_ptr->ref_xp;
+    ref_process_cxy = GET_CXY( ref_process_xp );
+    ref_process_ptr = (process_t *)GET_PTR( ref_process_xp );
+    // check parent process children number from reference
+    xptr_t   children_xp = XPTR( ref_process_cxy , &ref_process_ptr->children_nr );
+    if( hal_remote_atomic_add( children_xp , 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;
+            hal_remote_atomic_add ( children_xp , -1 );
+        parent_thread_ptr->errno = EAGAIN;
+        return -1;
+        }
     // Select target cluster for future migration of child process and main thread.
+    // Select target cluster for child process and main thread.
     // 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 )
+        if( parent_thread_ptr->fork_user )    // user defined placement
+        {
+        // user defined placement
+        target_cxy = parent_thread->fork_cxy;
+        parent_thread->fork_user = false;
+        target_cxy = parent_thread_ptr->fork_cxy;
+        parent_thread_ptr->fork_user = false;
+        }
+    else if( (LPID_FROM_PID(parent_process->pid) < 2)  && (local_cxy == 0) )
+    {
+        // 2 first process stay in boot cluster
+        target_cxy = local_cxy;
+    }
+        else
+        else                                  // DQDT placement
+        {
-        // DQDT placement
                 target_cxy = dqdt_get_cluster_for_process();
+        }
+//printk("\n[DBG] %s : core[%x,%d] for process %x selects target_cluster = %x\n",
+//__FUNCTION__ , local_cxy , parent_thread->core->lid , parent_pid , target_cxy );
+    // allocates memory in local cluster for the child process descriptor
+        child_process = process_alloc();
+        if( child_process == NULL )
+        {
+            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
+    // call process_make_fork in target cluster
+    if( target_cxy == local_cxy )
+    {
+        error = cluster_pid_alloc( XPTR( target_cxy , child_process ) , &child_pid );
+        error = process_make_fork( ref_process_xp,
+                                   parent_thread_xp,
+                                   &child_pid,
+                                   &child_thread_ptr );
+    }
     else                                         // target cluster is remote
+    else
+    {
+        rpc_process_pid_alloc_client( target_cxy , child_process , &error , &child_pid );
+        rpc_process_make_fork_client( target_cxy,
+                                      ref_process_xp,
+                                      parent_thread_xp,
+                                      &child_pid,
+                                      &child_thread_ptr,
+                                      &error );
+    }
     if( error )
+    {
+            printk("\n[ERROR] in %s : cannot allocate PID\n", __FUNCTION__ );
             hal_atomic_add ( &parent_process->children_nr , -1 );
         process_destroy( child_process );
         return EAGAIN;
+        printk("\n[ERROR] in %s : cannot fork process %x in cluster %x\n",
+        __FUNCTION__, parent_pid, local_cxy );
+        parent_thread_ptr->errno = EAGAIN;
+        return -1;
+    }
+    // initialize and register the child process descriptor
+    process_reference_init( child_process , child_pid , XPTR(local_cxy, parent_process) );
+    // initialises child process standard files structures
+    // ( root / cwd / bin ) from parent process descriptor
+        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 ) );
+//printk("\n[DBG] %s : core[%x,%d] for process %x created child process %x\n",
+//__FUNCTION__ , local_cxy , parent_thread->core->lid , parent_pid , child_pid );
+    // replicate VMM
+        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;
+    }
+//printk("\n[DBG] %s : core[%x,%d] for process %x duplicated vmm in child process\n",
+//__FUNCTION__ , local_cxy , parent_thread->core->lid , parent_pid );
+//vmm_display( parent_process , true );
+//vmm_display( child_process , true );
+    // create child main thread in local cluster
+    error = thread_user_fork( child_process,
+                              parent_thread->u_stack_size,
+                              parent_thread->u_stack_base,
+                              &child_thread );
+        if( error )
+    {
+            printk("\n[ERROR] in %s : cannot duplicate main thread\n", __FUNCTION__ );
+            hal_atomic_add( &parent_process->children_nr , -1 );
+        process_destroy( child_process );
+        return ENOMEM;
+    }
+//printk("\n[DBG] %s : core[%x,%d] initialised child main thread\n",
+//__FUNCTION__ , local_cxy , parent_thread->core->lid );
+        // update DQDT for the child thread
+    dqdt_local_update_threads( 1 );
+    // set child_thread FPU_context from parent_thread register values
+    // only when the parent process is the FPU owner
+        if( CURRENT_THREAD->core->fpu_owner == parent_thread )
+    // set remote child FPU_context from parent_thread register values
+    // only when the parent thread is the FPU owner
+        if( CURRENT_THREAD->core->fpu_owner == parent_thread_ptr )
+        {
                 hal_fpu_context_save( child_thread->fpu_context );
+                hal_fpu_context_save( XPTR( target_cxy , child_thread_ptr ) );
+        }
+    // set child_thread CPU context from parent_thread register values
+    hal_do_cpu_save( child_thread->cpu_context,
+                     child_thread,
+                     (int)((intptr_t)child_thread - (intptr_t)parent_thread) );
+    // set remote child CPU context from  parent_thread register values
+    hal_cpu_context_fork( XPTR( target_cxy , child_thread_ptr ) );
+    // from this point, both parent and child threads execute the following code
+    // but child execute it only when it has been unblocked by its parent
+    // From this point, both parent and child threads execute the following code.
+    // They can be distinguished by the CURRENT_THREAD value, and child will only
+    // execute it when it is unblocked by parent.
+    // - parent unblock child, and return child PID to user application.
+    // - child thread does nothing, and return 0 to user pplication
     thread_t * current = CURRENT_THREAD;
     if( current == parent_thread )
+    if( current == parent_thread_ptr )    // current == parent thread
+    {
         // parent_thread unblock child_thread
         thread_unblock( XPTR( local_cxy , child_thread ) , THREAD_BLOCKED_GLOBAL );
+        thread_unblock( XPTR( target_cxy , child_thread_ptr ) , THREAD_BLOCKED_GLOBAL );
         tm_end = hal_get_cycles();
 …
 fork_dmsg("\n[DBG] %s : core[%x,%d] parent_process %x exit / cycle %d\n"
 "     child_process %x / child_thread = %x / cost = %d\n",
 __FUNCTION__, local_cxy, parent_thread->core->lid,  parent_pid, (uint32_t)tm_start,
 child_pid, child_thread->trdid , (uint32_t)(tm_end - tm_start) );
+__FUNCTION__, local_cxy, parent_thread_ptr->core->lid,  parent_pid, (uint32_t)tm_end,
+child_pid, child_thread_ptr->trdid , (uint32_t)(tm_end - tm_start) );
         return child_pid;
+    }
         else  // current == child_thread
+        else                                   // current == child_thread
+    {
+        assert( (current == child_thread) , __FUNCTION__ ,
         "current thread %x is not the child thread %x\n", current , child_thread );
+        tm_end = hal_get_cycles();
 fork_dmsg("\n[DBG] %s : core[%x,%d] child process %x exit / cycle %d\n",
 __FUNCTION__, local_cxy, parent_thread->core->lid, child_pid, (uint32_t)hal_get_cycles() );
+__FUNCTION__, local_cxy, parent_thread_ptr->core->lid, child_pid, (uint32_t)tm_end );
         return 0;

trunk/kernel/syscalls/sys_get_cycle.c

r407	r408
48	48	{
49	49	printk("\n[ERROR] in %s : user buffer unmapped for thread %x in process %x\n",
50		__FUNCTION__ , this->trdid , process->pid );
	50	__FUNCTION__ , this->trdid , process->pid );
51	51	this->errno = EFAULT;
52	52	return -1;

trunk/kernel/syscalls/sys_read.c

-                      r407
+                      r408
         xptr_t       file_xp;     // remote file extended pointer
     uint32_t     nbytes;      // number of bytes actually read
+    reg_t        save_sr;     // required to enable IRQs during syscall
         uint32_t     tm_start;
         uint32_t     tm_end;
 …
                 return -1;
+    }
+    // enable IRQs
+    hal_enable_irq( &save_sr );
     // get extended pointer on remote file descriptor
 …
         return -1;
+    }
+    // restore IRQs
+    hal_restore_irq( save_sr );
     hal_fence();
 …
 #endif
 syscall_dmsg("\n[DBG] %s : core[%x,%d] / thread %x / nbytes = %d / cycle %d\n"
 " first byte = %c / file_id = %d / cost = %d\n",
 __FUNCTION__ , local_cxy , this->core->lid , this->trdid , nbytes , tm_start ,
 *((char *)(intptr_t)paddr) , file_id , tm_end - tm_start );
+syscall_dmsg("\n[DBG] %s : core[%x,%d] / thread %x in process %x / cycle %d\n"
+"nbytes = %d / first byte = %c / file_id = %d / cost = %d\n",
+__FUNCTION__ , local_cxy , this->core->lid , this->trdid , this->process->pid ,
+tm_start , nbytes , *((char *)(intptr_t)paddr) , file_id , tm_end - tm_start );
         return nbytes;

trunk/kernel/syscalls/sys_signal.c

-                      r407
+                      r408
                 void     * handler )
+{
         thread_t  * this = CURRENT_THREAD;
+        thread_t  * this    = CURRENT_THREAD;
+    printk("\n[ERROR] in %s : not implemented yet\n", __FUNCTION__ );
+    this->errno = EINVAL;
+    return -1;
         if((sig_id == 0) || (sig_id >= SIG_NR) || (sig_id == SIGKILL) || (sig_id == SIGSTOP))
+        {

trunk/kernel/syscalls/sys_thread_exit.c

r407	r408
73	73
74	74	// deschedule
75		sched_yield();
	75	sched_yield("waiting parent join");
76	76	}
77	77	}

trunk/kernel/syscalls/sys_thread_join.c

r407	r408
138	138
139	139	// deschedule
140		sched_yield();
	140	sched_yield("waiting child exit");
141	141	}
142	142	}

trunk/kernel/syscalls/sys_thread_sleep.c

r407	r408
36	36
37	37	thread_block( this , THREAD_BLOCKED_GLOBAL );
38		sched_yield();
	38	sched_yield("blocked on sleep");
39	39
40	40	thread_dmsg("\n[DBG] %s : thread %x in process %x resume at cycle\n",

trunk/kernel/syscalls/sys_thread_yield.c

r407	r408
27	27	int sys_thread_yield()
28	28	{
29		sched_yield();
	29	sched_yield("user request");
30	30	return 0;
31	31	}

trunk/kernel/syscalls/sys_write.c

-                      r407
+                      r408
+{
     error_t      error;
     paddr_t      paddr;                // unused, but required for user space checking
         xptr_t       file_xp;              // remote file extended pointer
     uint32_t     nbytes;               // number of bytes actually written
+    paddr_t      paddr;           // unused, but required for user space checking
+        xptr_t       file_xp;         // remote file extended pointer
+    uint32_t     nbytes;          // number of bytes actually written
+    reg_t        save_sr;         // required to enable IRQs during syscall
         uint32_t     tm_start;
         uint32_t     tm_end;
 …
                 return -1;
+    }
+    // enable IRQs
+    hal_enable_irq( &save_sr );
     // get extended pointer on remote file descriptor
 …
+    }
+    // restore IRQs
+    hal_restore_irq( save_sr );
     hal_fence();
     tm_end = hal_get_cycles();
 syscall_dmsg("\n[DBG] %s : core[%x,%d] / thread %x / nbytes = %d / cycle %d\n"
 " first byte = %c / file_id = %d / cost = %d\n",
 __FUNCTION__ , local_cxy , this->core->lid , this->trdid , nbytes , tm_start ,
 *((char *)(intptr_t)paddr) , file_id , tm_end - tm_start );
+syscall_dmsg("\n[DBG] %s : core[%x,%d] / thread %x in process %x / cycle %d\n"
+"nbytes = %d / first byte = %c / file_id = %d / cost = %d\n",
+__FUNCTION__ , local_cxy , this->core->lid , this->trdid , this->process->pid ,
+tm_start , nbytes , *((char *)(intptr_t)paddr) , file_id , tm_end - tm_start );
         return nbytes;

trunk/kernel/syscalls/syscalls.h

-                      r407
+                      r408
  * terminating thread.
  ******************************************************************************************
  * @ exit_vallue  : pointer to be returned to parent thread if thead is attached.
+ * @ exit_vallue  : pointer to be returned to parent thread if thread is attached.
  * @ return 0 if success / return -1 if failure.
  *****************************************************************************************/
 …
 /******************************************************************************************
+ * [10] This slot not allocated yet
+ ******************************************************************************************
+ * @ return 0 if success / returns -1 if failure.
+ *****************************************************************************************/
+/******************************************************************************************
+ * [11] This function rmove an existing mapping defined by the <addr> and <size>
+ * [10] This function implement the exit system call terminating a POSIX process.
+ ******************************************************************************************
+ * @ status   : terminaison status (not used in present implementation).
+ *****************************************************************************************/
+void sys_exit( uint32_t status );
+/******************************************************************************************
+ * [11] This function remove an existing mapping defined by the <addr> and <size>
  * arguments in user space.
  ******************************************************************************************
 …
  * [14] This function read bytes from an open file identified by its file descriptor.
  * The file can be a regular file or character oriented device.
+ * IRQs are enabled during this system call.
  ******************************************************************************************
  * @ file_id  : open file index in fd_array.
 …
  * [15] This function writes bytes to an open file identified by its file descriptor.
  * The file can be a regular file or character oriented device.
+ * IRQs are enabled during this system call.
  ******************************************************************************************
  * @ file_id  : open file index in fd_array.

Context Navigation

Legend:

Download in other formats: