Changeset 443 for trunk/kernel/kern

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/kern

Files:

• cluster.c (modified) (8 diffs)
• cluster.h (modified) (4 diffs)
• core.c (modified) (3 diffs)
• core.h (modified) (1 diff)
• do_syscall.c (modified) (2 diffs)
• kernel_init.c (modified) (3 diffs)
• printk.c (modified) (1 diff)
• process.c (modified) (17 diffs)
• process.h (modified) (8 diffs)
• scheduler.c (modified) (11 diffs)
• scheduler.h (modified) (1 diff)
• thread.c (modified) (15 diffs)
• thread.h (modified) (4 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