Changeset 443 for trunk/kernel

Timestamp:

May 16, 2018, 4:15:22 PM (7 years ago)

Author:

alain

Message:

Fix few bugs whike debugging the sort multi-thread application.

Location:

trunk/kernel

Files:

• kern/cluster.c (modified) (8 diffs)
• kern/cluster.h (modified) (4 diffs)
• kern/core.c (modified) (3 diffs)
• kern/core.h (modified) (1 diff)
• kern/do_syscall.c (modified) (2 diffs)
• kern/kernel_init.c (modified) (3 diffs)
• kern/printk.c (modified) (1 diff)
• kern/process.c (modified) (17 diffs)
• kern/process.h (modified) (8 diffs)
• kern/scheduler.c (modified) (11 diffs)
• kern/scheduler.h (modified) (1 diff)
• kern/thread.c (modified) (15 diffs)
• kern/thread.h (modified) (4 diffs)
• kernel_config.h (modified) (7 diffs)
• libk/remote_spinlock.c (modified) (2 diffs)
• mm/vmm.c (modified) (6 diffs)
• syscalls/sys_display.c (modified) (4 diffs)
• syscalls/sys_exit.c (modified) (3 diffs)
• syscalls/sys_fg.c (modified) (2 diffs)
• syscalls/sys_read.c (modified) (2 diffs)
• syscalls/sys_thread_cancel.c (modified) (5 diffs)
• syscalls/sys_trace.c (modified) (2 diffs)
• syscalls/sys_wait.c (modified) (3 diffs)
• syscalls/sys_write.c (modified) (5 diffs)
• syscalls/syscalls.h (modified) (2 diffs)

trunk/kernel/kern/cluster.c

@@ -34 +34 @@
 #include <spinlock.h>
 #include <core.h>
+#include <chdev.h>
 #include <scheduler.h>
 #include <list.h>
@@ -49 +50 @@
 /////////////////////////////////////////////////////////////////////////////////////
 
-extern process_t process_zero;     // allocated in kernel_init.c file
-
-
-/////////////////////////////////////////////////
+extern process_t           process_zero;     // allocated in kernel_init.c file
+extern chdev_directory_t   chdev_dir;        // allocated in kernel_init.c file
+
+///////////////////////////////////////////////n
 error_t cluster_init( struct boot_info_s * info )
 {
@@ -252 +253 @@
 
 //////////////////////////////////////////////////////
+xptr_t cluster_get_process_from_pid_in_cxy( cxy_t cxy,
+                                            pid_t pid )
+{
+    xptr_t      root_xp;       // xptr on root of list of processes in owner cluster
+    xptr_t      lock_xp;       // xptr on lock protecting this list
+    xptr_t      iter_xp;       // iterator
+    xptr_t      current_xp;    // xptr on current process descriptor
+    bool_t      found;
+
+    cluster_t * cluster = LOCAL_CLUSTER;
+
+    // get owner cluster and lpid
+    cxy_t   owner_cxy = CXY_FROM_PID( pid );
+    lpid_t  lpid      = LPID_FROM_PID( pid );
+
+    // get lock & root of list of copies from owner cluster
+    root_xp = XPTR( owner_cxy , &cluster->pmgr.copies_root[lpid] );
+    lock_xp = XPTR( owner_cxy , &cluster->pmgr.copies_lock[lpid] );
+
+    // take the lock protecting the list of processes
+    remote_spinlock_lock( lock_xp );
+
+    // scan list of processes
+    found = false;
+    XLIST_FOREACH( root_xp , iter_xp )
+    {
+        current_xp  = XLIST_ELEMENT( iter_xp , process_t , copies_list );
+
+        if( GET_CXY( current_xp ) == cxy )
+        {
+            found = true;
+            break;
+        }
+    }
+
+    // release the lock protecting the list of processes
+    remote_spinlock_unlock( lock_xp );
+
+    // return extended pointer on process descriptor in owner cluster
+    if( found ) return current_xp;
+    else        return XPTR_NULL;
+
+}  // end cluster_get_process_from_pid_in_cxy()
+
+
+//////////////////////////////////////////////////////
 xptr_t cluster_get_owner_process_from_pid( pid_t pid )
 {
@@ -298 +345 @@
 }  // end cluster_get_owner_process_from_pid()
 
+
 //////////////////////////////////////////////////////////
 xptr_t cluster_get_reference_process_from_pid( pid_t pid )
@@ -459 +507 @@
 void cluster_process_local_link( process_t * process )
 {
-    uint32_t irq_state;
+    reg_t    save_sr;
+
     pmgr_t * pm = &LOCAL_CLUSTER->pmgr;
 
+    // get extended pointers on local process list root & lock
+    xptr_t root_xp = XPTR( local_cxy , &pm->local_root );
+    xptr_t lock_xp = XPTR( local_cxy , &pm->local_lock );
+
     // get lock protecting the process manager local list
-    remote_spinlock_lock_busy( XPTR( local_cxy , &pm->local_lock ) , & irq_state );
-
-    xlist_add_last( XPTR( local_cxy , &pm->local_root ),
-                    XPTR( local_cxy , &process->local_list ) );
+    remote_spinlock_lock_busy( lock_xp , &save_sr );
+
+    // register process in local list
+    xlist_add_last( root_xp , XPTR( local_cxy , &process->local_list ) );
     pm->local_nr++;
 
     // release lock protecting the process manager local list
-    remote_spinlock_unlock_busy( XPTR( local_cxy , &pm->local_lock ) , irq_state );
+    remote_spinlock_unlock_busy( lock_xp , save_sr );
 }
 
@@ -476 +529 @@
 void cluster_process_local_unlink( process_t * process )
 {
-    uint32_t irq_state;
+    reg_t save_sr;
+
     pmgr_t * pm = &LOCAL_CLUSTER->pmgr;
 
+    // get extended pointers on local process list lock
+    xptr_t lock_xp = XPTR( local_cxy , &pm->local_lock );
+
     // get lock protecting the process manager local list
-    remote_spinlock_lock_busy( XPTR( local_cxy , &pm->local_lock ) , &irq_state );
-
+    remote_spinlock_lock_busy( lock_xp , &save_sr );
+
+    // remove process from local list
     xlist_unlink( XPTR( local_cxy , &process->local_list ) );
     pm->local_nr--;
 
     // release lock protecting the process manager local list
-    remote_spinlock_unlock_busy( XPTR( local_cxy , &pm->local_lock ) , irq_state );
+    remote_spinlock_unlock_busy( lock_xp , save_sr );
 }
 
@@ -582 +640 @@
 {
     xptr_t        root_xp;
+    xptr_t        lock_xp;
     xptr_t        iter_xp;
-    xptr_t        process_xp;     
-
-    // get extended pointer on root of process in cluster cxy
+    xptr_t        process_xp;
+    cxy_t         txt0_cxy;
+    chdev_t     * txt0_ptr;
+    xptr_t        txt0_xp;
+    xptr_t        txt0_lock_xp;
+    reg_t         txt0_save_sr;     // save SR to take TXT0 lock in busy mode      
+
+    assert( (cluster_is_undefined( cxy ) == false),
+    __FUNCTION__, "illegal cluster index" );
+
+    // get extended pointer on root and lock for local process list in cluster
     root_xp = XPTR( cxy , &LOCAL_CLUSTER->pmgr.local_root );
-
-    // skip one line
-    printk("\n***** processes in cluster %x / cycle %d\n", cxy , (uint32_t)hal_get_cycles() );
-
-    // loop on all reference processes in cluster cxy 
+    lock_xp = XPTR( cxy , &LOCAL_CLUSTER->pmgr.local_lock );
+
+    // get pointers on TXT0 chdev
+    txt0_xp  = chdev_dir.txt_tx[0];
+    txt0_cxy = GET_CXY( txt0_xp );
+    txt0_ptr = GET_PTR( txt0_xp );
+
+    // get extended pointer on TXT0 lock
+    txt0_lock_xp = XPTR( txt0_cxy , &txt0_ptr->wait_lock );
+
+    // get lock on local process list 
+    remote_spinlock_lock( lock_xp );
+
+    // get TXT0 lock in busy waiting mode
+    remote_spinlock_lock_busy( txt0_lock_xp , &txt0_save_sr );
+     
+    // display header
+    nolock_printk("\n***** processes in cluster %x / cycle %d\n",
+    cxy , (uint32_t)hal_get_cycles() );
+
+    // loop on all processes in cluster cxy 
     XLIST_FOREACH( root_xp , iter_xp )
     {
@@ -597 +680 @@
         process_display( process_xp );
     }
+
+    // release TXT0 lock in busy waiting mode
+    remote_spinlock_unlock_busy( txt0_lock_xp , txt0_save_sr );
+
+    // release lock on local process list
+    remote_spinlock_unlock( lock_xp );
+
 }  // end cluster_processes_display() 
 

trunk/kernel/kern/cluster.h

@@ -61 +61 @@
  * Warning : the "owner" cluster, and the "reference" cluster can be different clusters.
  *
- * The process manager of a cluster K maintains three structures:
- * 1) The pref_tbl[] is an array indexed by lpid. There is one entry per owned process.
+ * The process manager of a cluster K maintains three sets of process descriptors:
+ *
+ * 1) pref_tbl[] is an array indexed by lpid. There is one entry per owned process.
  *    Each entry contains an extended pointer on the reference process descriptor.
  *
- * 2) The local_root is the root of the local list of process descriptors in cluster K.
+ * 2) The local_root is the root of the local list of all process descriptors in cluster K.
  *    A process descriptor P is present in K, as soon as P has a thread in cluster K.
  *
@@ -187 +188 @@
 /******************************************************************************************
  * This function returns an extended pointer on the process descriptor in owner cluster
- * from the process PID. This PID can be be different from the calling process PID.
+ * from the process <pid>. This PID can be be different from the calling process PID.
  * It can be called by any thread running in any cluster,
  ******************************************************************************************
@@ -197 +198 @@
 /******************************************************************************************
  * This function returns an extended pointer on the reference process descriptor
- * from the process PID. This PID can be be different from the calling process PID.
+ * from the process <pid>. This PID can be be different from the calling process PID.
  * It can be called by any thread running in any cluster,
  ******************************************************************************************
@@ -204 +205 @@
  *****************************************************************************************/
 xptr_t cluster_get_reference_process_from_pid( pid_t pid );
+
+/******************************************************************************************
+ * This function returns an extended pointer on the process descriptor copy for the
+ * process identified by <pid> in cluster defined by <cxy> argument.
+ * This PID can be be different from the calling process PID.
+ * It can be called by any thread running in any cluster,
+ ******************************************************************************************
+ * @ cxy  : target cluster identifier.
+ * @ pid  : process identifier.
+ * @ return extended pointer on reference process if found / XPTR_NULL if not found.
+ *****************************************************************************************/
+xptr_t cluster_get_process_from_pid_in_cxy( cxy_t cxy,
+                                            pid_t pid );
 
 /******************************************************************************************

trunk/kernel/kern/core.c

@@ -49 +49 @@
         core->usage             = 0;
         core->spurious_irqs     = 0;
-        core->thread_idle       = NULL;
         core->fpu_owner         = NULL;
         core->rand_last         = hal_time_stamp() & 0xFFF;
@@ -90 +89 @@
 void core_compute_stats( core_t * core )
 {
-        thread_t * idle  = core->thread_idle;
+        thread_t * idle  = core->scheduler.idle;
         uint32_t   ticks = core->ticks_nr;
 
@@ -115 +114 @@
 void core_reset_stats( core_t * core )
 {
-        core->ticks_nr              = 0;
-        core->usage                 = 0;
-        core->thread_idle->ticks_nr = 0;
+        thread_t * idle  = core->scheduler.idle;
+
+        core->ticks_nr = 0;
+        core->usage    = 0;
+        idle->ticks_nr = 0;
+
         hal_fence();
 }

trunk/kernel/kern/core.h

@@ -57 +57 @@
         uint32_t            usage;          /*! cumulated busy_percent (idle / total)      */
         uint32_t            spurious_irqs;  /*! for instrumentation...                     */
-        struct thread_s   * thread_idle;    /*! pointer on idle thread descriptor          */
         struct thread_s   * fpu_owner;      /*! pointer on current FPU owner thread        */
     uint32_t            rand_last;      /*! last computed random value                 */

trunk/kernel/kern/do_syscall.c

@@ -102 +102 @@
     sys_trace,              // 47
     sys_fg,                 // 48
+    sys_undefined,          // 49
 };
 
@@ -136 +137 @@
         else if( index == SYS_CLOSEDIR       ) return "CLOSEDIR";         // 25
         else if( index == SYS_GETCWD         ) return "GETCWD";           // 26
+        else if( index == SYS_ISATTY         ) return "ISATTY";           // 27
         else if( index == SYS_ALARM          ) return "ALARM";            // 28
         else if( index == SYS_RMDIR          ) return "RMDIR";            // 29

trunk/kernel/kern/kernel_init.c

@@ -59 +59 @@
 #include <mapper.h>
 
-#define KERNEL_INIT_SYNCHRO  0xA5A5B5B5
-
 ///////////////////////////////////////////////////////////////////////////////////////////
 // All the following global variables are replicated in all clusters.
@@ -912 +910 @@
 
 #if( DEBUG_KERNEL_INIT & 1 )
+if( (core_lid ==  0) & (local_cxy == 0) ) 
 chdev_dir_display();
 #endif
@@ -1179 +1178 @@
 printk("\n[DBG] %s : exit barrier 8 : process init created / cycle %d\n", 
 __FUNCTION__ , (uint32_t)hal_get_cycles() );
+#endif
+
+#if (DEBUG_KERNEL_INIT & 1)
+if( (core_lid ==  0) & (local_cxy == 0) ) 
+sched_display( 0 );
 #endif
 

trunk/kernel/kern/printk.c

@@ -350 +350 @@
 {
     va_list       args;
-    uint32_t      save_sr;
+    reg_t         save_sr;
 
     // get pointers on TXT0 chdev

trunk/kernel/kern/process.c

@@ -135 +135 @@
         process->pid        = pid;
     process->ref_xp     = XPTR( local_cxy , process );
+    process->owner_xp   = XPTR( local_cxy , process );
     process->parent_xp  = parent_xp;
     process->term_state = 0;
@@ -320 +321 @@
     local_process->parent_xp  = hal_remote_lwd( XPTR( ref_cxy , &ref_ptr->parent_xp ) );
     local_process->ref_xp     = reference_process_xp;
+    local_process->owner_xp   = reference_process_xp;
     local_process->term_state = 0;
 
@@ -409 +411 @@
     cluster_process_copies_unlink( process );
 
-    // remove process from children_list if process is in owner cluster
+    // remove process from children_list if process owner cluster
     if( CXY_FROM_PID( pid ) == local_cxy )
     {
@@ -426 +428 @@
     }
 
-    // release the process PID to cluster manager if owner cluster
+    // release the process PID to cluster manager if process owner cluster
     if( CXY_FROM_PID( pid ) == local_cxy ) cluster_pid_release( pid );
 
@@ -800 +802 @@
         // allocate memory for local process descriptor
         process_ptr = process_alloc();
+
         if( process_ptr == NULL )  return NULL;
 
         // initialize local process descriptor copy
         error = process_copy_init( process_ptr , ref_xp );
+
         if( error ) return NULL;
     }
@@ -1021 +1025 @@
     }
 
-
     // release lock protecting th_tbl
     hal_fence();
@@ -1030 +1033 @@
 }  // end process_register_thread()
 
-///////////////////////////////////////////////
-void process_remove_thread( thread_t * thread )
-{
+/////////////////////////////////////////////////
+bool_t process_remove_thread( thread_t * thread )
+{
+    uint32_t count;  // number of threads in local process descriptor
+
     assert( (thread != NULL) , __FUNCTION__ , "thread argument is NULL" );
 
@@ -1043 +1048 @@
     spinlock_lock( &process->th_lock );
 
-    assert( (process->th_nr) , __FUNCTION__ , "process th_nr cannot be 0\n" );
+    count = process->th_nr;
+
+    assert( (count > 0) , __FUNCTION__ , "process th_nr cannot be 0\n" );
 
     // remove thread from th_tbl[]
@@ -1049 +1056 @@
     process->th_nr--;
 
+    // release lock protecting th_tbl
     hal_fence();
-
-    // release lock protecting th_tbl
     spinlock_unlock( &process->th_lock );
+
+    return (count == 1);
 
 }  // process_remove_thread()
@@ -1401 +1409 @@
     process->pid        = 0;
     process->ref_xp     = XPTR( local_cxy , process );
+    process->owner_xp   = XPTR( local_cxy , process );
     process->parent_xp  = XPTR_NULL;
     process->term_state = 0;
@@ -1531 +1540 @@
     process_t   * process_ptr;
     cxy_t         process_cxy;
+
     xptr_t        parent_xp;       // extended pointer on parent process
     process_t   * parent_ptr;
     cxy_t         parent_cxy;
 
+    xptr_t        owner_xp;        // extended pointer on owner process
+    process_t   * owner_ptr;
+    cxy_t         owner_cxy;
+
     pid_t         pid;
     pid_t         ppid;
     uint32_t      state;
-    xptr_t        ref_xp; 
     uint32_t      th_nr;
 
-    xptr_t        txt_file_xp;     // extended pointer on TXT_RX pseudo file
-    xptr_t        chdev_xp;        // extended pointer on TXT_RX chdev
-    chdev_t     * chdev_ptr;
-    cxy_t         chdev_cxy;
-    xptr_t        owner_xp;        // extended pointer on TXT owner process 
+    xptr_t        txt_file_xp;     // extended pointer on TXT_RX file descriptor
+    xptr_t        txt_chdev_xp;    // extended pointer on TXT_RX chdev
+    chdev_t     * txt_chdev_ptr;
+    cxy_t         txt_chdev_cxy;
+    xptr_t        txt_owner_xp;    // extended pointer on TXT owner process 
 
     xptr_t        elf_file_xp;     // extended pointer on .elf file 
@@ -1558 +1571 @@
     process_ptr = GET_PTR( process_xp );
     process_cxy = GET_CXY( process_xp );
-
-    // check reference process
-    ref_xp = hal_remote_lwd( XPTR( process_cxy , &process_ptr->ref_xp ) );
-    assert( (process_xp == ref_xp) , __FUNCTION__ , "process is not the reference\n");
 
     // get PID and state
@@ -1576 +1585 @@
     th_nr      = hal_remote_lw( XPTR( process_cxy , &process_ptr->th_nr ) );
 
-    // get TXT name and process owner
-    txt_file_xp = hal_remote_lwd( XPTR( process_cxy , &process_ptr->fd_array.array[0] ) );
+    // get pointers on owner process descriptor
+    owner_xp  = hal_remote_lwd( XPTR( process_cxy , &process_ptr->owner_xp ) );
+    owner_cxy = GET_CXY( owner_xp );
+    owner_ptr = GET_PTR( owner_xp );
+
+    // get extended pointer on TXT_RX file descriptor attached to process
+    txt_file_xp = hal_remote_lwd( XPTR( owner_cxy , &owner_ptr->fd_array.array[0] ) );
 
     assert( (txt_file_xp != XPTR_NULL) , __FUNCTION__ , 
     "process must be attached to one TXT terminal\n" ); 
 
-    chdev_xp  = chdev_from_file( txt_file_xp );
-    chdev_cxy = GET_CXY( chdev_xp );
-    chdev_ptr = (chdev_t *)GET_PTR( chdev_xp );
+    // get TXT_RX chdev pointers
+    txt_chdev_xp  = chdev_from_file( txt_file_xp );
+    txt_chdev_cxy = GET_CXY( txt_chdev_xp );
+    txt_chdev_ptr = GET_PTR( txt_chdev_xp );
+
+    // get TXT_RX name and ownership
     hal_remote_strcpy( XPTR( local_cxy , txt_name ) ,
-                           XPTR( chdev_cxy , chdev_ptr->name ) );
-    owner_xp = (xptr_t)hal_remote_lwd( XPTR( chdev_cxy , &chdev_ptr->ext.txt.owner_xp ) );
+                       XPTR( txt_chdev_cxy , txt_chdev_ptr->name ) );
+    
+    txt_owner_xp = (xptr_t)hal_remote_lwd( XPTR( txt_chdev_cxy, 
+                                                 &txt_chdev_ptr->ext.txt.owner_xp ) );
     
     // get process .elf name
     elf_file_xp   = hal_remote_lwd( XPTR( process_cxy , &process_ptr->vfs_bin_xp ) );
-
     elf_file_cxy  = GET_CXY( elf_file_xp );
     elf_file_ptr  = (vfs_file_t *)GET_PTR( elf_file_xp );
@@ -1598 +1616 @@
 
     // display process info
-    if( owner_xp == process_xp )
-    {
-        printk("PID %X | PPID %X | STS %X | %s (FG) | %X | %d | %s\n", 
+    if( txt_owner_xp == process_xp )
+    {
+        nolock_printk("PID %X | PPID %X | STS %X | %s (FG) | %X | %d | %s\n", 
         pid, ppid, state, txt_name, process_ptr, th_nr, elf_name );
     }
     else
     {
-        printk("PID %X | PPID %X | STS %X | %s (BG) | %X | %d | %s\n", 
+        nolock_printk("PID %X | PPID %X | STS %X | %s (BG) | %X | %d | %s\n", 
         pid, ppid, state, txt_name, process_ptr, th_nr, elf_name );
     }
@@ -1988 +2006 @@
     xptr_t      current_xp;
     xptr_t      iter_xp;
-
-    // check terminal index
+    cxy_t       txt0_cxy;
+    chdev_t   * txt0_ptr;
+    xptr_t      txt0_xp;
+    xptr_t      txt0_lock_xp;
+    reg_t       txt0_save_sr;    // save SR to take TXT0 lock in busy mode
+    
     assert( (txt_id < LOCAL_CLUSTER->nb_txt_channels) ,
     __FUNCTION__ , "illegal TXT terminal index" );
+
+    // get pointers on TXT0 chdev
+    txt0_xp  = chdev_dir.txt_tx[0];
+    txt0_cxy = GET_CXY( txt0_xp );
+    txt0_ptr = GET_PTR( txt0_xp );
+
+    // get extended pointer on TXT0 lock
+    txt0_lock_xp = XPTR( txt0_cxy , &txt0_ptr->wait_lock );
 
     // get pointers on TXT_RX[txt_id] chdev
@@ -2002 +2032 @@
     lock_xp = XPTR( chdev_cxy , &chdev_ptr->ext.txt.lock );
 
+    // get lock on attached process list
+    remote_spinlock_lock( lock_xp );
+
+    // get TXT0 lock in busy waiting mode
+    remote_spinlock_lock_busy( txt0_lock_xp , &txt0_save_sr );
+
     // display header
-    printk("\n***** processes attached to TXT_%d\n", txt_id );
-
-    // get lock
-    remote_spinlock_lock( lock_xp );
+    nolock_printk("\n***** processes attached to TXT_%d / cycle %d\n",
+    txt_id , (uint32_t)hal_get_cycles() );
 
     // scan attached process list 
@@ -2015 +2049 @@
     }
 
-    // release lock
+    // release TXT0 lock in busy waiting mode
+    remote_spinlock_unlock_busy( txt0_lock_xp , txt0_save_sr );
+
+    // release lock on attached process list
     remote_spinlock_unlock( lock_xp );
 

trunk/kernel/kern/process.h

@@ -90 +90 @@
  * The process descriptor is replicated in all clusters containing at least one thread 
  * of the PID process, with the following rules :
- * 1) The <pid>, <ppid>, <ref_xp>, <vfs_root_xp>, <vfs_bin_xp>  fields are defined
- *    in all process descriptor copies.
+ * 1) The <pid>, <ppid>, <ref_xp>, <owner_xp>, <vfs_root_xp>, <vfs_bin_xp>  fields are 
+ *    defined in all process descriptor copies.
  * 2) The <vfs_cwd_xp> and associated <cwd_lock>, that can be dynamically modified,
  *    are only defined in the reference process descriptor.
@@ -106 +106 @@
  *    are defined in all process descriptors copies.
  * 7) The termination <flags> and <exit_status> are only defined in the reference cluster.
- *    The term state format is defined in the shared_syscalls.h file.
+ *    The term_state format is defined in the shared_syscalls.h file.
  ********************************************************************************************/
 
@@ -119 +119 @@
         pid_t             pid;              /*! process identifier                              */
     xptr_t            ref_xp;           /*! extended pointer on reference process           */
+    xptr_t            owner_xp;         /*! extended pointer on owner process               */
     xptr_t            parent_xp;        /*! extended pointer on parent process              */
 
@@ -264 +265 @@
 /*********************************************************************************************
  * This debug function diplays on the kernel terminal TXT0 detailed informations on a 
- * reference process identified by the <process_xp> argument.
+ * process descriptor identified by the <process_xp> argument.
  * It can be called by a thread running in any cluster.
- *********************************************************************************************
- * @ process_xp : extended pointer on reference process.
+ * WARNING: this function uses the nolock_printk() function, and the  TXT0 lock MUST be
+ * taken by the caller function. 
+ *********************************************************************************************
+ * @ process_xp : extended pointer on process descriptor.
  ********************************************************************************************/
 void process_display( xptr_t process_xp );
@@ -379 +382 @@
 
 /*********************************************************************************************
- * This function implements 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 child (local) cluster can be any cluster defined by the sys_fork function.
+ * This function implements the "fork" system call, and is called by the sys_fork() function,
+ * likely throuch the RPC_PROCESS_MAKE_FORK. 
+ * It allocates memory and initializes a new "child" process descriptor, and the associated
+ * "child" thread descriptor in local cluster. It involves up to three different clusters :
+ * - the child (local) cluster can be any cluster selected by the sys_fork function.
  * - the parent cluster must be the reference cluster for the parent process.
  * - the client cluster containing the thread requesting the fork can be any cluster.
@@ -483 +486 @@
  * It checks that there is an available slot in the local th_tbl[] array,
  * allocates a new LTID, and registers the new thread in the th_tbl[].
- * WARNING : the lock protecting the th_tbl[] must be taken by the caller.
+ * It takes the lock protecting exclusive access to the th_tbl[].
  *********************************************************************************************
  * @ process  : pointer on the local process descriptor.
@@ -496 +499 @@
 /*********************************************************************************************
  * This function removes a thread registration from the local process descriptor.
- * WARNING : the lock protecting the th_tbl[] must be taken by the caller.
+ * It takes the lock protecting exclusive access to the th_tbl[].
  *********************************************************************************************
  * @ thread   : local pointer on thread to be removed.
- ********************************************************************************************/
-void process_remove_thread( struct thread_s * thread );
+ * @ return true if the removed thread was the last registered thread.
+ ********************************************************************************************/
+bool_t process_remove_thread( struct thread_s * thread );
 
 
@@ -551 +555 @@
  * When the process dentified by the <owner_xp> argument has the exclusive ownership of
  * the TXT_RX terminal, this function transfer this ownership to another attached process.
- * The process descriptor must be in the process owner cluster.
- * This function does nothing if the <pid> process is not the owner.
+ * The process descriptor must be the process owner.
+ * This function does nothing if the process identified by the <process_xp> is not 
+ * the TXT owner.
  * - If the current owner is not the KSH process, the new owner is the KSH process.
- * - If the <pid> process is the the KSH process, the new owner is another attached process.
+ * - If the current owner is the KSH process, the new owner is another attached process.
  * - If there is no other attached process, the TXT has no more defined owner. 
  *********************************************************************************************

trunk/kernel/kern/scheduler.c

@@ -34 +34 @@
 #include <scheduler.h>
 
+
 ///////////////////////////////////////////////////////////////////////////////////////////
 // Extern global variables
 ///////////////////////////////////////////////////////////////////////////////////////////
 
-extern chdev_directory_t    chdev_dir;            // allocated in kernel_init.c file
-extern uint32_t             switch_save_sr[];     // allocated in kernel_init.c file
+uint32_t   idle_thread_count;
+uint32_t   idle_thread_count_active;
+
+extern chdev_directory_t    chdev_dir;          // allocated in kernel_init.c file
+extern uint32_t             switch_save_sr[];   // allocated in kernel_init.c file
 
 ////////////////////////////////
@@ -50 +54 @@
 
     sched->current        = CURRENT_THREAD;
-    sched->idle           = NULL;             // initialized in kernel_init()
-    sched->u_last         = NULL;             // initialized in sched_register_thread()
-    sched->k_last         = NULL;             // initialized in sched_register_thread()
+    sched->idle           = NULL;               // initialized in kernel_init()
+    sched->u_last         = NULL;               // initialized in sched_register_thread()
+    sched->k_last         = NULL;               // initialized in sched_register_thread()
 
     // initialise threads lists
@@ -58 +62 @@
     list_root_init( &sched->k_root );
 
-    sched->req_ack_pending = false;           // no pending request
+    sched->req_ack_pending = false;             // no pending request
+    sched->trace           = false;             // context switches trace desactivated
 
 }  // end sched_init()
@@ -179 +184 @@
     thread_t     * thread;
     process_t    * process;
+    bool_t         last_thread;
 
     // get pointer on scheduler
@@ -237 +243 @@
 
             // delete thread
-            thread_destroy( thread );
+            last_thread = thread_destroy( thread );
 
 #if DEBUG_SCHED_HANDLE_SIGNALS
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_SCHED_HANDLE_SIGNALS < cycle )
-printk("\n[DBG] %s : thread %x in proces %x (%x) deleted / cycle %d\n",
-__FUNCTION__ , thread , process->pid , process , cycle );
+printk("\n[DBG] %s : thread %x in proces %x on core[%x,%d] deleted / cycle %d\n",
+__FUNCTION__ , thread->trdid , process->pid , local_cxy , thread->core->lid , cycle );
 #endif
             // destroy process descriptor if no more threads
-            if( process->th_nr == 0 ) 
+            if( last_thread ) 
             {
                 // delete process    
@@ -254 +260 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_SCHED_HANDLE_SIGNALS < cycle )
-printk("\n[DBG] %s : process %x has been deleted / cycle %d\n",
-__FUNCTION__ , process->pid , cycle );
+printk("\n[DBG] %s : process %x in cluster %x deleted / cycle %d\n",
+__FUNCTION__ , process->pid , local_cxy , cycle );
 #endif
 
@@ -277 +283 @@
  
 #if (DEBUG_SCHED_YIELD & 0x1)
-if( DEBUG_SCHED_YIELD < (uint32_t)hal_get_cycles() )
+if( sched->trace )
 sched_display( core->lid );
 #endif
@@ -295 +301 @@
 
     // check next thread kernel_stack overflow
-    assert( (next->signature == THREAD_SIGNATURE),
-    __FUNCTION__ , "kernel stack overflow for thread %x\n", next );
+    assert( (next->signature == THREAD_SIGNATURE), __FUNCTION__ , 
+    "kernel stack overflow for thread %x on core[%x,%d] \n", next, local_cxy, core->lid );
 
     // check next thread attached to same core as the calling thread
-    assert( (next->core == current->core),
-    __FUNCTION__ , "next core %x != current core %x\n", next->core, current->core );
+    assert( (next->core == current->core), __FUNCTION__ , 
+    "next core %x != current core %x\n", next->core, current->core );
 
     // check next thread not blocked when type != IDLE
@@ -311 +317 @@
     {
 
-if( (local_cxy == 0X1) && (core->lid == 1) && ((uint32_t)current == 0xcc000) )
-printk("\n@@@@@ cc000 exit at cycle %d\n", (uint32_t)hal_get_cycles() );
-
-if( (local_cxy == 0X1) && (core->lid == 1) && ((uint32_t)next == 0xcc000) )
-printk("\n@@@@@ cc000 enter at cycle %d\n", (uint32_t)hal_get_cycles() );
-
 #if DEBUG_SCHED_YIELD
-uint32_t cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_SCHED_YIELD < cycle )
+if( sched->trace )
 printk("\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, 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 , cycle );
+current, thread_type_str(current->type), current->process->pid, current->trdid,next ,
+thread_type_str(next->type) , next->process->pid , next->trdid , (uint32_t)hal_get_cycles() );
 #endif
 
@@ -345 +344 @@
     {
 
-#if (DEBUG_SCHED_YIELD & 1)
-uint32_t cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_SCHED_YIELD < cycle )
+#if DEBUG_SCHED_YIELD 
+if( sched->trace )
 printk("\n[DBG] %s : core[%x,%d] / cause = %s\n"
 "      thread %x (%s) (%x,%x) continue / cycle %d\n",
-__FUNCTION__, local_cxy, core->lid, cause,
-current, thread_type_str(current->type), current->process->pid, current->trdid, cycle );
+__FUNCTION__, local_cxy, core->lid, cause, current, thread_type_str(current->type),
+current->process->pid, current->trdid, (uint32_t)hal_get_cycles() );
 #endif
 
@@ -389 +387 @@
 
     nolock_printk("\n***** threads on core[%x,%d] / current %x / cycle %d\n",
-            local_cxy , core->lid, sched->current, (uint32_t)hal_get_cycles() );
+    local_cxy , core->lid, sched->current, (uint32_t)hal_get_cycles() );
 
     // display kernel threads

trunk/kernel/kern/scheduler.h

@@ -50 +50 @@
     struct thread_s * current;         /*! pointer on current running thread                */
     volatile bool_t   req_ack_pending; /*! sequencialize ack requests when true             */
+    bool_t            trace;           /*! context switches trace activated if true         */
 }
 scheduler_t;

trunk/kernel/kern/thread.c

@@ -142 +142 @@
         cluster_t    * local_cluster = LOCAL_CLUSTER;
 
+#if DEBUG_THREAD_USER_INIT
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_THREAD_USER_INIT < cycle )
+printk("\n[DBG] %s : thread %x enter to init thread %x in process %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, thread, process->pid , cycle );
+#endif
+
     // register new thread in process descriptor, and get a TRDID
     error = process_register_thread( process, thread , &trdid );
@@ -196 +203 @@
         thread->signature = THREAD_SIGNATURE;
 
-    // FIXME call hal_thread_init() function to initialise the save_sr field
+    // FIXME define and call an architecture specific hal_thread_init()
+    // function to initialise the save_sr field
     thread->save_sr = 0xFF13;
 
@@ -204 +212 @@
         // update DQDT 
     dqdt_update_threads( 1 );
+
+#if DEBUG_THREAD_USER_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_THREAD_USER_INIT < cycle )
+printk("\n[DBG] %s : thread %x exit  after init of thread %x in process %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, thread, process->pid , cycle );
+#endif
 
         return 0;
@@ -227 +242 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_THREAD_USER_CREATE < cycle )
-printk("\n[DBG] %s : thread %x enter / process %x / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, pid , cycle );
+printk("\n[DBG] %s : thread %x enter for process %x in cluster %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, pid , local_cxy , cycle );
 #endif
 
@@ -240 +255 @@
         return ENOMEM;
     }
+
+#if( DEBUG_THREAD_USER_CREATE & 1)
+if( DEBUG_THREAD_USER_CREATE < cycle )
+printk("\n[DBG] %s : process descriptor = %x for process %x in cluster %x\n",
+__FUNCTION__, process , pid , local_cxy );
+#endif
 
     // select a target core in local cluster
@@ -256 +277 @@
         core_lid = cluster_select_local_core();
     }
+
+#if( DEBUG_THREAD_USER_CREATE & 1)
+if( DEBUG_THREAD_USER_CREATE < cycle )
+printk("\n[DBG] %s : core[%x,%d] selected\n",
+__FUNCTION__, local_cxy , core_lid );
+#endif
 
     // allocate a stack from local VMM
@@ -282 +309 @@
         return ENOMEM;
     }
+
+#if( DEBUG_THREAD_USER_CREATE & 1)
+if( DEBUG_THREAD_USER_CREATE < cycle )
+printk("\n[DBG] %s : thread descriptor %x allocated\n",
+__FUNCTION__, thread );
+#endif
 
     // initialize thread descriptor
@@ -300 +333 @@
     }
 
+#if( DEBUG_THREAD_USER_CREATE & 1)
+if( DEBUG_THREAD_USER_CREATE < cycle )
+printk("\n[DBG] %s : thread descriptor %x initialised / trdid = %x\n",
+__FUNCTION__, thread , thread->trdid );
+#endif
+
     // set DETACHED flag if required
     if( attr->attributes & PT_ATTR_DETACH ) 
@@ -327 +366 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_THREAD_USER_CREATE < cycle )
-printk("\n[DBG] %s : thread %x exit / process %x / new_thread %x / core %d / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, pid, thread, core_lid, cycle );
+printk("\n[DBG] %s : thread %x exit / new_thread %x in process %x / core %d / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, thread->trdid , pid , core_lid, cycle );
 #endif
 
@@ -602 +641 @@
 // has been released, using a cache of mmap requests. [AG]
 ///////////////////////////////////////////////////////////////////////////////////////
-void thread_destroy( thread_t * thread )
+bool_t thread_destroy( thread_t * thread )
 {
     reg_t        save_sr;
+    bool_t       last_thread;
 
     process_t  * process    = thread->process;
@@ -616 +656 @@
 #endif
 
-    assert( (thread->local_locks == 0) , __FUNCTION__ , "all local locks not released" );
-
-    assert( (thread->remote_locks == 0) , __FUNCTION__ , "all remote locks not released" );
+    assert( (thread->local_locks == 0) , __FUNCTION__ , 
+    "local lock not released for thread %x in process %x", thread->trdid, process->pid );
+
+    assert( (thread->remote_locks == 0) , __FUNCTION__ , 
+    "remote lock not released for thread %x in process %x", thread->trdid, process->pid );
 
     // update intrumentation values
@@ -637 +679 @@
 
     // remove thread from process th_tbl[]
-    process_remove_thread( thread );
+    last_thread = process_remove_thread( thread );
         
     // update DQDT
@@ -654 +696 @@
 __FUNCTION__, CURRENT_THREAD, thread, process->pid, cycle );
 #endif
+
+    return last_thread;
 
 }   // end thread_destroy()
@@ -1092 +1136 @@
         hal_enable_irq( NULL );
 
-        if( CONFIG_THREAD_IDLE_MODE_SLEEP ) // force core to low-power mode
+        // force core to low-power mode (optional)
+        if( CONFIG_THREAD_IDLE_MODE_SLEEP ) 
         {
 
@@ -1113 +1158 @@
 
         }
-        else                                // search a runable thread
-        {
-            sched_yield( "IDLE" );
-        }
+
+        // search a runable thread
+        sched_yield( "IDLE" );
     }
 }  // end thread_idle()

trunk/kernel/kern/thread.h

@@ -77 +77 @@
 
 /***************************************************************************************
- * This defines the masks associated to the blocking causes.
+ * This defines the thread blocking causes bit-vector.
  **************************************************************************************/
 
@@ -278 +278 @@
 
 /***************************************************************************************
- * This function is called by the kernel_init() function to initialize the IDLE thread.
- * It initializes an existing thread descriptor from arguments values.
+ * This function is called by the kernel_init() function to initialize the IDLE thread
+ * descriptor from arguments values.
  * The THREAD_BLOCKED_GLOBAL bit is set, and the thread must be activated to start.
  ***************************************************************************************
@@ -296 +296 @@
 
 /***************************************************************************************
- * This function releases the physical memory allocated for a thread in a given cluster.
- * This include the thread descriptor itself, the associated CPU and FPU context, and
- * the physical memory allocated for an user thread local stack.
+ * This function is called by the sched_handle_signals() function to releases 
+ * the physical memory allocated for a thread in a given cluster, when this thread 
+ * is marked for delete. This include the thread descriptor itself, the associated 
+ * CPU and FPU context, and the physical memory allocated for an user thread local stack.
+ * The destroyed thread is removed from the local process th_tbl[] array, and returns 
+ * true when the destroyed thread was the last thread registered in process.
  ***************************************************************************************
  * @ thread  : pointer on the thread descriptor to release.
- **************************************************************************************/
-void thread_destroy( thread_t * thread );
+ * @ return true, if the thread was the last registerd thread in local process.
+ **************************************************************************************/
+bool_t thread_destroy( thread_t * thread );
 
 /***************************************************************************************
  * This function defines the code of the thread executed by all cores after kernel_init,
  * or when no other thread is runnable for a given core.
- *
- * TODO: In the TSAR architecture, it enters an infinite loop, in wich it forces
- * the core in sleep (low-power) mode. Any IRQ will force the core to exit this sleep
- * mode, but no ISR is executed.
- * TODO: We must analyse if we have the same behaviour for I86 architectures...
+ * It enter and infinite loop in wich:
+ * - it unmask the IRQs
+ * - it optionally calls the hal_core_sleep() function to reduce the power consumption
+ *   (this behavior is controlled by the CONFIG_THREAD_IDLE_MODE_SLEEP flag).
+ * - it call the sched_yield() function to find another runnable thread.
+ *
+ * TODO: In the TSAR architecture the hal_core_sleep() function forces the core to
+ * low-power mode. Any IRQ will force the core to exit this low-power mode, but no ISR
+ * is executed. We must analyse if we have the same behaviour for I86 architectures...
  **************************************************************************************/
 void thread_idle_func();
@@ -357 +365 @@
 /***************************************************************************************
  * This function is used by the four sys_thread_cancel(), sys_thread_exit(),
- * sys_kill() and sys_exit() system calls to delete a given thread. 
+ * sys_kill() and sys_exit() system calls to mark for delete a given thread. 
  * It set the THREAD_BLOCKED_GLOBAL bit and set the the THREAD_FLAG_REQ_DELETE bit
  * in the thread descriptor identified by the <thread_xp> argument, to ask the scheduler 

trunk/kernel/kernel_config.h

@@ -67 +67 @@
 #define DEBUG_FATFS_LOAD               0
 
-#define DEBUG_GPT_ACCESS               0
+#define DEBUG_HAL_GPT_ACCESS           0
+#define DEBUG_HAL_GPT_CREATE           0
+#define DEBUG_HAL_GPT_DESTROY          0
 
 #define DEBUG_HAL_KENTRY               0
@@ -76 +78 @@
 #define DEBUG_HAL_IOC_RX               0
 #define DEBUG_HAL_IOC_TX               0
+#define DEBUG_HAL_GPT
 
 #define DEBUG_KCM                      0
@@ -115 +118 @@
 #define DEBUG_RPC_VMM_GET_VSEG         0
 
-#define DEBUG_SCHED_HANDLE_SIGNALS     0
-#define DEBUG_SCHED_YIELD              0
+#define DEBUG_SCHED_HANDLE_SIGNALS     2
+#define DEBUG_SCHED_YIELD              2    // dynamically activated by the trace() syscall
 
 #define DEBUG_SYSCALLS_ERROR           2
@@ -132 +135 @@
 #define DEBUG_SYS_THREAD_CANCEL        0
 #define DEBUG_SYS_THREAD_CREATE        0
-#define DEBUG_SYS_THREAD_EXIT          1
+#define DEBUG_SYS_THREAD_EXIT          0
 #define DEBUG_SYS_THREAD_JOIN          0
 #define DEBUG_SYS_THREAD_SLEEP         0
 #define DEBUG_SYS_THREAD_WAKEUP        0
+#define DEBUG_SYS_TRACE                0
 #define DEBUG_SYS_WAIT                 0
 #define DEBUG_SYS_WRITE                0
@@ -146 +150 @@
 #define DEBUG_THREAD_DESTROY           0
 #define DEBUG_THREAD_IDLE              0
+#define DEBUG_THREAD_INIT              0
 #define DEBUG_THREAD_KERNEL_CREATE     0
 #define DEBUG_THREAD_KILL              0
@@ -199 +204 @@
 
 #define CONFIG_TXT_ECHO_MODE                1          // echo mode for TXT peripheral
-#define CONFIG_TXT_KBUF_SIZE                256        // kernel buffer for TXT write
+#define CONFIG_TXT_KBUF_SIZE                512        // kernel buffer for TXT write
 
 #define CONFIG_FBF_WIDTH                    128
@@ -265 +270 @@
 #define CONFIG_THREAD_DESC_SIZE             0x4000  // thread desc size (with kernel stack)
 #define CONFIG_THREAD_DESC_ORDER            2       // ln( number of 4K pages )
-#define CONFIG_THREAD_IDLE_MODE_SLEEP       0       // idle thread enter sleep mode 
+#define CONFIG_THREAD_IDLE_MODE_SLEEP       false   // idle thread enter sleep mode 
 
 ////////////////////////////////////////////////////////////////////////////////////////////

trunk/kernel/libk/remote_spinlock.c

@@ -201 +201 @@
 xlist_add_first( XPTR( local_cxy , &thread_ptr->xlocks_root ),
                  XPTR( lock_cxy  , &lock_ptr->list ) );
-
-// if( (uint32_t)lock_ptr == 0x66788 )
-// printk("\n@@@ %s : thread %x takes remote_spinlock %x\n",
-//__FUNCTION__, thread_ptr, lock_ptr );
-
 #endif
 
@@ -225 +220 @@
 hal_remote_swd( XPTR( lock_cxy , &lock_ptr->owner ) , XPTR_NULL );
 xlist_unlink( XPTR( lock_cxy , &lock_ptr->list ) );
-
-// if( (uint32_t)lock_ptr == 0x66788 )
-// printk("\n@@@ %s : thread %x releases remote_spinlock %x\n",
-// __FUNCTION__, thread_ptr, lock_ptr );
-
 #endif
 

trunk/kernel/mm/vmm.c

@@ -201 +201 @@
     gpt_t * gpt = &vmm->gpt;
 
-    printk("\n***** VSL and GPT for process %x in cluster %x\n\n", 
-    process->pid , local_cxy );
+    printk("\n***** VSL and GPT for process %x in cluster %x\n\n", process->pid , local_cxy );
 
     // get lock protecting the vseg list
@@ -666 +665 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_VMM_DESTROY < cycle )
-printk("\n[DBG] %s : thread %x enter for process %x / cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD , process->pid , cycle );
+printk("\n[DBG] %s : thread %x enter for process %x in cluster %x / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , process->pid , local_cxy , cycle );
 #endif
 
 #if (DEBUG_VMM_DESTROY & 1 )
+if( DEBUG_VMM_DESTROY < cycle )
 vmm_display( process , true );
 #endif
@@ -693 +693 @@
 #if( DEBUG_VMM_DESTROY & 1 )
 if( DEBUG_VMM_DESTROY < cycle )
-printk("\n[DBG] %s : %s / vpn_base %x / vpn_size %d\n",
+printk("\n[DBG] %s : found %s vseg / vpn_base %x / vpn_size %d\n",
 __FUNCTION__ , vseg_type_str( vseg->type ), vseg->vpn_base, vseg->vpn_size );
 #endif
-
         // unmap and release physical pages 
         vmm_unmap_vseg( process , vseg );
@@ -705 +704 @@
         // release memory allocated to vseg descriptor
         vseg_free( vseg );
+
+#if( DEBUG_VMM_DESTROY & 1 )
+if( DEBUG_VMM_DESTROY < cycle )
+printk("\n[DBG] %s : %s vseg released / vpn_base %x / vpn_size %d\n",
+__FUNCTION__ , vseg_type_str( vseg->type ), vseg->vpn_base, vseg->vpn_size );
+#endif
+
         }
 
@@ -717 +723 @@
             {
                     vseg = LIST_FIRST( &vmm->mmap_mgr.zombi_list[i] , vseg_t , zlist );
+
+#if( DEBUG_VMM_DESTROY & 1 )
+if( DEBUG_VMM_DESTROY < cycle )
+printk("\n[DBG] %s : found zombi vseg / vpn_base %x / vpn_size %d\n",
+__FUNCTION__ , vseg_type_str( vseg->type ), vseg->vpn_base, vseg->vpn_size );
+#endif
                     vseg_detach( vmm , vseg );
             vseg_free( vseg );
+
+#if( DEBUG_VMM_DESTROY & 1 )
+if( DEBUG_VMM_DESTROY < cycle )
+printk("\n[DBG] %s : zombi vseg released / vpn_base %x / vpn_size %d\n",
+__FUNCTION__ , vseg_type_str( vseg->type ), vseg->vpn_base, vseg->vpn_size );
+#endif
             }
     }
@@ -728 +746 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_VMM_DESTROY < cycle )
-printk("\n[DBG] %s : thread %x exit / cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD , cycle );
+printk("\n[DBG] %s : thread %x exit for process %x in cluster %x / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , process->pid , local_cxy , cycle );
 #endif
 

trunk/kernel/syscalls/sys_display.c

@@ -30 +30 @@
 #include <process.h>
 #include <string.h>
-
+#include <shared_syscalls.h>
+
+/////////////////////////////////////////////////////////////////////////////////
+// This static function returns a printable string for the type of display.
+/////////////////////////////////////////////////////////////////////////////////
+
+#if DEBUG_SYS_DISPLAY
+static char* display_type_str( uint32_t type )
+{
+    if     ( type == DISPLAY_STRING            ) return "STRING"; 
+    else if( type == DISPLAY_VMM               ) return "VMM"; 
+    else if( type == DISPLAY_SCHED             ) return "SCHED"; 
+    else if( type == DISPLAY_CLUSTER_PROCESSES ) return "CLUSTER_PROCESSES"; 
+    else if( type == DISPLAY_VFS               ) return "VFS"; 
+    else if( type == DISPLAY_CHDEV             ) return "CHDEV"; 
+    else if( type == DISPLAY_TXT_PROCESSES     ) return "TXT_PROCESSES"; 
+}
+#endif
 
 /////////////////////////////
@@ -49 +66 @@
 tm_start = hal_get_cycles();
 if( DEBUG_SYS_DISPLAY < tm_start )
-printk("\n[DBG] %s : thread %d enter / process %x / type  %d / cycle = %d\n",
-__FUNCTION__, this, this->process->pid, type, (uint32_t)tm_start );
+printk("\n[DBG] %s : thread %d enter / process %x / type  %s / cycle = %d\n",
+__FUNCTION__, this, this->process->pid, display_type_str(type), (uint32_t)tm_start );
 #endif
 
@@ -98 +115 @@
     else if( type == DISPLAY_VMM )
     {
-        pid_t pid = (pid_t)arg0;
-
-        // get extended pointer on reference process
-        xptr_t process_xp = cluster_get_reference_process_from_pid( pid );
+        cxy_t cxy = (cxy_t)arg0;
+        pid_t pid = (pid_t)arg1;
+
+        // check cxy argument
+            if( cluster_is_undefined( cxy ) ) 
+        {
+
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : illegal cxy argument %x / thread %x / process %x\n",
+__FUNCTION__ , cxy , this->trdid , process->pid );
+#endif
+            this->errno = EINVAL;
+            return -1;
+        }
+
+        // get extended pointer on process PID in cluster CXY
+        xptr_t process_xp = cluster_get_process_from_pid_in_cxy( cxy , pid );
 
             if( process_xp == XPTR_NULL )
@@ -107 +137 @@
 
 #if DEBUG_SYSCALLS_ERROR
-printk("\n[ERROR] in %s : undefined pid argument %d / thread %x / process %x\n",
-__FUNCTION__ , pid , this->trdid , process->pid );
-#endif
-            this->errno = EINVAL;
-            return -1;
-        }
-
-        // get cluster and local pointer on process
-        cxy_t       process_cxy = GET_CXY( process_xp );
-        process_t * process_ptr = (process_t *)GET_PTR( process_xp );
+printk("\n[ERROR] in %s : process %x in cluster %x not found / thread %x / process %x\n",
+__FUNCTION__ , pid , cxy , this->trdid , process->pid );
+#endif
+            this->errno = EINVAL;
+            return -1;
+        }
+
+        // get local pointer on process
+        process_t * process = (process_t *)GET_PTR( process_xp );
 
         // call kernel function
-        if( process_cxy == local_cxy )
-        {
-                vmm_display( process_ptr , true );
+        if( cxy == local_cxy )
+        {
+                vmm_display( process , true );
         }
         else
         {
-            rpc_vmm_display_client( process_cxy , process_ptr , true );
+            rpc_vmm_display_client( cxy , process , true );
         }
     }

trunk/kernel/syscalls/sys_exit.c

@@ -51 +51 @@
 #endif
 
-    // get owner process descriptor pointers and cluster
-    xptr_t      owner_xp  = cluster_get_owner_process_from_pid( pid );
+    // get owner process descriptor pointers 
+    xptr_t      owner_xp  = process->owner_xp;
     cxy_t       owner_cxy = GET_CXY( owner_xp );
     process_t * owner_ptr = GET_PTR( owner_xp );
@@ -62 +62 @@
     hal_enable_irq( &save_sr );
 
-    // mark for delete all process threads in all clusters 
-    // (but the main thread and this calling thread) 
+    // mark for delete all process threads in all clusters, 
+    // but the main thread and this calling thread 
     process_sigaction( pid , DELETE_ALL_THREADS );
 
@@ -81 +81 @@
 #if( DEBUG_SYS_EXIT & 1)
 if( tm_start > DEBUG_SYS_EXIT )
-printk("\n[DBG] %s : calling thread %x deleted itself / process %x\n",
+printk("\n[DBG] %s : calling thread %x marked iself for delete / process %x\n",
 __FUNCTION__ , this, pid );
 #endif

trunk/kernel/syscalls/sys_fg.c

@@ -36 +36 @@
 int sys_fg( pid_t    pid )
 {
-    xptr_t      process_xp;
+    xptr_t      process_xp;     // extended pointer on reference process descriptor
     process_t * process_ptr;
     cxy_t       process_cxy;
-    xptr_t      chdev_xp;
+    xptr_t      file_xp;        // extended pointer on STDIN file descriptor
+    xptr_t      chdev_xp;       // extended pointer on TXT0_RX chdev
     chdev_t   * chdev_ptr;
     cxy_t       chdev_cxy;
@@ -70 +71 @@
     process_ptr = (process_t *)GET_PTR( process_xp );
     process_cxy = GET_CXY( process_xp );
+
+    // get extended pointer on the reference process STDIN file descriptor
+    file_xp = hal_remote_lwd( XPTR( process_cxy , &process_ptr->fd_array.array[0] ) );
  
     // get extended pointer on TXT_RX chdev
-    chdev_xp = chdev_from_file( XPTR( process_cxy , &process_ptr->fd_array.array[0] ) );
+    chdev_xp = chdev_from_file( file_xp );
 
     // get chdev cluster and local pointer

trunk/kernel/syscalls/sys_read.c

@@ -147 +147 @@
         // check file readable
         uint32_t attr = hal_remote_lw( XPTR( file_cxy , &file_ptr->attr ) );
+
         if( (attr & FD_ATTR_READ_ENABLE) == 0 )
             {
@@ -231 +232 @@
 exit_sys_read = (uint32_t)tm_end;
 
-printk("\n@@@@@@@@@@@@ timing to read character\n"
+printk("\n***** timing to read one character *****\n"
 " - enter_sys_read          = %d / delta %d\n"
 " - enter_devfs_read        = %d / delta %d\n"

trunk/kernel/syscalls/sys_thread_cancel.c

@@ -37 +37 @@
     cxy_t        target_cxy;    // target thread cluster identifier
     ltid_t       target_ltid;   // target thread local index
+    xptr_t       owner_xp;      // extended pointer on owner process
     cxy_t        owner_cxy;     // process owner cluster identifier
-    xptr_t       owner_xp;      // extended pointer on owner process
 
     // get killer thread pointers
@@ -44 +44 @@
     process_t  * process = this->process;
     pid_t        pid     = process->pid;
+
+#if DEBUG_SYS_THREAD_CANCEL
+uint64_t     tm_start;
+uint64_t     tm_end;
+tm_start = hal_get_cycles();
+if( DEBUG_SYS_THREAD_CANCEL < tm_start )
+printk("\n[DBG] %s : thread %x enter to kill thread %x in process %x / cycle %d\n",
+__FUNCTION__, this , trdid , pid , (uint32_t)tm_start );
+#endif
 
     // get extended pointer on target thread
@@ -59 +68 @@
     }
 
-#if DEBUG_SYS_THREAD_CANCEL
-uint64_t     tm_start;
-uint64_t     tm_end;
-tm_start = hal_get_cycles();
-if( DEBUG_SYS_THREAD_CANCEL < tm_start )
-printk("\n[DBG] %s : thread %x enter to kill thread %x / cycle %d\n",
-__FUCTION__, this, GET_PTR( target_xp ), (uint32_t)tm_start );
-#endif
-
-    // get process owner cluster identifier
-    owner_cxy = CXY_FROM_PID( pid );
+    // get process owner cluster
+    owner_xp  = process->owner_xp;
+    owner_cxy = GET_CXY( owner_xp );
 
     // get target thread ltid and cluster
@@ -79 +80 @@
     if( (target_cxy == owner_cxy) && (target_ltid == 0) )
     {
-        // get extended pointer on owner cluster
-        owner_xp = cluster_get_owner_process_from_pid( pid );
-
         // mark for delete all threads but the main 
         hal_enable_irq( &save_sr );
@@ -107 +105 @@
 tm_end = hal_get_cycles();
 if( DEBUG_SYS_THREAD_CANCEL < tm_end )
-printk("\n[DBG] %s : thread %x exit after kill thread %x / cycle %d\n",
-__FUCTION__, this, GET_PTR( target_xp ), (uint32_t)tm_end );
+printk("\n[DBG] %s : thread %x exit after kill thread %x in process %x / cycle %d\n",
+__FUNCTION__, this , trdid , pid , (uint32_t)tm_end );
 #endif
 

trunk/kernel/syscalls/sys_trace.c

@@ -1 +1 @@
 /*
- * sys_trace.c - show kernel active processes and threads
+ * sys_trace.c - activate / desactivate the context switches trace for a given core
  * 
- * Author    Alain Greiner (c) (2016,2017)
+ * Author    Alain Greiner (c) (2016,2017,2018)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -27 +27 @@
 #include <thread.h>
 #include <errno.h>
+#include <shared_syscalls.h>
 #include <syscalls.h>
 
-//////////////////////////////////
-int sys_trace( uint32_t operation,
-               pid_t    pid, 
-               uint32_t trdid )
+///////////////////////////////
+int sys_trace( bool_t   active,
+               cxy_t    cxy,
+               lid_t    lid )
 {
-    // get extended pointer on target thread
-    xptr_t thread_xp = thread_get_xptr( pid , trdid );
+    uint32_t    ncores;
 
-    if( thread_xp == XPTR_NULL )
+    thread_t  * this    = CURRENT_THREAD;
+    process_t * process = this->process;
+
+#if DEBUG_SYS_TRACE
+uint64_t    tm_start;
+uint64_t    tm_end;
+tm_start = hal_get_cycles();
+if( DEBUG_SYS_TRACE < tm_start )
+printk("\n[DBG] %s : thread %d enter / process %x / cycle = %d\n",
+__FUNCTION__, this, this->process->pid, (uint32_t)tm_start );
+#endif
+
+    // check cluster identifier
+    if( cluster_is_undefined( cxy ) )
     {
-        printk("\n[ERROR] in %s : undefined thread for PID = %x / TRDID = %x\n",
-               __FUNCTION__ , pid , trdid );
-        CURRENT_THREAD->errno = EINVAL;
+
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : illegal cxy argument %x / thread %x / process %x\n",
+__FUNCTION__ , cxy , this->trdid , process->pid );
+#endif
+        this->errno = EINVAL;
         return -1;
     }
 
-    if( operation == TRACE_OFF )
+    // check core local index
+    ncores = hal_remote_lw( XPTR( cxy , &LOCAL_CLUSTER->cores_nr ) );
+    if( lid >= ncores )
     {
-        // desactivate thread trace TODO
 
-            printk("\n[DBG] %s : trace OFF  for thread %x in process %x\n",
-               __FUNCTION__ , trdid , pid );
-    }
-    else if( operation == TRACE_ON )
-    {
-        // activate thread trace TODO
-                    
-            printk("\n[DBG] %s : trace ON for thread %x in process %x\n",
-               __FUNCTION__ , trdid , pid );
-    }
-    else
-    {
-        printk("\n[ERROR] in %s : undefined operation\n", __FUNCTION__ );
-        CURRENT_THREAD->errno = EINVAL;
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : illegal lid argument %x / thread %x / process %x\n",
+__FUNCTION__ , lid , this->trdid , process->pid );
+#endif
+        this->errno = EINVAL;
         return -1;
     }
 
+    // get local pointer on target core
+    core_t * core = &LOCAL_CLUSTER->core_tbl[lid];
+
+    // get extended pointer on target scheduler trace field
+    xptr_t trace_xp = XPTR( cxy , &core->scheduler.trace );
+
+    if ( active ) hal_remote_sw( trace_xp , 1 );
+    else          hal_remote_sw( trace_xp , 0 );
+    
     hal_fence();
+
+#if DEBUG_SYS_TRACE
+tm_end = hal_get_cycles();
+if( DEBUG_SYS_TRACE < tm_end )
+printk("\n[DBG] %s : thread %x exit / process %x / cost = %d / cycle %d\n",
+__FUNCTION__, this, this->process->pid, (uint32_t)(tm_end - tm_start) , (uint32_t)tm_end );
+#endif
 
     return 0;

trunk/kernel/syscalls/sys_wait.c

@@ -73 +73 @@
         }
 
-    // get process owner cluster and calling thread trdid
+    // get calling process owner cluster
     cxy_t   owner_cxy = CXY_FROM_PID( pid );
-    trdid_t trdid     = this->trdid;
 
-    // wait must be executed by the main thread
+    // get calling thread trdid
+    trdid_t trdid = this->trdid;
+
+    // this function must be executed by the process main thread
     if( (owner_cxy != local_cxy) || (LTID_FROM_TRDID(trdid) != 0) )
     {
@@ -113 +115 @@
             child_state = (int)hal_remote_lw ( XPTR(child_cxy,&child_ptr->term_state));
 
-            // test if child process is terminated,
+            // test if this child process is terminated,
             // but termination not yet reported to parent process
             if( ((child_state & PROCESS_TERM_EXIT)  || 
@@ -120 +122 @@
                  ((child_state & PROCESS_TERM_WAIT) == 0) )
             {
-                // get pointer on main thread and PID from child owner process
+                // get pointer on child main thread and PID from child owner process
                 child_pid    = (pid_t)     hal_remote_lw (XPTR( child_cxy , &child_ptr->pid ));
                 child_thread = (thread_t *)hal_remote_lpt(XPTR( child_cxy ,
                                                                 &child_ptr->th_tbl[0] ));
 
-                // set the PROCESS_FLAG_WAIT in owner child descriptor
+                // set the PROCESS_FLAG_WAIT in owner child process descriptor
                 hal_remote_atomic_or( XPTR( child_cxy , &child_ptr->term_state ),
                                       PROCESS_TERM_WAIT );

trunk/kernel/syscalls/sys_write.c

@@ -103 +103 @@
     }
 
-    // enable IRQs
-    hal_enable_irq( &save_sr );
-
     // get extended pointer on remote file descriptor
     file_xp = process_fd_get_xptr( process , file_id );
@@ -128 +125 @@
     vfs_inode_type_t type = hal_remote_lw( XPTR( file_cxy , &file_ptr->type ) );
 
-    // action depend on file type
+    // enable IRQs
+    hal_enable_irq( &save_sr );
+
+   // action depend on file type
     if( type == INODE_TYPE_FILE )  // check file writable & write to mapper 
     {
@@ -152 +152 @@
     else if( type == INODE_TYPE_DEV )  // check ownership & write to device
     {
+        // check user buffer size for TXT_TX
+        if( (type == INODE_TYPE_DEV) && (count >= CONFIG_TXT_KBUF_SIZE) )
+        {
+
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : user buffer size %x too large / thread %x / process %x\n",
+__FUNCTION__ , count, this->trdid, process->pid );
+#endif
+                    this->errno = EINVAL;
+                    return -1;
+        }
+
         // move count bytes to device
         nbytes = devfs_user_move( false,             // from buffer to device
@@ -158 +170 @@
                                  count );
     }
-    else
+    else  // not FILE and not DEV
     {
         nbytes = 0;
@@ -192 +204 @@
 exit_sys_write = (uint32_t)tm_end;
 
-printk("\n@@@@@@@@@@@@ timing to write\n"
+printk("\n***** timing to write a string *****\n"
 " - enter_sys_write          = %d / delta %d\n"
 " - enter_devfs_write        = %d / delta %d\n"

trunk/kernel/syscalls/syscalls.h

@@ -170 +170 @@
  * [10] This function implement the exit system call terminating a POSIX process.
  * It can be called by any thread running in any cluster.
- * It uses both remote accesses to access the owner process descriptor, ans the
- * RPC_PROCESS_SIGACTION to delete remote process and thread descriptors
+ * It uses both remote accesses to access the owner process descriptor, and the
+ * RPC_PROCESS_SIGACTION to delete remote process and thread descriptors.
  * In the present implementation, this function implements actually the _exit():
  * - it does not flush open output streams.
@@ -600 +600 @@
 
 /****************************************************************************************** 
- * [47] This non-standard function is used to activate / desactivate the trace for a thread 
- * identified by the <trdid> and <pid> arguments.
+ * [47] This debug function is used to activate / desactivate the context switches trace
+ * for a core identified by the <cxy> and <lid> arguments.
  * It can be called by any other thread in the same process.
  ****************************************************************************************** 
- * @ operation  : operation type as defined below.
- * @ pid        : process identifier.
- * @ trdid      : thread identifier.
+ * @ active     : activate trace if true / desactivate trace if false.
+ * @ cxy        : cluster identifier.
+ * @ lid        : core local index.
  * @ returns O if success / returns -1 if failure.
  *****************************************************************************************/
-int sys_trace( uint32_t operation,
-               pid_t    pid, 
-               uint32_t trdid );
+int sys_trace( bool_t   active,
+               cxy_t    cxy, 
+               lid_t    lid );
 
 /******************************************************************************************