Changeset 279 for trunk/kernel/kern

Timestamp:

Jul 27, 2017, 12:23:29 AM (7 years ago)

Author:

alain

Message:

1) Introduce independant command fields for the various devices in the thread descriptor.
2) Introduce a new dev_pic_enable_ipi() function in the generic PIC device
3) Fix two bugs identified by Maxime in the scheduler initialisation, and in the sched_select().
4) fix several bugs in the TSAR hal_kentry.S.
5) Introduce a third kgiet segment (besides kdata and kcode) in the TSAR bootloader.

Location:

trunk/kernel/kern

Files:

• chdev.h (modified) (1 diff)
• cluster.c (modified) (2 diffs)
• cluster.h (modified) (4 diffs)
• core.c (modified) (1 diff)
• core.h (modified) (1 diff)
• kernel_init.c (modified) (25 diffs)
• printk.c (modified) (2 diffs)
• printk.h (modified) (3 diffs)
• process.c (modified) (3 diffs)
• rpc.c (modified) (62 diffs)
• rpc.h (modified) (2 diffs)
• scheduler.c (modified) (6 diffs)
• scheduler.h (modified) (4 diffs)
• thread.h (modified) (1 diff)

trunk/kernel/kern/chdev.h

@@ -169 +169 @@
     xptr_t   nic_tx[CONFIG_MAX_NIC_CHANNELS];    // external / multi-channels / shared
 
-    xptr_t   icu[CONFIG_MAX_CLUSTERS];           // internal / single channel / shared
     xptr_t   mmc[CONFIG_MAX_CLUSTERS];           // internal / single channel / shared
 

trunk/kernel/kern/cluster.c

@@ -77 +77 @@
     // initialize cluster local parameters
         cluster->cores_nr        = info->cores_nr;
-    cluster->cores_in_kernel = info->cores_nr; // all cpus start in kernel mode
+    cluster->cores_in_kernel = 0;
 
     // initialize the lock protecting the embedded kcm allocator
@@ -130 +130 @@
     // initialises RPC fifo
         rpc_fifo_init( &cluster->rpc_fifo );
+    cluster->rpc_threads = 0;
 
     cluster_dmsg("\n[INFO] %s : RPC fifo inialized in cluster %x at cycle %d\n",

trunk/kernel/kern/cluster.h

@@ -91 +91 @@
  * This structure defines a cluster manager.
  * It contains both global platform information, and cluster specific resources
- * managed by the local kernel instance.
+ * controled by the local kernel instance.
  ******************************************************************************************/
 
@@ -99 +99 @@
 
     // global parameters
-
         uint32_t          paddr_width;     /*! numer of bits in physical address              */
     uint32_t          x_width;         /*! number of bits to code x_size  (can be 0)      */
@@ -109 +108 @@
 
     // local parameters
-
         uint32_t          cores_nr;        /*! number of cores in cluster                     */
     uint32_t          cores_in_kernel; /*! number of cores currently in kernel mode       */
 
+    uint32_t          ram_size;        /*! physical memory size                           */
+    uint32_t          ram_base;        /*! physical memory base (local address)           */
+
         core_t            core_tbl[CONFIG_MAX_LOCAL_CORES];         /*! embedded cores        */
 
+        list_entry_t      dev_root;        /*! root of list of devices in cluster             */
+
+    // memory allocators
         ppm_t             ppm;             /*! embedded kernel page manager                   */
         khm_t             khm;             /*! embedded kernel heap manager                   */
         kcm_t             kcm;             /*! embedded kernel cache manager (for KCMs)       */
-
     kcm_t           * kcm_tbl[KMEM_TYPES_NR];         /*! pointers on allocated KCMs      */
 
-    uint32_t          ram_size;        /*! physical memory size                           */
-    uint32_t          ram_base;        /*! physical memory base (local address)           */
-
-        rpc_fifo_t        rpc_fifo;        /*! cluster RPC fifo (shared)                      */
-        list_entry_t      devlist;         /*! root of list of devices in cluster             */
-
+    // RPC
+        rpc_fifo_t        rpc_fifo;        /*! RPC fifo                                       */
+    uint32_t          rpc_threads;     /*! current number of RPC threads                  */
+
+    // DQDT
     int32_t           pages_var;       /*! pages number increment from last DQQT update   */
     int32_t           threads_var;     /*! threads number increment from last DQDT update */
@@ -132 +134 @@
         dqdt_node_t       dqdt_tbl[CONFIG_MAX_DQDT_DEPTH];     /*! embedded DQDT nodes        */
 
+    // Local process manager
     pmgr_t            pmgr;            /*! embedded process manager                       */
 

trunk/kernel/kern/core.c

@@ -50 +50 @@
         core->usage             = 0;
         core->spurious_irqs     = 0;
-    core->rpc_threads       = 0;
         core->thread_idle       = NULL;
         core->fpu_owner         = NULL;

trunk/kernel/kern/core.h

@@ -56 +56 @@
         uint32_t            usage;          /*! cumulated busy_percent (idle / total)      */
         uint32_t            spurious_irqs;  /*! for instrumentation...                     */
-    uint32_t            rpc_threads;    /*! current RPC threads number for this core   */
-        struct thread_s   * thread_rpc;     /*! pointer on current RPC thread descriptor   */
         struct thread_s   * thread_idle;    /*! pointer on idle thread descriptor          */
         struct thread_s   * fpu_owner;      /*! pointer on current FPU owner thread        */

trunk/kernel/kern/kernel_init.c

@@ -28 +28 @@
 #include <hal_special.h>
 #include <hal_context.h>
+#include <hal_irqmask.h>
 #include <barrier.h>
 #include <remote_barrier.h>
@@ -59 +60 @@
 
 ///////////////////////////////////////////////////////////////////////////////////////////
-// All these global variables are replicated in all clusters.
+// All the following global variables are replicated in all clusters.
 // They are initialised by the kernel_init() function.
 //
@@ -135 +136 @@
            "    /_/        \\_\\ |______| |_|    |_|   \\_____/  |______/        |_|    |_|  |_|  \\_\\ |_|   |_|  \n"
            "\n\n\t\t Advanced Locality Management Operating System / Multi Kernel Hybrid\n"
-           "\n\n\t\t\t Version 0.0   :   %d clusters   /   %d cores per cluster\n\n", nclusters , ncores );
+           "\n\n\t\t\t Version 0.0 : %d cluster(s)   /   %d core(s) per cluster\n\n", nclusters , ncores );
 }
 
@@ -274 +275 @@
             }
 
-            if( local_cxy == 0 )
-            kinit_dmsg("\n[INFO] %s created MMC chdev in cluster 0 at cycle %d\n",
-                       __FUNCTION__ , local_cxy , (uint32_t)hal_time_stamp() );
+            kinit_dmsg("\n[INFO] %s created MMC in cluster %x / chdev = %x\n",
+                       __FUNCTION__ , channel , local_cxy , chdev_ptr );
         }
         ///////////////////////////////
@@ -301 +301 @@
                 chdev_dir.dma[channel] = XPTR( local_cxy , chdev_ptr );
 
-                kinit_dmsg("\n[INFO] %s created DMA[%d] chdev in cluster 0 at cycle %d\n",
-                           __FUNCTION__ , channel , (uint32_t)hal_time_stamp() );
+                kinit_dmsg("\n[INFO] %s created DMA[%d] in cluster %x / chdev = %x\n",
+                           __FUNCTION__ , channel , local_cxy , chdev_ptr );
             }
         }
@@ -433 +433 @@
                     }
 
-                            kinit_dmsg("\n[INFO] %s create chdev %s[%d] in cluster %x at cycle %d\n",
-                               __FUNCTION__ , chdev_func_str( func ), channel,
-                               local_cxy , (uint32_t)hal_time_stamp() );
+                            kinit_dmsg("\n[INFO] %s create chdev %s[%d] in cluster %x / chdev = %x\n",
+                    __FUNCTION__ , chdev_func_str( func ), channel , local_cxy , chdev );
 
                 }  // end if match
@@ -658 +657 @@
 }
 
+////////////////////////////////////////////////////////////////////////////////////////////
+// This function display on TXT0 the content of the external chdev directory,
+// in the local cluster.
+////////////////////////////////////////////////////////////////////////////////////////////
+static void chdev_dir_display( )
+{
+    cxy_t     iob_cxy  = GET_CXY( chdev_dir.iob );
+    chdev_t * iob_ptr  = (chdev_t *)GET_PTR( chdev_dir.iob );
+    xptr_t    iob_base = hal_remote_lwd( XPTR( iob_cxy , &iob_ptr->base ) );
+
+    cxy_t     pic_cxy  = GET_CXY( chdev_dir.pic );
+    chdev_t * pic_ptr  = (chdev_t *)GET_PTR( chdev_dir.pic );
+    xptr_t    pic_base = hal_remote_lwd( XPTR( pic_cxy , &pic_ptr->base ) );
+
+    cxy_t     txt0_cxy  = GET_CXY( chdev_dir.txt[0] );
+    chdev_t * txt0_ptr  = (chdev_t *)GET_PTR( chdev_dir.txt[0] );
+    xptr_t    txt0_base = hal_remote_lwd( XPTR( txt0_cxy , &txt0_ptr->base ) );
+
+    cxy_t     txt1_cxy  = GET_CXY( chdev_dir.txt[1] );
+    chdev_t * txt1_ptr  = (chdev_t *)GET_PTR( chdev_dir.txt[1] );
+    xptr_t    txt1_base = hal_remote_lwd( XPTR( txt1_cxy , &txt1_ptr->base ) );
+
+    cxy_t     txt2_cxy  = GET_CXY( chdev_dir.txt[2] );
+    chdev_t * txt2_ptr  = (chdev_t *)GET_PTR( chdev_dir.txt[2] );
+    xptr_t    txt2_base = hal_remote_lwd( XPTR( txt2_cxy , &txt2_ptr->base ) );
+
+    cxy_t     ioc_cxy  = GET_CXY( chdev_dir.ioc[0] );
+    chdev_t * ioc_ptr  = (chdev_t *)GET_PTR( chdev_dir.ioc[0] );
+    xptr_t    ioc_base = hal_remote_lwd( XPTR( ioc_cxy , &ioc_ptr->base ) );
+
+    cxy_t     fbf_cxy  = GET_CXY( chdev_dir.fbf[0] );
+    chdev_t * fbf_ptr  = (chdev_t *)GET_PTR( chdev_dir.fbf[0] );
+    xptr_t    fbf_base = hal_remote_lwd( XPTR( fbf_cxy , &fbf_ptr->base ) );
+
+    cxy_t     nic_rx_cxy  = GET_CXY( chdev_dir.nic_rx[0] );
+    chdev_t * nic_rx_ptr  = (chdev_t *)GET_PTR( chdev_dir.nic_rx[0] );
+    xptr_t    nic_rx_base = hal_remote_lwd( XPTR( nic_rx_cxy , &nic_rx_ptr->base ) );
+
+    cxy_t     nic_tx_cxy  = GET_CXY( chdev_dir.nic_tx[0] );
+    chdev_t * nic_tx_ptr  = (chdev_t *)GET_PTR( chdev_dir.nic_tx[0] );
+    xptr_t    nic_tx_base = hal_remote_lwd( XPTR( nic_tx_cxy , &nic_tx_ptr->base ) );
+
+    printk("\n*** external chdev directory in cluster %x\n"
+           "  - iob       = %l / base = %l\n"
+           "  - pic       = %l / base = %l\n"
+           "  - txt[0]    = %l / base = %l\n"
+           "  - txt[1]    = %l / base = %l\n"
+           "  - txt[2]    = %l / base = %l\n"
+           "  - ioc[0]    = %l / base = %l\n"
+           "  - fbf[0]    = %l / base = %l\n"
+           "  - nic_rx[0] = %l / base = %l\n"
+           "  - nic_tx[0] = %l / base = %l\n",
+           local_cxy,
+           chdev_dir.iob, iob_base,
+           chdev_dir.pic, pic_base,
+           chdev_dir.txt[0], txt0_base,
+           chdev_dir.txt[1], txt1_base,
+           chdev_dir.txt[2], txt2_base,
+           chdev_dir.ioc[0], ioc_base,
+           chdev_dir.fbf[0], fbf_base,
+           chdev_dir.nic_rx[0], nic_rx_base,
+           chdev_dir.nic_tx[0], nic_tx_base );
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////
 // This function is the entry point for the kernel initialisation.
@@ -683 +746 @@
 
     error_t      error;
+    uint32_t     status;                    // running core status register
 
     cxy_t        io_cxy = info->io_cxy;
@@ -732 +796 @@
     if( error )
     {
-        nolock_printk("\n[PANIC] in %s : illegal core identifiers"
+        printk("\n[PANIC] in %s : illegal core identifiers"
                " gid = %x / cxy = %x / lid = %d\n",
                __FUNCTION__ , core_lid , core_cxy , core_lid );
@@ -745 +809 @@
         if( error )
         {
-            nolock_printk("\n[PANIC] in %s : cannot initialise cluster %x",
+            printk("\n[PANIC] in %s : cannot initialise cluster %x",
                    __FUNCTION__ , local_cxy );
             hal_core_sleep();
@@ -764 +828 @@
     // STEP 2 : all CP0s initialize the process_zero descriptor.
     //          CP0 in cluster 0 initialises the IOPIC device.
-    //          all CP0s complete the distibuted LAPIC initialization.
     /////////////////////////////////////////////////////////////////////////////////
 
@@ -777 +840 @@
     if( (core_lid == 0) && (local_cxy == 0) ) iopic_init( info );
     
-    // all CP0s initialize their local LAPIC extension,
-    if( core_lid == 0 ) lapic_init( info );
-
     ////////////////////////////////////////////////////////////////////////////////
     if( core_lid == 0 ) remote_barrier( XPTR( io_cxy , &global_barrier ), 
@@ -791 +851 @@
 
     ////////////////////////////////////////////////////////////////////////////////
-    // STEP 3 : all CP0s initialize their local chdev descriptors
-    //          (both internal devices and external devices).
+    // STEP 3 : all CP0s complete the distibuted LAPIC initialization.
+    //          all CP0s initialize their internal chdev descriptors
+    //          all CP0s initialize their local external chdev descriptors
     ////////////////////////////////////////////////////////////////////////////////
+
+    // all CP0s initialize their local LAPIC extension,
+    if( core_lid == 0 ) lapic_init( info );
 
     // CP0 scan the internal (private) peripherals,
@@ -818 +882 @@
 
     /////////////////////////////////////////////////////////////////////////////////
-    // STEP 4 : Alls cores initialize their private IDLE thread.
+    // STEP 4 : All cores enable IPI (Inter Procesor Interrupt),
+    //          Alh cores initialize IDLE thread.
     //          Only CP0 in cluster 0 creates the VFS root inode.
     //          It access the boot device to initialize the file system context.
     /////////////////////////////////////////////////////////////////////////////////
 
-    // all cores create idle thread descriptor
+    if( CONFIG_KINIT_DEBUG ) chdev_dir_display();
+    
+    // All cores enable the shared IPI channel
+
+// @@@
+    hal_set_ebase( 0x1000 );
+// @@@
+
+    dev_pic_enable_ipi();
+    hal_enable_irq( &status );
+
+    kinit_dmsg("\n[INFO] %s : IRQs enabled for core[%x,%d] / SR = %x\n", 
+               __FUNCTION__ , local_cxy , core_lid , hal_get_sr() );
+
+    // all cores create the idle thread descriptor
     error = thread_kernel_init( thread,
                                 THREAD_IDLE,
@@ -831 +910 @@
     if( error )
     {
-        nolock_printk("\n[PANIC] in %s : core[%x][%d] cannot initialize idle thread\n",
+        printk("\n[PANIC] in %s : core[%x][%d] cannot initialize idle thread\n",
                       __FUNCTION__ , local_cxy , core_lid );
         hal_core_sleep();
@@ -860 +939 @@
             fatfs_ctx_t * fatfs_ctx = fatfs_ctx_alloc();
 
-            nolock_assert( (fatfs_ctx != NULL) , __FUNCTION__ ,
-                           "cannot create FATFS context in cluster 0\n" );
+            assert( (fatfs_ctx != NULL) , __FUNCTION__ ,
+                    "cannot create FATFS context in cluster 0\n" );
 
             // 2. access boot device to initialize FATFS context
@@ -883 +962 @@
                                       &vfs_root_inode_xp );                // return
 
-            nolock_assert( (error == 0) , __FUNCTION__ , 
-                           "cannot create VFS root inode\n" );
+            assert( (error == 0) , __FUNCTION__ , 
+                    "cannot create VFS root inode\n" );
 
             // 5. initialize VFS context for FAT in cluster 0
@@ -896 +975 @@
         else
         {
-            nolock_printk("\n[PANIC] in %s : root FS must be FATFS\n", __FUNCTION__ );
+            printk("\n[PANIC] in %s : root FS must be FATFS\n", __FUNCTION__ );
             hal_core_sleep();
         }
@@ -931 +1010 @@
             fatfs_ctx_t * fatfs_ctx = fatfs_ctx_alloc();
 
-            nolock_assert( (fatfs_ctx != NULL) , __FUNCTION__ ,
-                           "cannot create FATFS context\n" );
+            assert( (fatfs_ctx != NULL) , __FUNCTION__ ,
+                    "cannot create FATFS context\n" );
 
             // get local pointer on VFS context for FATFS
@@ -965 +1044 @@
     /////////////////////////////////////////////////////////////////////////////////
 
-    if( (core_lid ==  0) && (local_cxy == 0) ) 
+//    if( (core_lid ==  0) && (local_cxy == 0) ) 
     kinit_dmsg("\n[INFO] %s exit barrier 5 at cycle %d : VFS OK in all clusters\n",
                __FUNCTION__, (uint32_t)hal_time_stamp());
@@ -986 +1065 @@
         devfs_ctx_t * devfs_ctx = devfs_ctx_alloc();
 
-        nolock_assert( (devfs_ctx != NULL) , __FUNCTION__ ,
-                       "cannot create DEVFS context in cluster IO\n");
+        assert( (devfs_ctx != NULL) , __FUNCTION__ ,
+                "cannot create DEVFS context in cluster IO\n");
 
         // register DEVFS root and external directories
@@ -993 +1072 @@
     }    
 
+printk("\n@@@ %s : cluster %x reach barrier 6\n", __FUNCTION__ , local_cxy );
+
     /////////////////////////////////////////////////////////////////////////////////
     if( core_lid == 0 ) remote_barrier( XPTR( io_cxy , &global_barrier ), 
@@ -999 +1080 @@
     /////////////////////////////////////////////////////////////////////////////////
 
-    if( (core_lid ==  0) && (local_cxy == 0) ) 
+//    if( (core_lid ==  0) && (local_cxy == 0) ) 
     kinit_dmsg("\n[INFO] %s exit barrier 6 at cycle %d : DEVFS OK in cluster IO\n",
                __FUNCTION__, (uint32_t)hal_time_stamp());
@@ -1071 +1152 @@
         print_banner( (info->x_size * info->y_size) , info->cores_nr );
 
-        kinit_dmsg("\n\n*** memory fooprint of main kernet objects ***\n"
+        kinit_dmsg("\n\n*** memory fooprint for main kernet objects ***\n\n"
                    " - thread descriptor  : %d bytes\n"
                    " - process descriptor : %d bytes\n"
@@ -1114 +1195 @@
     }
 
-    // each core activates its private PTI IRQ
+    // each core activates its private TICK IRQ
     dev_pic_enable_timer( CONFIG_SCHED_TICK_PERIOD );
 

trunk/kernel/kern/printk.c

@@ -401 +401 @@
 }
 
-////////////////////////////////////////
-void nolock_printk( char * format , ...)
-{
-    va_list   args;
-
-    // call kernel_printf on TXT0, in busy waiting mode
-    va_start( args , format );
-    kernel_printf( 0 , 1 , format , &args );
-    va_end( args );
-}
-
 ///////////////////////////////////////////
 inline void assert( bool_t       condition,
@@ -424 +413 @@
 }
 
-//////////////////////////////////////////////////
-inline void nolock_assert( bool_t       condition,
-                           const char * function_name,
-                           char       * string )
-{
-    if( condition == false )
-    {
-        nolock_printk("\n[PANIC] in %s : %s\n" , function_name , string );
-        hal_core_sleep();
-    }
-}
-
-
 
 // Local Variables:

trunk/kernel/kern/printk.h

@@ -74 +74 @@
 
 /**********************************************************************************
- * This function displays a formated string on the kernel terminal TXT0,
- * using a busy waiting policy: It calls directly the relevant TXT driver, 
- * without taking the the lock protecting exclusive access to TXT0 terminal.
- **********************************************************************************
- * @ format     : formated string.
- *********************************************************************************/
-void nolock_printk( char* format, ... );
-
-/**********************************************************************************
  * This function displays a "PANIC" message and force the calling core in
  * sleeping mode if a Boolean condition is false.
@@ -95 +86 @@
                     char       * string );
 
-/**********************************************************************************
- * This function displays a "PANIC" message and force the calling core in
- * sleeping mode if a Boolean condition is false,
- * without taking the the lock protecting exclusive access to TXT0 terminal.
- **********************************************************************************
- * @ condition     : condition that must be true.
- * @ function_name : name of the calling function.
- * @ string        : error message if condition is false. 
- *********************************************************************************/
-inline void nolock_assert( bool_t       condition,
-                           const char * function_name,
-                           char       * string );
-
 ///////////////////////////////////////////////////////////////////////////////////
 //       Conditionnal debug macros
@@ -215 +193 @@
 
 #if CONFIG_KINIT_DEBUG
-#define kinit_dmsg(...) nolock_printk(__VA_ARGS__)
+#define kinit_dmsg(...) printk(__VA_ARGS__)
 #else
 #define kinit_dmsg(...)

trunk/kernel/kern/process.c

@@ -90 +90 @@
     pid_t       parent_pid;
 
-    process_dmsg("\n[INFO] %s : enters for process %x in cluster %x / parent_xp = %l\n",
-                 __FUNCTION__ , pid , parent_xp );
+    process_dmsg("\n[INFO] %s : enters for process %x in cluster %x\n",
+                 __FUNCTION__ , pid , local_cxy );
 
     // get parent process cluster, local pointer, and pid
@@ -198 +198 @@
     local_process->ref_xp = reference_process_xp;
 
+    process_dmsg("\n[INFO] %s : enter for process %x in cluster %x\n",
+                 __FUNCTION__ , local_process->pid );
+
     // reset children list root (not used in a process descriptor copy)
     xlist_root_init( XPTR( local_cxy , &local_process->children_root ) );
@@ -229 +232 @@
 
         hal_fence();
+
+    process_dmsg("\n[INFO] %s : exit for process %x in cluster %x\n",
+                 __FUNCTION__ , local_process->pid );
 
     return 0;

trunk/kernel/kern/rpc.c

@@ -101 +101 @@
     assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
 
+    rpc_dmsg("\n[INFO] %s : enter\n", __FUNCTION__ );
+
     // initialise RPC descriptor header 
     rpc_desc_t  rpc;
@@ -115 +117 @@
     *error  = (error_t)rpc.args[0];     
     *ppn    = (uint32_t)rpc.args[1];
+
+    rpc_dmsg("\n[INFO] %s : completed\n", __FUNCTION__ );
 }
 
@@ -153 +157 @@
     assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
 
+    rpc_dmsg("\n[INFO] %s : enter\n", __FUNCTION__ );
+
     // initialise RPC descriptor header 
     rpc_desc_t  rpc;
@@ -167 +173 @@
     *pid    = (pid_t)rpc.args[1];
     *error  = (error_t)rpc.args[2];     
+
+    rpc_dmsg("\n[INFO] %s : completed\n", __FUNCTION__ );
 }
 
@@ -204 +212 @@
     assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
 
+    rpc_dmsg("\n[INFO] %s : enter\n", __FUNCTION__ );
+
     // initialise RPC descriptor header 
     rpc_desc_t  rpc;
@@ -217 +227 @@
     // get output arguments from RPC descriptor
     *error  = (error_t)rpc.args[1];     
+
+    rpc_dmsg("\n[INFO] %s : completed\n", __FUNCTION__ );
 }
 
@@ -256 +268 @@
     assert( (GET_CXY( process->ref_xp ) == local_cxy) , __FUNCTION__ ,
             "caller must be reference process cluster\n");
+
+    rpc_dmsg("\n[INFO] %s : enter\n", __FUNCTION__ );
 
     // get local process index in reference cluster
@@ -282 +296 @@
         if( target_cxy != local_cxy ) rpc_send_sync( target_cxy , &rpc );
     }
+
+    rpc_dmsg("\n[INFO] %s : completed\n", __FUNCTION__ );
 }  
 
@@ -327 +343 @@
     assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
 
+    rpc_dmsg("\n[INFO] %s : enter\n", __FUNCTION__ );
+
     // initialise RPC descriptor header 
     rpc_desc_t  rpc;
@@ -344 +362 @@
     *thread_xp = (xptr_t)rpc.args[4];
     *error     = (error_t)rpc.args[5];
+
+    rpc_dmsg("\n[INFO] %s : completed\n", __FUNCTION__ );
 }
 
@@ -405 +425 @@
     assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
 
+    rpc_dmsg("\n[INFO] %s : enter\n", __FUNCTION__ );
+
     // initialise RPC descriptor header 
     rpc_desc_t  rpc;
@@ -421 +443 @@
     *thread_xp = (xptr_t)rpc.args[3];
     *error     = (error_t)rpc.args[4];
+
+    rpc_dmsg("\n[INFO] %s : completed\n", __FUNCTION__ );
 }
 
@@ -463 +487 @@
     assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
 
+    rpc_dmsg("\n[INFO] %s : enter\n", __FUNCTION__ );
+
     // initialise RPC descriptor header 
     rpc_desc_t  rpc;
@@ -474 +500 @@
     // register RPC request in remote RPC fifo 
     rpc_send_sync( cxy , &rpc );
+
+    rpc_dmsg("\n[INFO] %s : completed\n", __FUNCTION__ );
 }
 
@@ -513 +541 @@
     assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
 
+    rpc_dmsg("\n[INFO] %s : enter\n", __FUNCTION__ );
+
     // initialise RPC descriptor header 
     rpc_desc_t  rpc;
@@ -534 +564 @@
     *inode_xp = (xptr_t)rpc.args[8];
     *error    = (error_t)rpc.args[9];
+
+    rpc_dmsg("\n[INFO] %s : completed\n", __FUNCTION__ );
 }
 
@@ -590 +622 @@
     assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
 
+    rpc_dmsg("\n[INFO] %s : enter\n", __FUNCTION__ );
+
     // initialise RPC descriptor header 
     rpc_desc_t  rpc;
@@ -600 +634 @@
     // register RPC request in remote RPC fifo (blocking function)
     rpc_send_sync( cxy , &rpc );
+
+    rpc_dmsg("\n[INFO] %s : completed\n", __FUNCTION__ );
 }
 
@@ -632 +668 @@
     assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
 
+    rpc_dmsg("\n[INFO] %s : enter\n", __FUNCTION__ );
+
     // initialise RPC descriptor header 
     rpc_desc_t  rpc;
@@ -648 +686 @@
     *dentry_xp = (xptr_t)rpc.args[3];
     *error     = (error_t)rpc.args[4];
+
+    rpc_dmsg("\n[INFO] %s : completed\n", __FUNCTION__ );
 }
 
@@ -695 +735 @@
     assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
 
+    rpc_dmsg("\n[INFO] %s : enter\n", __FUNCTION__ );
+
     // initialise RPC descriptor header 
     rpc_desc_t  rpc;
@@ -705 +747 @@
     // register RPC request in remote RPC fifo (blocking function)
     rpc_send_sync( cxy , &rpc );
+
+    rpc_dmsg("\n[INFO] %s : completed\n", __FUNCTION__ );
 }
 
@@ -737 +781 @@
     assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
 
+    rpc_dmsg("\n[INFO] %s : enter\n", __FUNCTION__ );
+
     // initialise RPC descriptor header 
     rpc_desc_t  rpc;
@@ -752 +798 @@
     *file_xp = (xptr_t)rpc.args[2];
     *error   = (error_t)rpc.args[3];
+
+    rpc_dmsg("\n[INFO] %s : completed\n", __FUNCTION__ );
 }
 
@@ -790 +838 @@
     assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
 
+    rpc_dmsg("\n[INFO] %s : enter\n", __FUNCTION__ );
+
     // initialise RPC descriptor header 
     rpc_desc_t  rpc;
@@ -800 +850 @@
     // register RPC request in remote RPC fifo (blocking function)
     rpc_send_sync( cxy , &rpc );
+
+    rpc_dmsg("\n[INFO] %s : completed\n", __FUNCTION__ );
 }
 
@@ -831 +883 @@
     assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
 
+    rpc_dmsg("\n[INFO] %s : enter\n", __FUNCTION__ );
+
     // initialise RPC descriptor header 
     rpc_desc_t  rpc;
@@ -846 +900 @@
     // get output values from RPC descriptor
     *error   = (error_t)rpc.args[3];
+
+    rpc_dmsg("\n[INFO] %s : completed\n", __FUNCTION__ );
 }
 
@@ -889 +945 @@
     assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
 
+    rpc_dmsg("\n[INFO] %s : enter\n", __FUNCTION__ );
+
     // initialise RPC descriptor header 
     rpc_desc_t  rpc;
@@ -902 +960 @@
     // get output values from RPC descriptor
     *error   = (error_t)rpc.args[1];
+
+    rpc_dmsg("\n[INFO] %s : completed\n", __FUNCTION__ );
 }
 
@@ -938 +998 @@
     assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
 
+    rpc_dmsg("\n[INFO] %s : enter\n", __FUNCTION__ );
+
     // initialise RPC descriptor header 
     rpc_desc_t  rpc;
@@ -954 +1016 @@
     *cluster = (uint32_t)rpc.args[3];
     *error   = (error_t)rpc.args[4];
+
+    rpc_dmsg("\n[INFO] %s : completed\n", __FUNCTION__ );
 }
 
@@ -994 +1058 @@
     assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
 
+    rpc_dmsg("\n[INFO] %s : enter\n", __FUNCTION__ );
+
     // initialise RPC descriptor header 
     rpc_desc_t  rpc;
@@ -1008 +1074 @@
     // get output argument from rpc descriptor
     *vseg_xp = rpc.args[2];
+
+    rpc_dmsg("\n[INFO] %s : completed\n", __FUNCTION__ );
 }
 
@@ -1050 +1118 @@
     assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
 
+    rpc_dmsg("\n[INFO] %s : enter\n", __FUNCTION__ );
+
     // initialise RPC descriptor header 
     rpc_desc_t  rpc;
@@ -1066 +1136 @@
     *ppn   = (ppn_t)rpc.args[3];
     *error = (error_t)rpc.args[4];
+
+    rpc_dmsg("\n[INFO] %s : completed\n", __FUNCTION__ );
 }
 
@@ -1105 +1177 @@
     assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
 
+    rpc_dmsg("\n[INFO] %s : enter\n", __FUNCTION__ );
+
     // initialise RPC descriptor header 
     rpc_desc_t  rpc;
@@ -1118 +1192 @@
     // get output arguments from RPC descriptor
     *buf_xp = (xptr_t)rpc.args[1];
+
+    rpc_dmsg("\n[INFO] %s : completed\n", __FUNCTION__ );
 }
 
@@ -1152 +1228 @@
     assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
 
+    rpc_dmsg("\n[INFO] %s : enter\n", __FUNCTION__ );
+
     // initialise RPC descriptor header 
     rpc_desc_t  rpc;
@@ -1163 +1241 @@
     // register RPC request in remote RPC fifo 
     rpc_send_sync( cxy , &rpc );
+
+    rpc_dmsg("\n[INFO] %s : completed\n", __FUNCTION__ );
 }
 
@@ -1199 +1279 @@
     assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
 
+    rpc_dmsg("\n[INFO] %s : enter\n", __FUNCTION__ );
+
     // initialise RPC descriptor header 
     rpc_desc_t  rpc;
@@ -1217 +1299 @@
     // get output values from RPC descriptor
     *error     = (error_t)rpc.args[6];
+
+    rpc_dmsg("\n[INFO] %s : completed\n", __FUNCTION__ );
 }
 
@@ -1262 +1346 @@
                     rpc_desc_t * rpc )
 {
-        thread_t * this = CURRENT_THREAD;
     uint32_t   cores;
     error_t    error;
@@ -1268 +1351 @@
     reg_t      sr_save;
 
-    // get client CPU and cluster coordinates
-    cxy_t      client_cxy = local_cxy;   
-    lid_t      client_lid = CURRENT_CORE->lid;
+    thread_t * this = CURRENT_THREAD;
+
+    rpc_dmsg("\n[INFO] %s : enter / client_cxy = %x / server_cxy = %x\n",
+             __FUNCTION__ , local_cxy , server_cxy );
 
     // allocate and initialise an extended pointer on the RPC descriptor
-        xptr_t   xp = XPTR( client_cxy , rpc );
-
-    // get local pointer on rpc_fifo in remote cluster with the 
-    // assumption that addresses are identical in all clusters
+        xptr_t   desc_xp = XPTR( local_cxy , rpc );
+
+    // get local pointer on rpc_fifo in remote cluster, with the 
+    // assumption that rpc_fifo pddresses are identical in all clusters
     rpc_fifo_t * rf = &LOCAL_CLUSTER->rpc_fifo;
 
@@ -1284 +1368 @@
     { 
         error = remote_fifo_put_item( XPTR( server_cxy , &rf->fifo ),
-                                      (uint64_t *)&xp,
+                                      (uint64_t )desc_xp,
                                       &first );
 
             if ( error ) 
         {
-            printk("\n[WARNING] %s : core %d in cluster %x cannot post RPC to cluster %x\n",
-                   __FUNCTION__ , client_lid , client_cxy , server_cxy );
+            printk("\n[WARNING] %s : cluster %x cannot post RPC to cluster %x\n",
+                   __FUNCTION__ , local_cxy , server_cxy );
+
             if( thread_can_yield() ) sched_yield();
+        }
+        else
+        {
         }
     }
     while( error );
  
-    rpc_dmsg("\n[INFO] %s on core %d in cluster %x sent RPC %p to cluster %x\n", 
-              __FUNCTION__ , client_lid , client_cxy , rpc , server_cxy );
+    rpc_dmsg("\n[INFO] %s : RPC registered / client_cxy = %x / server_cxy = %x\n",
+             __FUNCTION__ , local_cxy , server_cxy , first );
         
-    // send IPI if this is the first RPC in remote FIFO
-    // and no CPU is in kernel mode in server cluster.
-    // the selected CPU in server has the same lid as the client CPU.
+    // send IPI to remote CP0, if this is the first RPC in remote FIFO,
+    // and there is no CPU is in kernel mode in server cluster.
         if( first )
         {
@@ -1309 +1396 @@
                 if( cores == 0 ) // no core in kernel mode in server
                 {
-                    dev_pic_send_ipi( server_cxy , client_lid );
-
-                    rpc_dmsg("\n[INFO] %s : core %d in cluster %x send IPI to core %d in cluster %x\n",
-                      __FUNCTION__, client_lid , client_cxy , client_lid , server_cxy );
+                    dev_pic_send_ipi( server_cxy , 0 );
+
+                    rpc_dmsg("\n[INFO] %s : IPI sent / client_cxy = %x / server_cxy = %x\n",
+                     __FUNCTION__, local_cxy , server_cxy );
         }
         }
 
-        // activate preemption to allow incoming RPC and avoid deadlock
+        // enable IRQs to allow incoming RPC and avoid deadlock
         if( this->type == THREAD_RPC ) hal_enable_irq( &sr_save );
 
-    // the sending thread poll the response slot until RPC completed
+    // the server thread poll the response slot until RPC completed
+    // TODO this could be replaced by a descheduling policy... [AG]
         while( 1 )
     {
@@ -1325 +1413 @@
     }
 
-    // restore preemption
+    // restore IRQs
         if( this->type == THREAD_RPC ) hal_restore_irq( sr_save );
+
+    rpc_dmsg("\n[INFO] %s : completed / client_cxy = %x / server_cxy = %x\n",
+             __FUNCTION__ , local_cxy , server_cxy );
 
 }  // end rpc_send_sync()
@@ -1344 +1435 @@
 }
 
-////////////////////////////////////////////////
-error_t rpc_execute_all( rpc_fifo_t * rpc_fifo )
+/////////////////////////////////////////////
+void rpc_execute_all( rpc_fifo_t * rpc_fifo )
 {
         xptr_t         xp;             // extended pointer on RPC descriptor
@@ -1353 +1444 @@
     rpc_desc_t   * desc;           // pointer on RPC descriptor 
     uint32_t       index;          // RPC index 
-    uint32_t       expected;       // number of expected responses 
     cxy_t          client_cxy;     // client cluster identifier
         error_t        error;
@@ -1370 +1460 @@
                 if ( error == 0 )  // One RPC request successfully extracted from RPC_FIFO
         {
-            rpc_dmsg("\n[INFO] %s : RPC_THREAD %x on core %x in cluster %x handles RPC %d\n"
+            rpc_dmsg("\n[INFO] %s : RPC_THREAD %x on core %x in cluster %x handles RPC %d\n",
                                      __FUNCTION__ , this->trdid , core->lid , local_cxy , count );
 
@@ -1377 +1467 @@
             desc       = (rpc_desc_t *)GET_PTR( xp );
 
-            // get rpc index and expected responses from RPC descriptor
+            // get rpc index from RPC descriptor
                 index     = hal_remote_lw( XPTR( client_cxy , &desc->index ) );
-                expected  = hal_remote_lw( XPTR( client_cxy , &desc->response ) );
 
             // call the relevant server function
@@ -1388 +1477 @@
 
             // notify RPC completion as required
-            if( expected == 1 ) hal_remote_sw( XPTR(client_cxy,&desc->response) , 0 );
-            if( expected >  1 ) hal_remote_atomic_add( XPTR(client_cxy,&desc->response) , -1 );
+            hal_remote_atomic_add( XPTR(client_cxy,&desc->response) , -1 );
                 }
         
@@ -1400 +1488 @@
             (count > CONFIG_RPC_PENDING_MAX) ) break;
         }
-    while( 1 )
-
-        rpc_dmsg("\n[INFO] %s running on core %d in cluster %x exit\n"
-              __FUNCTION__ , CURRENT_CORE->lid , local_cxy );
-                
+    while( 1 );
+
     // update RPC_FIFO global counter
         rpc_fifo->count += count;
 
-        return 0;
 }  // end rpc_execute_all()
 
@@ -1422 +1506 @@
     reg_t         sr_save;
 
+    
         this   = CURRENT_THREAD;
     core   = this->core;
@@ -1427 +1512 @@
     found  = false;
 
-    // calling thread must be the RPC_FIFO owner
-    if( this->trdid != rpc_fifo->owner )
-    {
-        printk("\n[PANIC] in %s : calling thread is not RPC_FIFO owner\n", __FUNCTION__ );
-        hal_core_sleep();
-    }
+    assert( (this->trdid == rpc_fifo->owner) , __FUNCTION__ ,
+          "calling thread is not RPC_FIFO owner\n" );
 
     // makes the calling thread not preemptable
@@ -1443 +1524 @@
     {
         thread = LIST_ELEMENT( iter , thread_t , sched_list );
-        if( (thread->type == THREAD_RPC) && (thread->blocked ==  THREAD_BLOCKED_IDLE ) ) 
+        if( (thread->type == THREAD_RPC) && (thread->blocked == THREAD_BLOCKED_IDLE ) ) 
         {
             found = true;
@@ -1453 +1534 @@
     {
         thread->blocked = 0;
+
+        rpc_dmsg("\n[INFO] %s : activate RPC thread %x on core %x in cluster %x at cycle %d\n", 
+                          __FUNCTION__ , thread , core->gid , local_cxy , hal_get_cycles() );
     }
     else                           // create a new RPC thread
@@ -1469 +1553 @@
         }
 
-        rpc_dmsg("\n[INFO] %s creates RPC thread %x on core %x in cluster %x at cycle %d\n", 
+        rpc_dmsg("\n[INFO] %s : create RPC thread %x on core %x in cluster %x at cycle %d\n", 
                           __FUNCTION__ , thread , core->gid , local_cxy , hal_get_cycles() );
 
         // update core descriptor counter  
-            hal_atomic_add( &core->rpc_threads , 1 );
+            hal_atomic_add( &LOCAL_CLUSTER->rpc_threads , 1 );
     }
 
     // update owner in rpc_fifo
     rpc_fifo->owner = thread->trdid;
-
-    rpc_dmsg ("\n[INFO] %s activates RPC thread %x on core %x in cluster %x at cycle %d\n",
-                      __FUNCTION__ , thread , core->gid , local_cxy , hal_get_cycles() );
 
     // current thread deschedules / RPC thread start execution 
@@ -1506 +1587 @@
     }
 
-        // calling thread tries to take the light lock,
-    // and activates an RPC thread if success
+        // try to take the light lock, and activates an RPC thread if success
     if( hal_atomic_test_set( &rpc_fifo->owner , this->trdid ) )
         {
@@ -1543 +1623 @@
 
     // this infinite loop is not preemptable
-    // the RPC thread deschedule when the RPC_FIFO is empty
+    // the RPC thread deschedule only when the RPC_FIFO is empty
         while(1)
         {
@@ -1561 +1641 @@
 
 
-        // suicide if too much RPC threads for this core
-                if( this->core->rpc_threads > CONFIG_RPC_THREADS_MAX ) 
+        //  block and deschedule or sucide
+                if( LOCAL_CLUSTER->rpc_threads >= CONFIG_RPC_THREADS_MAX ) 
                 {
             rpc_dmsg("\n[INFO] RPC thread %x suicide on core %d in cluster %x at cycle %d\n", 
@@ -1568 +1648 @@
 
             // update core descriptor counter
-                hal_atomic_add( &this->core->rpc_threads , -1 );
+                hal_atomic_add( &LOCAL_CLUSTER->rpc_threads , -1 );
 
             // suicide
                         thread_exit();
                 }
-
-        // block and deschedule
-        rpc_dmsg("\n[INFO] RPC thread %x deschedule on core %d in cluster %x at cycle %d\n", 
-                              this->trdid , this->core->lid , local_cxy , hal_get_cycles() ); 
-
-                thread_block( this , THREAD_BLOCKED_IDLE );
-        sched_yield();
-
-                rpc_dmsg("\n[INFO] RPC thread %x wake up on core %d in cluster %x at cycle %d\n", 
-                              this->trdid , this->core->lid , local_cxy , hal_get_cycles() );
-        }
+        else
+        {
+            rpc_dmsg("\n[INFO] RPC thread %x blocks on core %d in cluster %x at cycle %d\n", 
+                                 this->trdid , this->core->lid , local_cxy , hal_get_cycles() ); 
+
+                     thread_block( this , THREAD_BLOCKED_IDLE );
+             sched_yield();
+
+                     rpc_dmsg("\n[INFO] RPC thread %x wake up on core %d in cluster %x at cycle %d\n", 
+                          this->trdid , this->core->lid , local_cxy , hal_get_cycles() );
+        }
+        } // end while
 } // end rpc_thread_func()
 

trunk/kernel/kern/rpc.h

@@ -158 +158 @@
  * This function is the entry point for RPC handling on the server side.
  * It can be executed by any thread running (in kernel mode) on any core.
- * It first checks the core private RPC fifo, an then the cluster shared RPC fifo.
- * It calls the rpc_activate_thread() function to activate a dedicated RPC thread.
- ***********************************************************************************
- * @ returns true if at least one RPC found / false otherwise.
+ * It checks the RPC fifo, try to take the light-lock and activates (or creates)
+ * an RPC thread in case of success.
+ ***********************************************************************************
+ * @ returns true if success / false otherwise.
  **********************************************************************************/
 bool_t rpc_check();
@@ -170 +170 @@
  ***********************************************************************************
  * @ rpc_fifo  : pointer on the local RPC fifo
- * @ returns 0 if success
- **********************************************************************************/
-error_t rpc_execute_all( rpc_fifo_t * rpc_fifo );
+ **********************************************************************************/
+void rpc_execute_all( rpc_fifo_t * rpc_fifo );
 
 /**********************************************************************************

trunk/kernel/kern/scheduler.c

@@ -41 +41 @@
     sched->k_threads_nr   = 0;
 
-    sched->current        = NULL;
-    sched->idle           = NULL;
-    sched->u_last         = NULL;
-    sched->k_last         = NULL;
+    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()
 
     // initialise threads lists
@@ -62 +62 @@
     spinlock_lock( &sched->lock );
 
-    // register thread
     if( type == THREAD_USER )
     {
+        // register thread in scheduler user list
         list_add_last( &sched->u_root , &thread->sched_list );
         sched->u_threads_nr++;
+
+        // initialize u_last field if first user thread
+        if( sched->u_last == NULL ) sched->u_last = &thread->sched_list;
     }
     else // kernel thread
     {
+        // register thread in scheduler kernel list
         list_add_last( &sched->k_root , &thread->sched_list );
         sched->k_threads_nr++;
+
+        // initialize k_last field if first kernel thread
+        if( sched->k_last == NULL ) sched->k_last = &thread->sched_list; 
     }
 
@@ -89 +96 @@
     spinlock_lock( &sched->lock );
 
-    // remove thread
     if( type == THREAD_USER )
     {
+        // remove thread from user list
         list_unlink( &thread->sched_list );
         sched->u_threads_nr--;
+
+        // reset the u_last field if list empty
+        if( sched->u_threads_nr == 0 ) sched->u_last = NULL;
     }
     else // kernel thread 
     {
+        // remove thread from kernel list
         list_unlink( &thread->sched_list );
         sched->k_threads_nr--;
+
+        // reset the k_last field if list empty
+        if( sched->k_threads_nr == 0 ) sched->k_last = NULL;
     }
 
@@ -140 +154 @@
     list_entry_t * last;
 
-    // first scan the kernel threads
-    last    = sched->k_last;
-    current = sched->k_last;
-    do
-    {
-        // get next entry in kernel list
-        current = list_next( &sched->k_root , current );
-
-        // skip the list root that does not contain a thread
-        if( current == NULL ) continue;
-
-        // get thread pointer
-        thread = LIST_ELEMENT( current , thread_t , sched_list );
-
-        // return thread if not blocked
-        if( thread->blocked == 0 ) 
+    // first : scan the kernel threads list,
+    // only if this list is not empty 
+    if( list_is_empty( &sched->k_root ) == false )
+    {
+        last    = sched->k_last;
+        current = sched->k_last;
+        do
         {
-            // release lock 
-            spinlock_unlock( &sched->lock );
-            return thread;
+            // get next entry in kernel list
+            current = list_next( &sched->k_root , current );
+
+            // skip the root that does not contain a thread
+            if( current == NULL ) current = sched->k_root.next;
+
+            // get thread pointer for this entry
+            thread = LIST_ELEMENT( current , thread_t , sched_list );
+
+            // return thread if runnable
+            if( thread->blocked == 0 ) 
+            {
+                // release lock 
+                spinlock_unlock( &sched->lock );
+                return thread;
+            }
         }
-    }
-    while( current != last );
-
-    // second scan the user threads
-    last    = sched->u_last;
-    current = sched->u_last;
-    do
-    {
-        // get next entry in user list
-        current = list_next( &sched->u_root , current );
-
-        // skip the list root that does not contain a thread
-        if( current == NULL ) continue;
-
-        // get thread pointer
-        thread = LIST_ELEMENT( current , thread_t , sched_list );
-
-        // return thread if not blocked
-        if( thread->blocked == 0 )
+        while( current != last );
+    }
+
+    // second : scan the user threads list,
+    // only if this list is not empty 
+    if( list_is_empty( &sched->u_root ) == false )
+    {
+        last    = sched->u_last;
+        current = sched->u_last;
+        do
         {
-            // release lock 
-            spinlock_unlock( &sched->lock );
-            return thread;
+            // get next entry in user list
+            current = list_next( &sched->u_root , current );
+
+            // skip the root that does not contain a thread
+            if( current == NULL ) current = sched->u_root.next;
+
+            // get thread pointer for this entry
+            thread = LIST_ELEMENT( current , thread_t , sched_list );
+
+            // return thread if runnable
+            if( thread->blocked == 0 )
+            {
+                // release lock 
+                spinlock_unlock( &sched->lock );
+                return thread;
+            }
         }
-    }
-    while( current != last );
+        while( current != last );
+    }
 
     // release lock 
     spinlock_unlock( &sched->lock );
 
-    // third, return idle thread if no runnable thread
+    // third : return idle thread if no runnable thread
     return sched->idle;
 
@@ -234 +256 @@
     thread_t    * current = CURRENT_THREAD;
     core_t      * core    = current->core;
+    scheduler_t * sched   = &core->scheduler;
 
     if( thread_can_yield() == false )
@@ -265 +288 @@
                __FUNCTION__, core->lid, local_cxy, current->trdid, next->trdid );
 
-    // switch contexts if new thread
+    // switch contexts and update scheduler state if new thread
         if( next != current )  
         {
         hal_cpu_context_save( current );
         hal_cpu_context_restore( next );
+
+        if( current->type == THREAD_USER ) sched->u_last = &current->sched_list;
+        else                               sched->k_last = &current->sched_list;
+
+        sched->current = next;
         }
 

trunk/kernel/kern/scheduler.h

@@ -34 +34 @@
 struct thread_s;
 
-/***********************************************************************************************
+/*********************************************************************************************
  * This structure define the scheduler associated to a given core.
  * WARNING : the idle thread is executed when there is no runable thread in the list 
  * of attached threads, but is NOT part of the list of attached threads.
- **********************************************************************************************/
+ ********************************************************************************************/
 
 typedef struct scheduler_s
 {
-    spinlock_t        lock;         /*! readlock protecting lists of threads                  */
-    uint16_t          u_threads_nr; /*! total numbre of attached user threads                 */
-    uint16_t          k_threads_nr; /*! total number of attached kernel threads               */
-    list_entry_t      u_root;       /*! root of list of user threads for this scheduler       */
-    list_entry_t      k_root;       /*! root of list of kernel threads for this scheduler     */
-    list_entry_t    * u_last;       /*! pointer on list_entry for last executed kernel thread */
-    list_entry_t    * k_last;       /*! pointer on list entry for last executed user thread   */
-    struct thread_s * idle;         /*! pointer on idle thread                                */
-    struct thread_s * current;      /*! pointer on current running thread                     */
+    spinlock_t        lock;         /*! readlock protecting lists of threads                */
+    uint16_t          u_threads_nr; /*! total numbre of attached user threads               */
+    uint16_t          k_threads_nr; /*! total number of attached kernel threads             */
+    list_entry_t      u_root;       /*! root of list of user threads for this scheduler     */
+    list_entry_t      k_root;       /*! root of list of kernel threads for this scheduler   */
+    list_entry_t    * u_last;       /*! pointer on list_entry for last executed k_thread    */
+    list_entry_t    * k_last;       /*! pointer on list entry for last executed u_thread    */
+    struct thread_s * idle;         /*! pointer on idle thread                              */
+    struct thread_s * current;      /*! pointer on current running thread                   */
 }
 scheduler_t;
 
-/***********************************************************************************************
+/*********************************************************************************************
  *  This function initialises the scheduler for a given core.
- **********************************************************************************************/  
+ ********************************************************************************************/  
 void sched_init( struct core_s * core );
 
-/***********************************************************************************************
+/*********************************************************************************************
  * This function register a new thread in a given core scheduler.
- ***********************************************************************************************
+ *********************************************************************************************
  * @ core    : local pointer on the core descriptor.
  * @ thread  : local pointer on the thread descriptor.
- **********************************************************************************************/  
+ ********************************************************************************************/  
 void sched_register_thread( struct core_s   * core,
                             struct thread_s * thread );
 
-/*********************************************************************************************** 
+/********************************************************************************************* 
  *  This function removes a thread from the set of threads attached to a given core.
- ***********************************************************************************************
+ *********************************************************************************************
  * @ thread  : local pointer on the thread descriptor.
- **********************************************************************************************/  
+ ********************************************************************************************/  
 void sched_remove_thread( struct thread_s * thread );
 
-/*********************************************************************************************** 
+/********************************************************************************************* 
  * This function handles pending signals for all registered threads, and tries to make 
  * a context switch for the core running the calling thread.
@@ -82 +82 @@
  * - If there is no other runable thread, the calling thread continues execution.
  * - If there is no runable thread, the idle thread is executed.
- **********************************************************************************************/
+ ********************************************************************************************/
 void sched_yield();
 
-/*********************************************************************************************** 
+/********************************************************************************************* 
  * This function handles pending signals for all registered threads, and make 
  * a context switch to the thread defined by the <thread> argument.
  * If the selected thread is not attached to the same core as the calling thread,
  * or is blocked, it causes a kernel panic.
- ***********************************************************************************************
+ *********************************************************************************************
  * @ new   : local pointer on the thread to run.
- **********************************************************************************************/
+ ********************************************************************************************/
 void sched_switch_to( struct thread_s * new );
 
-/***********************************************************************************************
+/*********************************************************************************************
  * This function scan all threads attached to a given core scheduler, and executes
  * the relevant actions for pending signals, such as the THREAD_SIG_KILL signal.
- ***********************************************************************************************
+ *********************************************************************************************
  * @ core    : local pointer on the core descriptor.
- **********************************************************************************************/
+ ********************************************************************************************/
 void sched_handle_signals( struct core_s * core );
 
-/*********************************************************************************************** 
+/********************************************************************************************* 
  * This function is used by the scheduler of a given core to actually kill a thread that has 
  * the SIG_KILL signal set (following a thread_exit() or a thread_kill() event).
@@ -110 +110 @@
  * - It removes the thread from the scheduler.
  * - It release physical memory allocated for thread descriptor.
- ***********************************************************************************************
+ *********************************************************************************************
  * @ thread  : local pointer on the thread descriptor.
- **********************************************************************************************/
+ ********************************************************************************************/
 void sched_kill_thread( struct thread_s * thread );
 
-/***********************************************************************************************
+/*********************************************************************************************
  * This function does NOT modify the scheduler state.
  * It just select a thread in the list of attached threads, implementing the following policy: 
@@ -123 +123 @@
  *    the last executed one, and returns the first runable found (can be the current thread).
  * 3) if no runable thread found, it returns the idle thread.
- ***********************************************************************************************
+ *********************************************************************************************
  * @ core    : local pointer on the core descriptor.
  * @ returns pointer on selected thread descriptor
- **********************************************************************************************/
+ ********************************************************************************************/
 struct thread_s * sched_select( struct core_s * core );
 
-/*********************************************************************************************** 
+/********************************************************************************************* 
  * This function scan the list of kernel threads to find an idle (blocked) RPC thread.
- ***********************************************************************************************
+ *********************************************************************************************
  * @ core    : local pointer on the core descriptor.
  * @ returns pointer on RPC thread descriptor / returns NULL if no idle RPC thread.
- **********************************************************************************************/
+ ********************************************************************************************/
 struct thread_s * sched_get_rpc_thead( struct core_s * core );
 

trunk/kernel/kern/thread.h

@@ -213 +213 @@
 
     uint32_t            dev_channel;     /*! device channel for a DEV thread          */
-    union                                /*! embedded command for a DEV thread        */
-    {
-        ioc_command_t   ioc;             /*! IOC device generic command               */
-        txt_command_t   txt;             /*! TXT device generic command               */
-        nic_command_t   nic;             /*! NIC device generic command               */
-        mmc_command_t   mmc;             /*! MMC device generic command               */
-        dma_command_t   dma;             /*! DMA device generic command               */
-    }
-    command;
+
+    ioc_command_t       ioc_cmd;         /*! IOC device generic command               */
+    txt_command_t       txt_cmd;         /*! TXT device generic command               */
+    nic_command_t       nic_cmd;         /*! NIC device generic command               */
+    mmc_command_t       mmc_cmd;         /*! MMC device generic command               */
+    dma_command_t       dma_cmd;         /*! DMA device generic command               */
 
         cxy_t               rpc_client_cxy;  /*! client cluster index (for a RPC thread)  */