Changeset 5 for trunk/kernel/kern

Timestamp:

Apr 26, 2017, 2:11:56 PM (8 years ago)

Author:

alain

Message:

Introduce the chdev_t structure in place of the device_t structure.

Location:

trunk/kernel/kern

Files:

• blkio.c (modified) (1 diff)
• chdev.c (added)
• chdev.h (added)
• cluster.c (modified) (3 diffs)
• cluster.h (modified) (3 diffs)
• core.c (modified) (4 diffs)
• core.h (modified) (3 diffs)
• device.c (deleted)
• device.h (deleted)
• do_interrupt.c (modified) (1 diff)
• dqdt.c (modified) (1 diff)
• event.c (modified) (1 diff)
• kernel_init.c (modified) (17 diffs)
• printk.c (modified) (8 diffs)
• printk.h (modified) (14 diffs)
• process.c (modified) (1 diff)
• remote_sem.c (modified) (1 diff)
• rpc.c (modified) (10 diffs)
• rpc.h (modified) (2 diffs)
• signal.c (modified) (4 diffs)
• signal.h (modified) (3 diffs)
• thread.c (modified) (16 diffs)
• thread.h (modified) (2 diffs)

trunk/kernel/kern/blkio.c

@@ -26 +26 @@
 #include <kmem.h>
 #include <thread.h>
-#include <device.h>
+#include <chdev.h>
 #include <driver.h>
 #include <event.h>

trunk/kernel/kern/cluster.c

@@ -48 +48 @@
 ///////////////////////////////////////////////////////////////////////////////////////////
 
-process_t process_zero;
+process_t process_zero;     // allocated in kernel_init.c file
 
 
@@ -78 +78 @@
     cluster->cores_in_kernel = info->cores_nr;   // all cpus start in kernel mode
 
-    // initialize kcm lock
+    // initialize the lock protectig the embedded kcm allocator
         spinlock_init( &cluster->kcm_lock );
-
-    // initialize txt0 lock
-        remote_spinlock_init( XPTR( local_cxy , &cluster->txt0_lock ) );
 
     // initialises DQDT 
@@ -100 +97 @@
   
     // initialises embedded KCM 
-        kcm_init( &cluster->kcm , KMEM_KCM ); 
-
-    // initialises cores
+        kcm_init( &cluster->kcm , KMEM_KCM );
+
+    // initialises all cores descriptors
         for( lid = 0 ; lid < cluster->cores_nr; lid++ )
         {

trunk/kernel/kern/cluster.h

@@ -98 +98 @@
         spinlock_t        kcm_lock;           /*! local, protect creation of KCM allocators   */
     remote_barrier_t  barrier;            /*! used to synchronize kernel parallel init    */
-    remote_spinlock_t txt0_lock;          /*! global, only cluster_io lock is used        */
 
     // global parameters
@@ -115 +114 @@
     uint32_t          cores_in_kernel;    /*! number of cores currently in kernel mode    */
 
-        core_t            core_tbl[CONFIG_MAX_CORES_PER_CLUSTER];         /*! embedded cores  */
+        core_t            core_tbl[CONFIG_MAX_LOCAL_CORES];         /*! embedded cores        */
 
         ppm_t             ppm;                /*! embedded kernel page manager                */
@@ -145 +144 @@
  * This global variable is allocated in the kernel_init.c file.
  * There is one cluster_manager per cluster, with the same local address, 
- * but different value, in all clusters containing a kernel instance. 
+ * but different content, in all clusters containing a kernel instance. 
  *****************************************************************************************/
 

trunk/kernel/kern/core.c

@@ -30 +30 @@
 #include <printk.h>
 #include <thread.h>
+#include <chdev.h>
 #include <dev_icu.h>
 #include <rpc.h>
@@ -41 +42 @@
 /////////////////////////////////
 void core_init( core_t    * core, 
-                uint32_t    lid, 
-                uint32_t    gid )
+                lid_t       lid, 
+                gid_t       gid )
 {
         core->lid               = lid;
@@ -64 +65 @@
 
         sched_init( core );
-
-        core->icu               = NULL;          // TODO ??? [AG]
 }
 
@@ -200 +199 @@
 
 ///////////////////////////////////////////////////
-void core_set_irq_vector_entry( xptr_t     core_xp,
+void core_set_irq_vector_entry( core_t   * core,
                                 uint32_t   irq_type,
                                 uint32_t   irq_id,
-                                xptr_t     dev_xp )
-{
-    // get core cluster and local pointer
-    cxy_t    core_cxy = GET_CXY( core_xp );
-    core_t * core_ptr = (core_t *)GET_PTR( core_xp );
-
-    // compute xptr on relevant interrupt vector entry
-    xptr_t   xp;
-    if     ( irq_type == WTI_TYPE ) xp = XPTR( core_cxy , &core_ptr->wti_vector[irq_id] );
-    else if( irq_type == HWI_TYPE ) xp = XPTR( core_cxy , &core_ptr->hwi_vector[irq_id] );
-    else                            xp = XPTR( core_cxy , &core_ptr->pti_vector[irq_id] );
-
-    // set relevant IRQ vector entry
-    hal_remote_swd( xp , dev_xp );
-}
+                                chdev_t  * chdev )
+{
+    if     ( irq_type == WTI_TYPE ) core->wti_vector[irq_id] = chdev;
+    else if( irq_type == HWI_TYPE ) core->hwi_vector[irq_id] = chdev;
+    else                            core->pti_vector[irq_id] = chdev;
+}

trunk/kernel/kern/core.h

@@ -37 +37 @@
 
 struct thread_s;
-struct device_s;
+struct chdev_s;
 
 
 /****************************************************************************************
- * This structure defines the core descriptor
+ * This structure defines the core descriptor.
+ * It contains the three interrupt vectors, that are implemented as array of pointers
+ * on the source channel devices, for all IRQs allocated to a given core.
  ***************************************************************************************/
 
@@ -62 +64 @@
         rpc_fifo_t          rpc_fifo;       /*! embedded private RPC fifo (one per core)   */
         scheduler_t         scheduler;      /*! embedded private scheduler                 */
-    struct device_s   * icu;            /*! pointer on local ICU device descriptor     */
 
-    xptr_t              hwi_vector[CONFIG_MAX_HWIS_PER_ICU];     /*! on source device  */
-    xptr_t              pti_vector[CONFIG_MAX_PTIS_PER_ICU];     /*! on source device  */
-    xptr_t              wti_vector[CONFIG_MAX_WTIS_PER_ICU];     /*! on source device  */
+    struct chdev_s    * hwi_vector[CONFIG_MAX_HWIS_PER_ICU];     /*! on source device  */
+    struct chdev_s    * pti_vector[CONFIG_MAX_PTIS_PER_ICU];     /*! on source device  */
+    struct chdev_s    * wti_vector[CONFIG_MAX_WTIS_PER_ICU];     /*! on source device  */
 
-        char                name[CONFIG_SYSFS_NAME_LEN];
         sysfs_entry_t       node;
 } 
@@ -159 +159 @@
  * any thread in any cluster.
  ***************************************************************************************
- * @ core_xp    : extended pointer on the core descriptor.
+ * @ core       : local pointer on the core descriptor.
  * @ irq_type   : type of IRQ (HWI/WTI/PTI).
  * @ irq_id     : index in the IRQ vector.
- * @ dev_xp     : extended pointer on the "source" descriptor.
+ * @ chdev      : local pointer on the "source" chdev descriptor.
  **************************************************************************************/
-void core_set_irq_vector_entry( xptr_t     core_xp,
-                                uint32_t   irq_type,
-                                uint32_t   irq_id,
-                                xptr_t     dev_xp );
+void core_set_irq_vector_entry( core_t          * core,
+                                uint32_t          irq_type,
+                                uint32_t          irq_id,
+                                struct chdev_s  * chdev );
 
 

trunk/kernel/kern/do_interrupt.c

@@ -25 +25 @@
 #include <thread.h>
 #include <cpu-trace.h>
-#include <device.h>
+#include <chdev.h>
 #include <system.h>
 #include <signal.h>

trunk/kernel/kern/dqdt.c

@@ -263 +263 @@
     // analyse load for all children in non terminal node
     load_min = 0xFFFFFFFF;
+    select   = 0;
     for( i = 0 ; i < 4 ; i++ )
     {

trunk/kernel/kern/event.c

@@ -24 +24 @@
 #include <cpu.h>
 #include <cluster.h>
-#include <device.h>
+#include <chdev.h>
 #include <pmm.h>
 #include <event.h>

trunk/kernel/kern/kernel_init.c

@@ -40 +40 @@
 #include <ppm.h>
 #include <page.h>
-#include <device.h>
+#include <chdev.h>
 #include <boot_info.h>
 #include <dqdt.h>
 #include <dev_icu.h>
 #include <dev_mmc.h>
-#include <dev_mwr.h>
-#include <dev_iox.h>
+#include <dev_dma.h>
+#include <dev_iob.h>
 #include <dev_ioc.h>
+#include <dev_txt.h>
 #include <dev_pic.h>
 #include <printk.h>
 #include <vfs.h>
-
-
-#define KERNEL_INIT_SYNCRO  0xA5A5B5B5
+#include <soclib_tty.h>
+
+
+#define KERNEL_INIT_SYNCHRO  0xA5A5B5B5
 
 ///////////////////////////////////////////////////////////////////////////////////////////
@@ -60 +62 @@
 ///////////////////////////////////////////////////////////////////////////////////////////
 
+// This variable defines the local boot_info structure
+__attribute__((section(".kinfo")))
+boot_info_t          boot_info          CACHELINE_ALIGNED;
+
 // This variable defines the local cluster manager 
+__attribute__((section(".kdata")))
 cluster_t            cluster_manager    CACHELINE_ALIGNED; 
 
-// This variable defines the kernel process descriptor and associated thread
+// These variables define the kernel process0 descriptor and associated thread
+__attribute__((section(".kdata")))
 process_t            process_zero       CACHELINE_ALIGNED;            
 thread_t             thread_zero        CACHELINE_ALIGNED;
 
 // This variable contains the extended pointers on the device descriptors
-devices_directory_t  devices_dir        CACHELINE_ALIGNED;
-
-// This variable contains the input IRQ indexes for the PIC and ICU devices
-devices_input_irq_t  devices_input_irq   CACHELINE_ALIGNED;
-
-// This variable synchronizes the cores during kernel_init()
-volatile uint32_t    local_sync_init = 0;  
+__attribute__((section(".kdata")))
+chdev_directory_t    chdev_dir          CACHELINE_ALIGNED;
+
+// This variable contains the input IRQ indexes for the PIC device
+__attribute__((section(".kdata")))
+chdev_pic_input_t    chdev_pic_input    CACHELINE_ALIGNED;
+
+// This variable contains the input IRQ indexes for the ICU device
+__attribute__((section(".kdata")))
+chdev_icu_input_t    chdev_icu_input    CACHELINE_ALIGNED;
+
+// This variable synchronizes the local cores during kernel_init()
+__attribute__((section(".kdata")))
+volatile uint32_t    local_sync_init    CACHELINE_ALIGNED;  
 
 // This variable defines the local cluster identifier
-cxy_t                local_cxy;
-
-
-///////////////////////////////////////////////////////////////////////////////////////////
-// This function displays the ALMOS_MKH.banner.
-///////////////////////////////////////////////////////////////////////////////////////////
-static void print_boot_banner()
+__attribute__((section(".kdata")))
+cxy_t                local_cxy          CACHELINE_ALIGNED;
+
+// This variable is the lock protecting the kernel TXT terminal (used by printk)
+__attribute__((section(".kdata")))
+remote_spinlock_t    txt0_lock          CACHELINE_ALIGNED;
+
+///////////////////////////////////////////////////////////////////////////////////////////
+// This function displays the ALMOS_MKH banner.
+///////////////////////////////////////////////////////////////////////////////////////////
+static void print_banner( uint32_t nclusters , uint32_t ncores )
 { 
-        printk("\n           ____        ___        ___       ___    _______    ________         ___       ___   ___     ___   \n");
-        printk("          /    \\      |   |      |   \\     /   |  /  ___  \\  /  ____  |       |   \\     /   | |   |   /  / \n");
-        printk("         /  __  \\      | |        |   \\___/   |  |  /   \\  | | /    |_/        |   \\___/   |   | |   /  /  \n");
-        printk("        /  /  \\  \\     | |        |  _     _  |  | |     | | | |______   ___   |  _     _  |   | |__/  /     \n");
-        printk("       /  /____\\  \\    | |        | | \\   / | |  | |     | | \\______  \\ |___|  | | \\   / | |   |  __  <  \n");
-        printk("      /   ______   \\   | |     _  | |  \\_/  | |  | |     | |  _     | |        | |  \\_/  | |   | |  \\  \\  \n");
-        printk("     /   /      \\   \\  | |____/ | | |       | |  |  \\___/  | | \\____/ |        | |       | |   | |   \\  \\\n");
-        printk("    /_____/    \\_____\\|_________/|___|     |___|  \\_______/  |________/       |___|     |___| |___|   \\__\\\n");
-
-
-        printk("\n\n\t\t\t\t Multi-Kernel Advanced Locality Management Operating System\n");
-        printk("\t\t\t\t   %s \n\n\n", CONFIG_ALMOS_VERSION );
+    printk("\n"
+           "                    _        __    __     _____     ______         __    __    _   __   _     _   \n"
+           "          /\\       | |      |  \\  /  |   / ___ \\   / _____|       |  \\  /  |  | | / /  | |   | |  \n"
+           "         /  \\      | |      |   \\/   |  | /   \\ | | /             |   \\/   |  | |/ /   | |   | |  \n"
+           "        / /\\ \\     | |      | |\\  /| |  | |   | | | |_____   ___  | |\\  /| |  |   /    | |___| |  \n"
+           "       / /__\\ \\    | |      | | \\/ | |  | |   | | \\_____  \\ |___| | | \\/ | |  |   \\    |  ___  |  \n"
+           "      / ______ \\   | |      | |    | |  | |   | |       | |       | |    | |  | |\\ \\   | |   | |  \n"
+           "     / /      \\ \\  | |____  | |    | |  | \\___/ |  _____/ |       | |    | |  | | \\ \\  | |   | |  \n"
+           "    /_/        \\_\\ |______| |_|    |_|   \\_____/  |______/        |_|    |_|  |_|  \\_\\ |_|   |_|  \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 ); 
 }
 
 
 ///////////////////////////////////////////////////////////////////////////////////////////
-// This static function allocates memory for all devices descriptors associated 
-// to peripherals contained in the local cluster: 
-// - the internal (replicated) devices are placed in the local cluster.
-// - the external devices are pseudo-randomly distributed on all clusters. 
-// It initialises these device descriptors as specified by the boot_info_t structure,
-// including the dynamic linking with the driver for the specified implementation.
-// Finally, all copies of the devices directory are initialised.
-// TODO check that cluster IO contains a PIC and IOB [AG]
+// This static function allocates memory and initializes the TXT0 chdev descriptor,
+// associated to the kernel terminal, shared by all kernel instances for debug messages.
+// It should be called by a thread running in the I/O cluster, because the TXT0 chdev
+// is created in the I/O cluster.
 ///////////////////////////////////////////////////////////////////////////////////////////
 // @ info    : pointer on the local boot-info structure.
 ///////////////////////////////////////////////////////////////////////////////////////////
-static void devices_init( boot_info_t * info )
+static void txt0_device_init( boot_info_t * info )
 {
     boot_device_t * dev_tbl;         // pointer on array of devices in boot_info
         uint32_t        dev_nr;          // actual number of devices in this cluster
-        xptr_t          xp_dev;          // extended pointer on device descriptor
-        xptr_t          xp_dev_bis;      // extended pointer on second device descriptor
         xptr_t          base;            // remote pointer on segment base
         uint32_t        size;            // channel size (bytes)
@@ -126 +138 @@
         uint32_t        x;               // X cluster coordinate
         uint32_t        y;               // Y cluster coordinate
-        uint32_t        channels;        // number of channels
-        uint32_t        chl;             // channel index
-        uint32_t        p0;              // device parameter 0
-        uint32_t        p1;              // device parameter 1
-        uint32_t        p2;              // device parameter 2
-        uint32_t        p3;              // device parameter 3
-    bool_t          is_local;        // true for internal peripherals
-
-    // get number of peripherals from boot_info
-        dev_nr      = info->devices_nr;
-    dev_tbl     = info->dev;
-
-    // loop on all peripherals in cluster
+        chdev_t       * chdev;           // local pointer on created chdev
+
+    // get number of peripherals and base of devices array from boot_info
+        dev_nr      = info->ext_dev_nr;
+    dev_tbl     = info->ext_dev;
+
+    // loop on external peripherals to find TXT
         for( i = 0 ; i < dev_nr ; i++ )
         {
-        size     = dev_tbl[i].size;
-        base     = dev_tbl[i].base;
-        type     = dev_tbl[i].type;
-        channels = dev_tbl[i].channels;
-        p0       = dev_tbl[i].param0;
-        p1       = dev_tbl[i].param1;
-        p2       = dev_tbl[i].param2;
-        p3       = dev_tbl[i].param3;
-
-        func     = FUNC_FROM_TYPE( type );
-        impl     = IMPL_FROM_TYPE( type );
-
-        // do nothing for RAM and ROM functional types
-        if( (type == DEV_FUNC_RAM) || (type == DEV_FUNC_ROM) ) continue;
-
-        // loop on channels in peripheral
-        for( chl = 0 ; chl < channels ; chl++ )
-        { 
-            // target cluster is local for internal (replicated) peripherals
-            if( (func == DEV_FUNC_ICU) || 
-                (func == DEV_FUNC_MMC) ||
-                (func == DEV_FUNC_MWR) )   is_local = true;
-            else                           is_local = false;
-
-            // allocate memory and initialize device descriptor
-                    xp_dev = device_alloc( info , is_local );
-
-            if( xp_dev == XPTR_NULL ) hal_core_sleep();
-            
-            device_init( xp_dev ,
-                         func ,
-                         impl,
-                         chl,
-                         false,                    // TX
-                         base + size*chl,
-                         size );
-
-            // allocate memory and initialise another device descriptor if NIC, 
-            // ALMOS-MKH uses two separate devices descriptor for NIC_RX and NIC_TX
-            if( func == DEV_FUNC_NIC )
+        size        = dev_tbl[i].size;
+        base        = dev_tbl[i].base;
+        type        = dev_tbl[i].type;
+        func        = FUNC_FROM_TYPE( type );
+        impl        = IMPL_FROM_TYPE( type );
+
+        if (func == DEV_FUNC_TXT ) 
+        {
+            // allocate and initialize a local chdev for TXT0
+            chdev = chdev_create( func,
+                                  impl,
+                                  0,        // channel
+                                  0,        // direction
+                                  base );
+
+            // Complete TXT specific initialisation
+            if( impl == IMPL_TXT_TTY )
             {
-                xp_dev_bis = device_alloc( info , is_local );
-
-                if( xp_dev_bis == XPTR_NULL ) hal_core_sleep();
-
-                device_init( xp_dev_bis ,
-                             func ,
-                             impl,
-                             chl,
-                             true,                // RX
-                             (base + size*chl),
-                             size );
-             }
-
-            // TODO ??? AG
-                    // devfs_register( dev );
-
-            // make device type specific initialisation
-            // the number of parameters depends on the device type
-            if     ( func == DEV_FUNC_ICU ) dev_icu_init( xp_dev , p0 , p1 , p2 );     
-            else if( func == DEV_FUNC_MMC ) dev_mmc_init( xp_dev );
-// TODO     else if( func == DEV_FUNC_MWR ) dev_mwr_init( xp_dev , p0 , p1 , p2 , p3 );
-            else if( func == DEV_FUNC_IOB ) dev_iox_init( xp_dev );
-            else if( func == DEV_FUNC_IOC ) dev_ioc_init( xp_dev );
-            else if( func == DEV_FUNC_TXT ) dev_txt_init( xp_dev );
-            else if( func == DEV_FUNC_PIC ) dev_pic_init( xp_dev , p0 );
-            else if( func == DEV_FUNC_NIC ) dev_nic_init( xp_dev );
-            else                            hal_core_sleep();
-
-           // initialize the replicated devices_dir[x][y] structures
-           // defining the extended pointers on all devices descriptors 
-           xptr_t * ptr_dev;    
-           xptr_t * ptr_dev_bis;    
-
-           if( func == DEV_FUNC_ICU ) ptr_dev     = &devices_dir.icu[local_cxy];
-           if( func == DEV_FUNC_MMC ) ptr_dev     = &devices_dir.mmc[local_cxy];
-           if( func == DEV_FUNC_MWR ) ptr_dev     = &devices_dir.mwr[local_cxy];
-
-           if( func == DEV_FUNC_TXT ) ptr_dev     = &devices_dir.txt[chl];
-           if( func == DEV_FUNC_IOB ) ptr_dev     = &devices_dir.iob;
-           if( func == DEV_FUNC_IOC ) ptr_dev     = &devices_dir.ioc;
-           if( func == DEV_FUNC_PIC ) ptr_dev     = &devices_dir.pic;
-           if( func == DEV_FUNC_NIC ) ptr_dev     = &devices_dir.nic_tx[chl];
-           if( func == DEV_FUNC_NIC ) ptr_dev_bis = &devices_dir.nic_rx[chl];
-  
+                chdev->cmd = &soclib_tty_cmd;
+                chdev->isr = &soclib_tty_isr;
+                soclib_tty_init( chdev );
+            }
+
+            // initialize the replicated chdev_dir[x][y] structures
             for( x = 0 ; x < info->x_size ; x++ )
             {
@@ -231 +176 @@
                 {
                     cxy_t  cxy = (x<<info->y_width) + y;
-                     
-                    hal_remote_swd( XPTR( cxy , ptr_dev ) , xp_dev );
-
-                    if( func == DEV_FUNC_NIC )
-                    {
-                       hal_remote_swd( XPTR( cxy , ptr_dev_bis ) , xp_dev_bis );
+                    hal_remote_swd( XPTR( cxy , &chdev_dir.txt[0] ) , XPTR( local_cxy , chdev ) );
+                }
+            }
+
+                    kinit_dmsg("\n[INFO] %s : core[%x][0] created TXT0 chdev / paddr = %l at cycle %d\n",
+                       __FUNCTION__ , local_cxy , chdev_func_str( func ), chdev_xp , hal_time_stamp() );
+        }
+
+        } // end loop on devices
+
+}  // end txt0_device_init()
+
+///////////////////////////////////////////////////////////////////////////////////////////
+// This static function allocates memory for the chdev (channel_device) descriptors
+// associated to the internal peripherals contained in the local cluster. These internal
+// devices (ICU, MMC, DMA) chdev descriptors are placed in the local cluster.
+// It initialises these device descriptors as specified by the boot_info_t structure,
+// including the dynamic linking with the driver for the specified implementation.
+// Finally, all copies of the devices directory are initialised.
+///////////////////////////////////////////////////////////////////////////////////////////
+// @ info    : pointer on the local boot-info structure.
+///////////////////////////////////////////////////////////////////////////////////////////
+static void internal_devices_init( boot_info_t * info )
+{
+    boot_device_t * dev_tbl;         // pointer on array of devices in boot_info
+        uint32_t        dev_nr;          // actual number of devices in this cluster
+        xptr_t          base;            // remote pointer on segment base
+        uint32_t        size;            // channel size (bytes)
+    uint32_t        type;            // peripheral type
+    uint32_t        func;            // device functionnal index
+    uint32_t        impl;            // device implementation index
+        uint32_t        i;               // device index in dev_tbl
+        uint32_t        x;               // X cluster coordinate
+        uint32_t        y;               // Y cluster coordinate
+        uint32_t        channels_nr;     // number of channels in device
+        uint32_t        channel;         // channel index
+        uint32_t        p0;              // device parameter 0
+        uint32_t        p1;              // device parameter 1
+        uint32_t        p2;              // device parameter 2
+        uint32_t        p3;              // device parameter 3
+
+        chdev_t       * chdev;           // local pointer on one channel_device descriptor
+    xptr_t          chdev_xp;        // extended pointer on channel_device descriptor
+
+    // get number of internal devices and base of devices array from boot_info
+        dev_nr      = info->int_dev_nr;
+    dev_tbl     = info->int_dev;
+
+    // loop on all internal devices in cluster
+        for( i = 0 ; i < dev_nr ; i++ )
+        {
+        size        = dev_tbl[i].size;
+        base        = dev_tbl[i].base;
+        type        = dev_tbl[i].type;
+        channels_nr = dev_tbl[i].channels;
+        p0          = dev_tbl[i].param0;
+        p1          = dev_tbl[i].param1;
+        p2          = dev_tbl[i].param2;
+        p3          = dev_tbl[i].param3;
+
+        func     = FUNC_FROM_TYPE( type );
+        impl     = IMPL_FROM_TYPE( type );
+
+        // do nothing for RAM, that does not require a chdev descriptor.
+        if( func == DEV_FUNC_RAM ) continue;
+
+        // check internal device functional type
+        if( (func != DEV_FUNC_MMC) &&
+            (func != DEV_FUNC_ICU) &&
+            (func != DEV_FUNC_DMA) ) 
+        {
+            assert( false , __FUNCTION__ , "illegal internal peripheral type" );
+        }
+
+        // loop on channels 
+        for( channel = 0 ; channel < channels_nr ; channel++ )
+        {
+            // create one chdev in local cluster
+            chdev = chdev_create( func ,
+                                  impl,
+                                  channel,      
+                                  false,           // TX
+                                  base );
+
+            assert( (chdev != NULL) , __FUNCTION__ , "cannot allocate internal chdev" );
+            
+            // get extended pointer on channel descriptor 
+            chdev_xp = XPTR( local_cxy , chdev );
+
+            // TODO ??? AG
+                    // devfs_register( dev );
+
+            // make device type specific initialisation
+            // the number of parameters depends on the device type
+            // TODO : remove these parameters that  must be provided by the driver
+            if     ( func == DEV_FUNC_ICU ) dev_icu_init( chdev , p0 , p1 , p2 );     
+            else if( func == DEV_FUNC_MMC ) dev_mmc_init( chdev );
+            else                            dev_dma_init( chdev );
+
+            // initialize the replicated chdev_dir[x][y] structures
+            // containing extended pointers on all devices descriptors 
+            xptr_t * entry;    
+
+            if     ( func == DEV_FUNC_ICU ) entry  = &chdev_dir.icu[local_cxy];
+            else if( func == DEV_FUNC_MMC ) entry  = &chdev_dir.mmc[local_cxy];
+            else                            entry  = &chdev_dir.dma[channel];
+  
+            if( func != DEV_FUNC_DMA )  // ICU and MMC devices are remotely accessible
+            {
+                for( x = 0 ; x < info->x_size ; x++ )
+                {
+                    for( y = 0 ; y < info->y_size ; y++ )
+                    {
+                        cxy_t  cxy = (x<<info->y_width) + y;
+                        hal_remote_swd( XPTR( cxy , entry ) , chdev_xp );
                     }
                 }
             }
-           
-                    kinit_dmsg("[INFO] %s created device %s / channel %d / in cluster %x\n",
-                       __FUNCTION__ , device_func_str[func] , chl , dev_cxy );
+            else                      // DMA devices are NOT remotely accessible
+            {
+                *entry = chdev_xp;
+            }
+
+            kinit_dmsg("\n[INFO] %s :core[%x][0] created chdev %s / channel %d"
+                       " / paddr = %l at cycle %d\n",
+                       __FUNCTION__ , local_cxy , chdev_func_str( func ) , 
+                       channel , chdev_xp , hal_time_stamp() );
 
         } // end loop on channels
 
-        // initialize the replicated devices_irq[x][y] structures
-        // defining how peripherals are connected to PIC or ICU components
-        uint32_t   id;
-        uint8_t    valid;
-        uint32_t   dev_type;
-        uint8_t    channel;
-        uint8_t    is_rx;
-        uint32_t * ptr_irq; 
-
-        // default initiialization for devices_irq structure
-        
-        // only external peripherals can be connected to PIC
+        // initialize the entries of the local chdev_icu_input structure
+        // defining how internal peripherals are connected to ICU 
+        if( func == DEV_FUNC_ICU )  
+        {
+            uint32_t   id;
+            uint8_t    valid;
+            uint32_t   dev_type;
+            uint8_t    channel;
+
+            // loop on ICU inputs
+            for( id = 0 ; id < CONFIG_MAX_HWIS_PER_ICU ; id++ )
+            {
+                valid    = dev_tbl[i].irq[id].valid;
+                dev_type = dev_tbl[i].irq[id].dev_type;
+                channel  = dev_tbl[i].irq[id].channel;
+
+                if( valid ) // only valid local IRQs are registered
+                {
+                    uint32_t * index;   // local pointer on the entry to be set
+                    uint16_t   dev_func = FUNC_FROM_TYPE( dev_type );
+                    if( dev_func == DEV_FUNC_MMC )  
+                        index = &chdev_icu_input.mmc;
+                    else if( dev_func == DEV_FUNC_DMA )  
+                        index = &chdev_icu_input.dma[channel]; 
+                    else
+                    {
+                        assert( false , __FUNCTION__ , "illegal source device for ICU input" );
+                    }                   
+
+                    // set entry in local structure
+                    *index = id;
+                }
+
+            }  // end loop on ICU inputs
+        }  // end if ICU
+        } // end loop on peripherals
+}  // end internal_devices_init()
+
+///////////////////////////////////////////////////////////////////////////////////////////
+// This static function allocates memory for the chdev descriptors associated 
+// to the external (shared) peripherals contained in the local cluster. These external
+// devices (IOB, IOC, TXT, NIC, etc ) are distributed on all clusters. 
+// It initialises these device descriptors as specified by the boot_info_t structure,
+// including the dynamic linking with the driver for the specified implementation.
+// Finally, all copies of the devices directory are initialised.
+//
+// The number of channel_devices depends on the device functionnal type.
+// There is three nested loops to scan the full set of external channel_devices:
+// - loop on external devices.
+// - loop on channels for multi-channels devices.
+// - loop on directions (RX/TX) for NIC device.
+// The set of channel_devices is indexed by the chdev_gid global index, that is used
+// to select the cluster containing a given chdev[func,channel,direction].
+// All clusters scan the full set of chdevs, but only the cluster matching
+// (chdev_gid % (x_size*y_size)) create the corresponding chdev. 
+//
+// TODO check that cluster IO contains a PIC [AG]
+///////////////////////////////////////////////////////////////////////////////////////////
+// @ info    : pointer on the local boot-info structure.
+///////////////////////////////////////////////////////////////////////////////////////////
+static void external_devices_init( boot_info_t * info )
+{
+    boot_device_t * dev_tbl;         // pointer on array of devices in boot_info
+        uint32_t        dev_nr;          // actual number of devices in this cluster
+        xptr_t          base;            // remote pointer on segment base
+        uint32_t        size;            // channel size (bytes)
+    uint32_t        type;            // peripheral type
+    uint32_t        func;            // device functionnal index
+    uint32_t        impl;            // device implementation index
+        uint32_t        i;               // device index in dev_tbl
+        uint32_t        x;               // X cluster coordinate
+        uint32_t        y;               // Y cluster coordinate
+        uint32_t        channels_nr;     // number of channels
+        uint32_t        channel;         // channel index
+        uint32_t        directions_nr;   // number of directions 
+        uint32_t        direction;       // direction index
+        uint32_t        p0;              // device parameter 0
+        uint32_t        p1;              // device parameter 1
+        uint32_t        p2;              // device parameter 2
+        uint32_t        p3;              // device parameter 3
+    uint32_t        first_channel;   // used in loop on channels
+
+        chdev_t       * chdev;           // local pointer on one channel_device descriptor
+    xptr_t          chdev_xp;        // extended pointer on channel_device descriptor
+    uint32_t        chdev_gid = 0;   // global index of channel_device descriptor
+
+    // get number of peripherals and base of devices array from boot_info
+        dev_nr      = info->ext_dev_nr;
+    dev_tbl     = info->ext_dev;
+
+    // loop on external peripherals
+        for( i = 0 ; i < dev_nr ; i++ )
+        {
+        size        = dev_tbl[i].size;
+        base        = dev_tbl[i].base;
+        type        = dev_tbl[i].type;
+        channels_nr = dev_tbl[i].channels;
+        p0          = dev_tbl[i].param0;
+        p1          = dev_tbl[i].param1;
+        p2          = dev_tbl[i].param2;
+        p3          = dev_tbl[i].param3;
+
+        func     = FUNC_FROM_TYPE( type );
+        impl     = IMPL_FROM_TYPE( type );
+
+        // There is one chdev per direction for NIC
+        if (func == DEV_FUNC_NIC) directions_nr = 2;
+        else                      directions_nr = 1;
+
+        // The TXT0 chdev has already been created
+        if (func == DEV_FUNC_TXT) first_channel = 1;
+        else                      first_channel = 0;
+
+        // do nothing for ROM, that does not require a device descriptor.
+        if( func == DEV_FUNC_ROM ) continue;
+
+        // check external device functionnal type
+        if( (func != DEV_FUNC_IOB) &&
+            (func != DEV_FUNC_PIC) &&
+            (func != DEV_FUNC_IOC) &&
+            (func != DEV_FUNC_TXT) &&
+            (func != DEV_FUNC_NIC) &&
+            (func != DEV_FUNC_FBF) ) 
+        {
+            assert( false , __FUNCTION__ , "undefined external peripheral type" );
+        }
+
+        // loops on channels 
+        for( channel = first_channel ; channel < channels_nr ; channel++ )
+        { 
+            // loop on directions
+            for( direction = 0 ; direction < directions_nr ; direction++ )
+            {
+                // get target cluster for chdev[func,channel,direction]
+                uint32_t offset     = chdev_gid % ( info->x_size * info->y_size );
+                uint32_t cx         = offset / info->y_size;
+                uint32_t cy         = offset % info->y_size;
+                uint32_t target_cxy = (cx<<info->y_width) + cy;
+
+                // allocate and initialize a local chdev
+                // if local cluster matches target cluster
+                if( target_cxy == local_cxy )
+                {
+                    chdev = chdev_create( func,
+                                          impl,
+                                          channel,
+                                          direction,
+                                          base );
+
+                    assert( (chdev != NULL), __FUNCTION__ , 
+                            "cannot allocate external device" );
+
+                    // get extended pointer on chdev
+                    chdev_xp = XPTR( local_cxy , chdev );
+
+                    // make device type specific initialisation
+                    // the number of parameters depends on the device type
+                    // TODO : remove the parameters that  must be provided by the drivers
+                    if     ( func == DEV_FUNC_IOB ) dev_iob_init( chdev );
+                    else if( func == DEV_FUNC_IOC ) dev_ioc_init( chdev );
+                    else if( func == DEV_FUNC_TXT ) dev_txt_init( chdev );
+                    else if( func == DEV_FUNC_NIC ) dev_nic_init( chdev );
+                    else if( func == DEV_FUNC_PIC ) dev_pic_init( chdev , p0 );
+                    else if( func == DEV_FUNC_FBF ) dev_fbf_init( chdev , p0 , p1 );
+                    else
+                    {
+                        assert( false , __FUNCTION__ , "undefined device type" );
+                    }
+
+                    // all external (shared) devices are remotely accessible 
+                    // initialize the replicated chdev_dir[x][y] structures
+                    // defining the extended pointers on chdev descriptors 
+                    xptr_t * entry;    
+                
+                    if( func == DEV_FUNC_IOB ) entry  = &chdev_dir.iob;
+                    if( func == DEV_FUNC_PIC ) entry  = &chdev_dir.pic;
+                    if( func == DEV_FUNC_TXT ) entry  = &chdev_dir.txt[channel];
+                    if( func == DEV_FUNC_IOC ) entry  = &chdev_dir.ioc[channel];
+                    if( func == DEV_FUNC_FBF ) entry  = &chdev_dir.fbf[channel];
+                    if( func == DEV_FUNC_NIC ) entry  = &chdev_dir.nic_tx[channel];
+  
+                    for( x = 0 ; x < info->x_size ; x++ )
+                    {
+                        for( y = 0 ; y < info->y_size ; y++ )
+                        {
+                            cxy_t  cxy = (x<<info->y_width) + y;
+                            hal_remote_swd( XPTR( cxy , entry ) , chdev_xp );
+                        }
+                    }
+
+                            kinit_dmsg("\n[INFO] %s : core[%x][0] created chdev %s / channel = %d"
+                               " / paddr = %l at cycle %d\n",
+                               __FUNCTION__ , local_cxy , chdev_func_str( func ),
+                               channel , chdev_xp , hal_time_stamp() );
+
+                }  // end if match
+
+                // increment chdev global index (matching or not)            
+                chdev_gid++;
+
+            } // end loop on directions
+
+        }  // end loop on channels
+
+        // initialize the entries of the local chdev_pic_input structure
+        // defining how external peripherals are connected to PIC 
         if( func == DEV_FUNC_PIC )  
         {
+            uint32_t   id;
+            uint8_t    valid;
+            uint32_t   dev_type;
+            uint8_t    channel;
+            uint8_t    is_rx;
+
             // loop on PIC inputs
             for( id = 0 ; id < CONFIG_MAX_IRQS_PER_PIC ; id++ )
@@ -268 +528 @@
                 is_rx     = dev_tbl[i].irq[id].is_rx;
 
-                // only valid IRQs are registered in the devices_input_irq structure
-                // ptr_irq is a local pointer on the entry to be set in devices_irq
-                if( valid )
+                if( valid )  // only valid inputs are registered
                 {
+                    uint32_t * index;  // local pointer on one entry
                     uint16_t dev_func = FUNC_FROM_TYPE( dev_type );
-                    if( dev_func == DEV_FUNC_TXT )   
-                        ptr_irq = &devices_input_irq.txt[channel];
-                    if( dev_func == DEV_FUNC_IOC )                   
-                        ptr_irq = &devices_input_irq.ioc; 
-                    if( (dev_func == DEV_FUNC_NIC) && (is_rx == 0) ) 
-                        ptr_irq = &devices_input_irq.nic_tx[channel]; 
-                    if( (dev_func == DEV_FUNC_NIC) && (is_rx != 0) ) 
-                        ptr_irq = &devices_input_irq.nic_rx[channel]; 
-                   
-                    // all copies of devices_irq must be updated in all clusters
-                    for( x = 0 ; x < info->x_size ; x++ )
-                    {
-                        for( y = 0 ; y < info->y_size ; y++ )
-                        {
-                            cxy_t  cxy = (x<<info->y_width) + y;
-                            hal_remote_sw( XPTR( cxy , ptr_irq ) , id );
-                        }       
+
+                    if( dev_func == DEV_FUNC_TXT )
+                    {
+                        index = &chdev_pic_input.txt[channel];
                     }
+                    else if( dev_func == DEV_FUNC_IOC )
+                    {
+                        index = &chdev_pic_input.ioc[channel]; 
+                    }
+                    else if( (dev_func == DEV_FUNC_NIC) && (is_rx == 0) )
+                    {
+                        index = &chdev_pic_input.nic_tx[channel]; 
+                    }
+                    else if( (dev_func == DEV_FUNC_NIC) && (is_rx != 0) )
+                    {
+                        index = &chdev_pic_input.nic_rx[channel]; 
+                    }
+                    else
+                    {
+                        assert( false , __FUNCTION__ , "illegal source device for PIC input" );
+                    }                   
+
+                    // set entry in local structure
+                    *index = id; 
                 }
             } // end loop on PIC inputs
         } // end PIC
-
-        // only internal peripherals can be connected to ICU
-        if( func == DEV_FUNC_ICU )  
-        {
-            // loop on ICU inputs
-            for( id = 0 ; id < CONFIG_MAX_HWIS_PER_ICU ; id++ )
-            {
-                valid    = dev_tbl[i].irq[id].valid;
-                dev_type = dev_tbl[i].irq[id].dev_type;
-                channel  = dev_tbl[i].irq[id].channel;
-
-                // only valid IRQs are registered in the devices_input_irq structure
-                // ptr_irq is a local pointer on the entry to be set in devices_irq
-                if( valid )
-                {
-                    uint16_t dev_func = FUNC_FROM_TYPE( dev_type );
-                    if( dev_func == DEV_FUNC_MMC )  
-                        ptr_irq = &devices_input_irq.mmc[local_cxy];
-                    if( dev_func == DEV_FUNC_MWR )  
-                        ptr_irq = &devices_input_irq.mwr[local_cxy]; 
-                   
-                    // all copies of devices_irq must be updated in all clusters
-                    for( x = 0 ; x < info->x_size ; x++ )
-                    {
-                        for( y = 0 ; y < info->y_size ; y++ )
-                        {
-                            cxy_t  cxy = (x<<info->y_width) + y;
-                            hal_remote_sw( XPTR( cxy , ptr_irq ) , id );
-                        }
-                    }
-                }
-            }  // end loop on ICU inputs
-        }  // end ICU
-        } // end loop on peripherals
-}  // end devices_init()
-
+        } // end loop on devices
+}  // end external_devices_init()
 
 
@@ -335 +566 @@
 // This function is the entry point for the kernel initialisation.
 // It is executed by all cores in all clusters, but only core[0] in each cluster
-// initialize the cluster manager, ant the other local shared resources. 
-// To comply with the multi-kernels paradigm, it access only local cluster memory,
-// using only informations contained in the local boot_info_t structure, 
-// that has been set by the bootloader.
-// All cores TODO ...
+// initialize the cluster manager, ant the local peripherals. 
+// To comply with the multi-kernels paradigm, it access only local cluster memory, using
+// only informations contained in the local boot_info_t structure, set by the bootloader.
 ///////////////////////////////////////////////////////////////////////////////////////////
 // @ info    : pointer on the local boot-info structure.
@@ -363 +592 @@
 
     // Each core makes an associative search in boot_info
-    // to get its (cxy,lid) composite index 
+    // to get its (cxy,lid) composite index from its gid
     found    = false;
     core_cxy = 0;
@@ -378 +607 @@
     }
          
-    if ( found == false )
-    {
-        printk("PANIC in %s : Core %d not registered in cluster %x\n",
-               __FUNCTION__ , core_gid , local_cxy );
-        hal_core_sleep();
-    }
-
-    if ( core_cxy != local_cxy) 
-    {
-        printk("PANIC in %s : Core %d has wrong cxy in cluster %x\n",
-               __FUNCTION__ , core_gid , local_cxy );
-        hal_core_sleep();
-    }
-
-    // from this point, only core[0] initialises local resources
+    // suicide if not found
+    if( (found == false) || (core_cxy != local_cxy) ) hal_core_sleep();
+
+    //////////////////////////////////////////////////////////////
+    // In first step, only CP0 initialises local resources
+    //////////////////////////////////////////////////////////////
+
     if( core_lid == 0 )    
     {
         // initialize local cluster manager (cores and memory allocators)
         error = cluster_init( info );
-        if ( error == 0 ) 
-        {
-            printk("PANIC in %s : Failed to initialize cluster manager in cluster %x\n",
-                   __FUNCTION__ , local_cxy );
-            hal_core_sleep();
-        }
+ 
+        // suicide if failure
+        if( error ) hal_core_sleep();
+
+        // get pointer on local cluster manager and on core descriptor
+        cluster = LOCAL_CLUSTER;
+            core    = &cluster->core_tbl[core_lid];
 
         // initialize process_zero descriptor
                 process_zero_init( info );
 
-        // initialize thread_zero descriptor
+        // CP0 initialize its private thread_zero descriptor
             memset( &thread_zero , 0 , sizeof(thread_t) );
             thread_zero.type     = THREAD_KERNEL;
@@ -413 +635 @@
             hal_set_current_thread( &thread_zero );
 
-        // initialise local devices descriptors
-        devices_init( info );
+        // CP0 in I/O cluster initialize the kernel TXT0 chdev descriptor.
+        // this TXTO device is shared by the all kernel instances for debug messages:
+        // the printk() function call the dev_txt_sync_write() function that call
+        // directly the relevant TXT driver, without desheduling.
+        if( core_cxy == info->io_cxy ) txt0_device_init( info );
+
+        // synchronise all CP0s before using TXT0
+        remote_barrier( XPTR( info->io_cxy , &cluster->barrier ) , 
+                        (cluster->x_size * cluster->y_size) );
+
+        // All CP0 initialise internal peripheral chdev descriptors.
+        // Each CP0[cxy] scan the set of its internal (private) peripherals,
+        // and allocate memory for the corresponding chdev descriptors.
+        internal_devices_init( info );
+        
+        // All CP0 contribute to initialise external peripheral chdev descriptors.
+        // Each CP0[cxy] scan the set of external (shared) peripherals (but the TXT0),
+        // and allocates memory for the chdev descriptors that must be placed
+        // on the (cxy) cluster according to its global index.  
+        external_devices_init( info );
 
         // TODO initialize devFS and sysFS
@@ -420 +660 @@
                 // sysfs_root_init();
 
-                // TODO dire précisément ce qu'on fait ici [AG]
-                // hal_arch_init( info );
-
         // TODO ??? [AG]
                 // clusters_sysfs_register();
 
-        // initialize virtual file system
+        // TODO initialize virtual file system
         // vfs_init();
 
@@ -433 +670 @@
 
         // activate other cores in same cluster
-                local_sync_init = KERNEL_INIT_SYNCRO;
+                local_sync_init = KERNEL_INIT_SYNCHRO;
                 hal_wbflush();
     }
@@ -439 +676 @@
     {
         // other cores wait synchro from core[0]
-                while( local_sync_init != KERNEL_INIT_SYNCRO )
+                while( local_sync_init != KERNEL_INIT_SYNCHRO )
         {
                    uint32_t retval = hal_time_stamp() + 1000;
@@ -445 +682 @@
         }
 
-        // other cores initialise thread_zero descriptor 
+        // get pointer on local cluster manager and on core descriptor
+        cluster = LOCAL_CLUSTER;
+            core    = &cluster->core_tbl[core_lid];
+
+        // core initialise its private thread_zero descriptor 
             memset( &thread_zero , 0 , sizeof(thread_t) );
             thread_zero.type     = THREAD_KERNEL;
@@ -451 +692 @@
             hal_set_current_thread( &thread_zero );
     }
-
-
-    // each core get pointer on local cluster manager and on core descriptor
-    cluster = LOCAL_CLUSTER;
-        core    = &cluster->core_tbl[core_lid];
 
         // each core creates its private idle thread descriptor 
@@ -463 +699 @@
                                   NULL,
                                   core_lid );
-    if( error )
-        {
-                printk("ERROR in %s: failed to create idle thread for core %d in cluster %x\n",
-               __FUNCTION__ , core_lid , core_cxy );
-        hal_core_sleep();
-    }
+
+    assert( (error == 0) , __FUNCTION__ , "cannot create idle thread" );
 
     // each core register thread_idle in scheduler 
@@ -476 +708 @@
     hal_set_current_thread( thread_idle );
 
-    kinit_dmsg("INFO %s  Created thread idle %x for core %d at cycle %d ]\n",
-               thread, hal_get_gid(), hal_time_stamp());
+    kinit_dmsg("\n[INFO] %s : thread idle created for core[%x][%d] at cycle %d\n",
+               __FUNCTION__ , core_cxy , core_lid , hal_time_stamp());
 
     // global syncho for all core[0] in all clusters
@@ -490 +722 @@
                     cluster->cores_nr );
 
-    if( core_lid ==  0 )
+    if( (core_lid ==  0) && (local_cxy == info->io_cxy) ) 
     {
-        kinit_dmsg("INFO %s completed for cluster %x at cycle %d\n",
-                   __FUNCTION__ , local_cxy , hal_time_stamp() );
-
-        if( local_cxy == info->io_cxy ) print_boot_banner();
+        print_banner( (info->x_size * info->y_size) , info->cores_nr );
     }
 
-    // load idle thread context in calling core
+    // load idle thread context on calling core
         hal_cpu_context_load( thread_idle );
 

trunk/kernel/kern/printk.c

@@ -24 +24 @@
 #include <hal_types.h>
 #include <hal_irqmask.h>
-#include <printk.h>
-#include <stdarg.h>
+#include <hal_special.h>
 #include <dev_txt.h>
 #include <remote_spinlock.h>
 #include <cluster.h>
+#include <printk.h>
 
 ///////////////////////////////////////////////////////////////////////////////////
-// This static function is called by printk(), nolock_printk() and user_printk()
+// This static function is called by kernel_printf() to display a string on the
+// TXT channel defined by the <channel> argument. 
+// The access mode is defined by the <busy> argument:
+// - if <busy> is true, it uses the dev_txt_sync_write() function, that takes the
+//   TXT lock, and call directly the relevant TXT driver, without descheduling.
+// - if <busy is false, it uses the dev_txt_write() function, that register the
+//   write buffer in the relevant TXT chdev queue, and uses a descheduling policy.
 ///////////////////////////////////////////////////////////////////////////////////
+// @ channel  : TXT channel.
+// @ busy     : TXT device acces mode.
+// @ buf      : buffer containing the characters.
+// @ nc       : number of characters.
+// return 0 if success / return -1 if TTY0 busy after 10000 retries.
+///////////////////////////////////////////////////////////////////////////////////
+static error_t txt_write( uint32_t  channel,
+                          uint32_t  busy,
+                          char    * buffer,
+                          uint32_t  count )
+{
+    if( busy ) return dev_txt_sync_write( channel , buffer , count );
+    else       return dev_txt_write( channel , buffer , count );
+}  
+
+//////////////////////////////////////////////////////////////////////////////////////
+// This static function is called by printk() and user_printk() to build
+// a formated string.
+//////////////////////////////////////////////////////////////////////////////////////
+// @ channel   : channel index.
+// @ busy      : TXT device access mode.
+// @ format    : printf like format.
+// @ args      : format arguments.
+//////////////////////////////////////////////////////////////////////////////////////
 static void kernel_printf( uint32_t   channel,
+                           uint32_t   busy,
                            char     * format, 
                            va_list  * args ) 
@@ -46 +77 @@
         if (i) 
         {
-            dev_txt_sync_write( channel, format, i );
+            txt_write( channel, busy, format, i );
             format += i;
         }
@@ -83 +114 @@
                 {
                     val = -val;
-                    dev_txt_sync_write( channel, "-" , 1 );
+                    txt_write( channel, busy, "-" , 1 );
                 }
                 for(i = 0; i < 10; i++) 
@@ -109 +140 @@
             {
                 uint32_t val = va_arg( *args , uint32_t );
-                dev_txt_sync_write( channel, "0x" , 2 );
+                txt_write( channel, busy, "0x" , 2 );
                 for(i = 0; i < 8; i++) 
                 {
-                    buf[7 - i] = HexaTab[val % 16];
+                    buf[7 - i] = HexaTab[val & 0xF];
                     if (!(val = (val>>4)))  break;
                 }
@@ -119 +150 @@
                 break;
             }
-            case ('X'):             /* 32 bits hexadecimal unsigned  on 10 char*/
+            case ('X'):             /* 32 bits hexadecimal unsigned  on 10 char */
             {
                 uint32_t val = va_arg( *args , uint32_t );
-                dev_txt_sync_write( channel, "0x" , 2 );
+                txt_write( channel, busy, "0x" , 2 );
                 for(i = 0; i < 8; i++) 
                 {
-                    buf[7 - i] = HexaTab[val % 16];
+                    buf[7 - i] = HexaTab[val & 0xF];
                     val = (val>>4);
                 }
@@ -135 +166 @@
             {
                 uint64_t val = va_arg( *args , uint64_t );
-                dev_txt_sync_write( channel, "0x" , 2 );
+                txt_write( channel, busy, "0x" , 2 );
                 for(i = 0; i < 16; i++) 
                 {
-                    buf[15 - i] = HexaTab[val % 16];
-                    if (!(val /= 16))  break;
+                    buf[15 - i] = HexaTab[val & 0xF];
+                    if (!(val = (val>>4)))  break;
                 }
                 len =  i + 1;
                 pbuf = &buf[15 - i];
+                break;
+            }
+            case ('L'):           /* 64 bits hexadecimal unsigned on 18 char */ 
+            {
+                uint64_t val = va_arg( *args , uint64_t );
+                txt_write( channel, busy, "0x" , 2 );
+                for(i = 0; i < 16; i++) 
+                {
+                    buf[15 - i] = HexaTab[val & 0xF];
+                    val = (val>>4);
+                }
+                len =  16;
+                pbuf = buf;
                 break;
             }
@@ -157 +201 @@
             default:
             {
-                dev_txt_sync_write( channel ,
-                                    "\n[PANIC] in kernel_printf() : illegal format\n", 45 );
+                txt_write( channel , busy,
+                           "\n[PANIC] in kernel_printf() : illegal format\n", 45 );
             }
         }
 
-        if( pbuf != NULL ) dev_txt_sync_write( channel, pbuf, len );
+        if( pbuf != NULL ) txt_write( channel, busy, pbuf, len );
         
         goto printf_text;
@@ -169 +213 @@
 }  // end kernel_printf()
 
-///////////////////////////////////////
-void nolock_printk( char* format, ...)
-{
-    va_list   args;
+////////////////////////////////
+void printk( char * format, ...)
+{
+    va_list       args;
 
     // call kernel_printf
     va_start( args , format );
-    kernel_printf( 0, format , &args );
+    kernel_printf( 0 , 1 , format , &args );
     va_end( args );
 }
 
-////////////////////////////////
-void printk( char* format, ...)
-{
-    va_list       args;
-    uint32_t  save_sr;
-
-    // disable IRQs
-    hal_disable_irq( &save_sr );
-
-    // get TXT0 lock
-    cluster_t * cluster = LOCAL_CLUSTER;
-    remote_spinlock_lock( XPTR( cluster->io_cxy , &cluster->txt0_lock ) );
+/////////////////////////////////////
+void user_printk( char* format, ...)
+{
+    va_list   args;
+
+    // get calling thread TXT channel TODO
+    uint32_t channel = 0;
 
     // call kernel_printf
     va_start( args , format );
-    kernel_printf( 0, format , &args );
-    va_end( args );
-
-    // release TXT0 lock
-    remote_spinlock_unlock( XPTR( cluster->io_cxy , &cluster->txt0_lock ) );
-
-    // restore IRQs
-    hal_restore_irq( save_sr );
-}
-
-/////////////////////////////////////
-void user_printk( char* format, ...)
-{
-    va_list   args;
-
-    // get calling thread TXT channel TODO
-    uint32_t channel = 0;
-
-    // call kernel_printf
-    va_start( args , format );
-    kernel_printf( channel, format , &args );
+    kernel_printf( channel, 0 , format , &args );
     va_end( args );
 }
 
-
+///////////////////////////////////////////
+inline void assert( bool_t       condition,
+                    const char * function_name,
+                    char       * string )
+{
+    if( condition == false )
+    {
+        printk("\n[PANIC] in %s : %s\n" , function_name , string );
+        hal_core_sleep();
+    }
+}
 
 // Local Variables:

trunk/kernel/kern/printk.h

@@ -24 +24 @@
 ///////////////////////////////////////////////////////////////////////////////////
 // The printk.c and printk.h files define the functions used by the kernel
-// to display messages on the kernel text terminal, using a busy waiting
-// policy if required : these functions does not use the TXT kernel thread,
-// and does not deschedule if TXT peripheral is not available.
-// These functions use the generic TXT device to call the proper implementation
+// to display messages on a text terminal. 
+// Two access modes are supported:
+// - The printk() function displays kernel messages on the kernel terminal TXT0,
+//   using a busy waiting policy: It calls directly the relevant TXT driver, 
+//   after taking the TXT0 chdev lock for exclusive access to the TXT0 terminal.
+// - The user_printk() function displays messages on the calling thread private
+//   terminal, using a descheduling policy: it register the request in the selected
+//   TXT chdev waiting queue and deschedule. The calling thread is reactivated by 
+//   the IRQ signaling completion.
+// Both functions use the generic TXT device to call the proper implementation
 // dependant TXT driver.
+// Finally these files define a set of conditionnal trace <***_dmsg> for debug.
 ///////////////////////////////////////////////////////////////////////////////////
 
@@ -34 +41 @@
 #define _PRINTK_H
 
-///////////////////////////////////////////////////////////////////////////////////
-//       Access functions to kernel terminal TTY0 
-///////////////////////////////////////////////////////////////////////////////////
-
+#include <hal_types.h>
+#include <stdarg.h>
+
+
+/**********************************************************************************
+ * This function displays a formated string on the kernel terminal TXT0,
+ * using a busy waiting policy: It calls directly the relevant TXT driver, 
+ * after taking the TXT0 chdev lock for exclusive access to the TXT0 terminal.
+ **********************************************************************************
+ * @ format     : formated string.
+ *********************************************************************************/
 extern void         printk( char* format, ... );
 
-extern void         nolock_printk( char* format, ... );
-
+/**********************************************************************************
+ * Display a formated string on the calling thread private terminal, using a 
+ * descheduling policy: it register the request in the selected TXT chdev waiting
+ * queue and deschedule. IT is reactivated by the IRQ signaling completion.
+ * Not fully implemented yet ( use TXT0 in deschedling mode ).
+ **********************************************************************************
+ * @ format     : formated string.
+ *********************************************************************************/
 extern void         user_printk( char* format, ... );
 
+/**********************************************************************************
+ * This function displaya "PANIC" message and force the calling core in
+ * sleeping mode if a Boolean condition is false.
+ * These functions are actually used to debug the kernel...
+ **********************************************************************************
+ * @ condition     : condition that must be true.
+ * @ function_name : name of the calling function.
+ * @ string        : error message if condition is false. 
+ *********************************************************************************/
+inline void assert( bool_t       condition,
+                    const char * function_name,
+                    char       * string );
+
 ///////////////////////////////////////////////////////////////////////////////////
 //       Conditionnal debug macros
 ///////////////////////////////////////////////////////////////////////////////////
 
+#if CONFIG_CONTEXT_DEBUG
+#define context_dmsg(...)   printk(__VA_ARGS__)
+#else
+#define context_dmsg(...)
+#endif
+
 #if CONFIG_CORE_DEBUG
-#define core_dmsg(...)   printk(__VA__ARGS__)
+#define core_dmsg(...)   printk(__VA_ARGS__)
 #else
 #define core_dmsg(...)
@@ -55 +94 @@
 
 #if CONFIG_DQDT_DEBUG
-#define dqdt_dmsg(...)   printk(__VA__ARGS__)
+#define dma_dmsg(...)   printk(__VA_ARGS__)
+#else
+#define dma_dmsg(...)
+#endif
+
+#if CONFIG_DQDT_DEBUG
+#define dqdt_dmsg(...)   printk(__VA_ARGS__)
 #else
 #define dqdt_dmsg(...)
@@ -61 +106 @@
 
 #if CONFIG_ELF_DEBUG
-#define elf_dmsg(...)   printk(__VA__ARGS__)
+#define elf_dmsg(...)   printk(__VA_ARGS__)
 #else
 #define elf_dmsg(...)
 #endif
 
+#if CONFIG_EXEC_DEBUG
+#define exec_dmsg(...)   printk(__VA_ARGS__)
+#else
+#define exec_dmsg(...)
+#endif
+
+#if CONFIG_FBF_DEBUG
+#define fbf_dmsg(...)   printk(__VA_ARGS__)
+#else
+#define fbf_dmsg(...)
+#endif
+
 #if CONFIG_FORK_DEBUG
-#define fork_dmsg(...)   printk(__VA__ARGS__)
+#define fork_dmsg(...)   printk(__VA_ARGS__)
 #else
 #define fork_dmsg(...)
 #endif
 
-#if CONFIG_EXEC_DEBUG
-#define exec_dmsg(...)   printk(__VA__ARGS__)
-#else
-#define exec_dmsg(...)
-#endif
-
 #if CONFIG_ICU_DEBUG
-#define icu_dmsg(...)   printk(__VA__ARGS__)
+#define icu_dmsg(...)   printk(__VA_ARGS__)
 #else
 #define icu_dmsg(...)
@@ -85 +136 @@
 
 #if CONFIG_IOC_DEBUG
-#define ioc_dmsg(...)   printk(__VA__ARGS__)
+#define ioc_dmsg(...)   printk(__VA_ARGS__)
 #else
 #define ioc_dmsg(...)
+#endif
+
+#if CONFIG_KCM_DEBUG
+#define kcm_dmsg(...) printk(__VA_ARGS__)
+#else
+#define kcm_dmsg(...)
+#endif
+
+#if CONFIG_KHM_DEBUG
+#define khm_dmsg(...) printk(__VA_ARGS__)
+#else
+#define khm_dmsg(...)
 #endif
 
@@ -102 +165 @@
 #endif
 
+#if CONFIG_MAPPER_DEBUG
+#define mapper_dmsg(...)   printk(__VA_ARGS__)
+#else
+#define mapper_dmsg(...)
+#endif
+
 #if CONFIG_MMC_DEBUG
-#define mmc_dmsg(...)   printk(__VA__ARGS__)
+#define mmc_dmsg(...)   printk(__VA_ARGS__)
 #else
 #define mmc_dmsg(...)
@@ -109 +178 @@
 
 #if CONFIG_NIC_DEBUG
-#define nic_dmsg(...)   printk(__VA__ARGS__)
+#define nic_dmsg(...)   printk(__VA_ARGS__)
 #else
 #define nic_dmsg(...)
@@ -115 +184 @@
 
 #if CONFIG_PIC_DEBUG
-#define pic_dmsg(...)   printk(__VA__ARGS__)
+#define pic_dmsg(...)   printk(__VA_ARGS__)
 #else
 #define pic_dmsg(...)
 #endif
 
+#if CONFIG_PPM_DEBUG
+#define ppm_dmsg(...)   printk(__VA_ARGS__)
+#else
+#define ppm_dmsg(...)
+#endif
+
 #if CONFIG_PROCESS_DEBUG
-#define process_dmsg(...)   printk(__VA__ARGS__)
+#define process_dmsg(...)   printk(__VA_ARGS__)
 #else
 #define process_dmsg(...)
@@ -127 +202 @@
 
 #if CONFIG_RPC_DEBUG
-#define rpc_dmsg(...)   printk(__VA__ARGS__)
+#define rpc_dmsg(...)   printk(__VA_ARGS__)
 #else
 #define rpc_dmsg(...)
@@ -133 +208 @@
 
 #if CONFIG_SCHED_DEBUG
-#define sched_dmsg(...)   printk(__VA__ARGS__)
+#define sched_dmsg(...)   printk(__VA_ARGS__)
 #else
 #define sched_dmsg(...)
@@ -139 +214 @@
 
 #if CONFIG_THREAD_DEBUG
-#define thread_dmsg(...)   printk(__VA__ARGS__)
+#define thread_dmsg(...)   printk(__VA_ARGS__)
 #else
 #define thread_dmsg(...)
@@ -145 +220 @@
 
 #if CONFIG_TXT_DEBUG
-#define txt_dmsg(...)   printk(__VA__ARGS__)
+#define txt_dmsg(...)   printk(__VA_ARGS__)
 #else
 #define txt_dmsg(...)
@@ -151 +226 @@
 
 #if CONFIG_VFS_DEBUG
-#define vfs_dmsg(...)   printk(__VA__ARGS__)
+#define vfs_dmsg(...)   printk(__VA_ARGS__)
 #else
 #define vfs_dmsg(...)
@@ -157 +232 @@
 
 #if CONFIG_VMM_DEBUG
-#define vmm_dmsg(...)   printk(__VA__ARGS__)
+#define vmm_dmsg(...)   printk(__VA_ARGS__)
 #else
 #define vmm_dmsg(...)

trunk/kernel/kern/process.c

@@ -271 +271 @@
     spinlock_lock( &process->th_lock );
 
-    // first loop on threads to send the THREAD_SIG_KILL signal to all peocess threads
+    // first loop on threads to send the THREAD_SIG_KILL signal to all process threads
     // we use both "ltid" and "count" indexes, because it can exist "holes" in th_tbl
     for( ltid = 0 , count = 0  ; 

trunk/kernel/kern/remote_sem.c

@@ -101 +101 @@
     {
         rpc_semaphore_alloc_client( ref_cxy , &sem_xp );
+        sem_ptr = (remote_sem_t *)GET_PTR( sem_xp );
     }
 

trunk/kernel/kern/rpc.c

@@ -33 +33 @@
 #include <core.h>
 #include <mapper.h>
-#include <device.h>
+#include <chdev.h>
 #include <bits.h>
 #include <thread.h>
@@ -55 +55 @@
     &rpc_thread_user_create_server,     // 4
     &rpc_thread_kernel_create_server,   // 5
-    &rpc_icu_wti_alloc_server,          // 6                       
-    &rpc_device_alloc_server,           // 7
+    &rpc_undefined,                     // 6                       
+    &rpc_undefined,                     // 7
     &rpc_undefined,                     // 8
     &rpc_undefined,                     // 9
@@ -1018 +1018 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-//               Marshaling functions attached to RPC_ICU_WTI_ALLOC 
-/////////////////////////////////////////////////////////////////////////////////////////
-
-//////////////////////////////////////////////
-void rpc_icu_wti_alloc_client( cxy_t      cxy,
-                               uint32_t * wti_id )    // out
-{
-    // RPC must be remote
-    if( cxy == local_cxy ) 
-    {
-        printk("PANIC in %s : target is not remote\n", __FUNCTION__ );
-        hal_core_sleep();
-    }
-
-    // initialise RPC descriptor header 
-    rpc_desc_t  rpc;
-    rpc.index    = RPC_ICU_WTI_ALLOC;
-    rpc.response = 1;
-
-    // register RPC request in remote RPC fifo 
-    rpc_send_sync( cxy , &rpc );
-
-    // get output argument from rpc descriptor
-    *wti_id = (uint32_t)rpc.args[0];
-}
-
-//////////////////////////////////////////
-void rpc_icu_wti_alloc_server( xptr_t xp )
-{
-    uint32_t      wti_id;
-
-    // get client cluster identifier and pointer on RPC descriptor
-    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
-    rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
-
-    // call icu_wti_alloc() function
-    wti_id = dev_icu_wti_alloc();
-
-    // set output argument
-    hal_remote_swd( XPTR( client_cxy , &desc->args[0] ) , (uint64_t)wti_id);
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////
-//               Marshaling functions attached to RPC_DEVICE_ALLOC 
-/////////////////////////////////////////////////////////////////////////////////////////
-
-/////////////////////////////////////////////
-void rpc_device_alloc_client( cxy_t     cxy,
-                              xptr_t  * dev_xp,      // out
-                              error_t * error )      // out
-{
-    // RPC must be remote
-    if( cxy == local_cxy ) 
-    {
-        printk("PANIC in %s : target is not remote\n", __FUNCTION__ );
-        hal_core_sleep();
-    }
-
-    // initialise RPC descriptor header 
-    rpc_desc_t  rpc;
-    rpc.index    = RPC_DEVICE_ALLOC;
-    rpc.response = 1;
-
-    // register RPC request in remote RPC fifo 
-    rpc_send_sync( cxy , &rpc );
-
-    // get output argument from rpc descriptor
-    *dev_xp = (xptr_t)rpc.args[0];
-    *error  = (error_t)rpc.args[1];
-}    
-
-/////////////////////////////////////////
-void rpc_device_alloc_server( xptr_t xp )
-{
-    error_t      error;
-    kmem_req_t   req;
-    device_t   * dev_ptr;  
-    xptr_t       dev_xp;
-
-    // get client cluster identifier and pointer on RPC descriptor
-    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
-    rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
-
-    // allocate memory for a device descriptor
-    req.type   = KMEM_DEVICE;
-    req.flags  = AF_ZERO;
-    dev_ptr    = (device_t *)kmem_alloc( &req );
-
-    // set output arguments
-    error  = ( dev_ptr == NULL );
-    dev_xp = XPTR( local_cxy , dev_ptr );
-    hal_remote_swd( XPTR( client_cxy , &desc->args[0] ) , (uint64_t)dev_xp );
-    hal_remote_swd( XPTR( client_cxy , &desc->args[1] ) , (uint64_t)error );
-}
-
-
-/////////////////////////////////////////////////////////////////////////////////////////
 //               Marshaling functions attached to RPC_FATFS_GET_CLUSTER 
 /////////////////////////////////////////////////////////////////////////////////////////
@@ -1190 +1093 @@
     bool_t     first;
     reg_t      sr_save;
+
+printk("\n@@@ coucou 0\n");
 
     // get client CPU and cluster coordinates
@@ -1220 +1125 @@
     while( error );
  
+printk("\n@@@ coucou 1\n");
+
     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 );
@@ -1240 +1147 @@
         }
 
+printk("\n@@@ coucou 2\n");
+
         // activate preemption to allow incoming RPC and avoid deadlock
         if( this->type == THREAD_RPC ) hal_enable_irq( &sr_save );
@@ -1248 +1157 @@
         if( rpc->response == 0 ) break;
     }
+
+printk("\n@@@ coucou 3\n");
 
     // restore preemption
@@ -1425 +1336 @@
     error_t      error;
 
-    // do nothing if light lock already taken or FIFO empty  
+    // calling thread does nothing if light lock already taken or FIFO empty  
         if( (rpc_fifo->owner != 0) || (local_fifo_is_empty( &rpc_fifo->fifo )) )
     {
@@ -1431 +1342 @@
     }
 
-        // The calling thread try to take the light lock,
-    // and activate an RPC thread if success
+        // calling thread tries to take the light lock,
+    // and activates an RPC thread if success
     if( hal_atomic_test_set( &rpc_fifo->owner , this->trdid ) )
         {
@@ -1452 +1363 @@
         return false;
     }
-} // end __rpc_check()
+} // end rpc_check()
 
 

trunk/kernel/kern/rpc.h

@@ -63 +63 @@
     RPC_THREAD_USER_CREATE     = 4,
     RPC_THREAD_KERNEL_CREATE   = 5,
-        RPC_ICU_WTI_ALLOC          = 6,
-    RPC_DEVICE_ALLOC           = 7,
 
     RPC_VFS_INODE_CREATE       = 10,
@@ -465 +463 @@
 
 /***********************************************************************************
- * The RPC_ICU_WTI_ALLOC can be send by any thread running in a "client" cluster
- * to get a WTI mailbox from the ICU of a "server" cluster.
- * The WTI is allocated from the server ICU, but the WTI is not enabled,
- * and no target core is selected in remote cluster.
- * It returns wti_id == -1 if there is no free WTI in server cluster.
- ***********************************************************************************
- * @ cxy      : server cluster identifier.
- * @ wti_id   : [out] local pointer on WTI index in client cluster (-1 if error).
- **********************************************************************************/
-void rpc_icu_wti_alloc_client( cxy_t      cxy,
-                               uint32_t * wti_id );    
-
-void rpc_icu_wti_alloc_server( xptr_t xp );
-
-/***********************************************************************************
- * The RPC_DEVICE_ALLOC can be send by any thread running in a "client" cluster
- * to create a device descriptor in a remote "server" cluster.
- * The WTI is allocated from the server ICU, but the WTI is not enabled,
- * and no target core is selected in remote cluster.
- * It returns wti_id == -1 if there is no free WTI in server cluster.
- ***********************************************************************************
- * @ cxy      : server cluster identifier.
- * @ dev_xp   : [out] buffer for extended pointer on device (in client cluster).
- * @ error    : [out] local pointer on buffer for error code (in client cluster). 
- **********************************************************************************/
-void rpc_device_alloc_client( cxy_t     cxy,
-                              xptr_t  * dev_xp,           
-                              error_t * error );    
-
-void rpc_device_alloc_server( xptr_t xp );
-
-/***********************************************************************************
  * The RPC_FATFS_GET_CLUSTER can be send by any thread running in a "client" cluster
  * to scan the FAT mapper, stored in a remote "server" cluster, and get the FATFS 

trunk/kernel/kern/signal.c

@@ -2 +2 @@
  * signal.c - signal-management related operations implementation
  * 
- * Author  Ghassan Almaless (2008,2009,2010,2011,2012)
- *         Mohamed Lamine Karaoui (2015)
- *         Alain Greiner    (2016)
+ * Author  Alain Greiner    (2016,2017)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -55 +53 @@
 }
 
-////////////////////////////////////////
-error_t signal_init( thread_t * thread )
-{
-        thread->info.sig_state = 0;
-        thread->info.sig_mask  = CURRENT_THREAD->info.sig_mask;
-        return 0;
-}
-
-////////////////////////////////////////////////////
-static error_t signal_rise_all( process_t * process, 
-                                uint32_t    sig )
+//////////////////////////////////////
+void signal_rise( process_t * process, 
+                  uint32_t    sig )
 {
         thread_t     * thread;
@@ -83 +73 @@
                         __FUNCTION__, process->th_nr , process->pid );
 
-        return 0;
-}
-
-////////////////////////////////////////////////////
-static error_t signal_rise_one( process_t * process,
-                                uint32_t    sig )
-{
-        thread_t * thread;
-
-        spinlock_lock( &process->th_lock );
-
-//mdify to current_thread, not the one pointed by the sig_mgr ?
-        if(process->sig_mgr.handler == NULL)
-                thread = list_first(&process->th_root, struct thread_s, rope);
-        else
-                thread = process->sig_mgr.handler;
-
-        spinlock_lock( &thread->lock );
-        thread->info.sig_state |= (1 << sig);
-        spinlock_unlock( &thread->lock );
-
-        spinlock_unlock( &process->th_lock );
-
-    sig_dmsg("\n[INFO] %s : Thread %u of process %u has received signal %u. sig_state = %x\n",        \
-                        __FUNCTION__, thread_current_cpu(thread)->gid,                          \
-                        process->pid, sig, thread->info.sig_state);
-
-        return 0;
-}
-
+}  // end signal_rise()
+
+///////////////////////////////////////////
 RPC_DECLARE( __signal_rise,                             \
                 RPC_RET( RPC_RET_PTR(error_t, err)),    \
@@ -183 +146 @@
 }
 
-//////////////////////////////////
-error_t signal_rise( pid_t    pid, 
-                     cxy_t    location, 
-                     uint32_t sig)
-{
-        error_t err;
-
-        /* Check location error */
-        if ( location == CID_NULL )
-        {
-                err = ESRCH;
-                printk(WARNING, "%s: there is no process with pid %u\n", \
-                                __FUNCTION__, pid);
-                return err;
-        }
-
-        err = EAGAIN;
-        RCPC( location, RPC_PRIO_SIG_RISE, __signal_rise,       \
-                        RPC_RECV( RPC_RECV_OBJ(err) ),          \
-                        RPC_SEND( RPC_SEND_OBJ(pid),            \
-                                  RPC_SEND_OBJ(sig))            \
-            );
-
-        return err;
+///////////////////////////////
+error_t sys_kill( pid_t    pid, 
+                  uint32_t sig)
+{
+    cxy_t       owner_cxy;    // process owner cluster
+    lpid_t      owner_lpid;   // local process identifier 
+    xptr_t      root_xp;      // extended pointer on root of xlist of process copies
+    xptr_t      lock_xp;      // extended pointer on remote_spinlock protecting this list
+    xptr_t      iter_xp;      // iterator for process copies list
+    xptr_t      process_xp;   // local pointer on process copy 
+    cxy_t       process_cxy;  // cluster of process copy
+    process_t * process_ptr;  // local pointer on process copy 
+        error_t     error;
+
+    // get local pointer on local cluster manager
+    cluster_t * cluster = LOCAL_CLUSTER;
+
+    // get owner process cluster and lpid
+    owner_cxy  = CXY_FROM_PID( pid );
+    owner_lpid = LPID_FROM_PID( pid );
+
+    // get extended pointers on copies root and lock
+    root_xp = XPTR( owner_cxy , &cluster->copies_root[lpid] );
+    lock_xp = XPTR( owner_cxy , &cluster->copies_lock[lpid] );
+
+    // take the lock protecting the copies
+    remote_spinlock_lock( lock_xp );
+
+    // TODO the loop below sequencialize the RPCs
+    // they could be pipelined...
+ 
+    // traverse the list of copies
+    XLIST_FOREACH( root_xp , iter_xp )
+    {
+        process_xp  = XLIST_ELEMENT( iter_xp , process_t , copies_list );
+        process_cxy = GET_CXY( process_xp );
+        process_ptr = (process_t *)GET_PTR( process_xp );
+
+        if( process_xy == local_cxy )   // process copy is local
+        {
+            error = signal_rise( process_ptr , sig );
+        }
+        else                           // process copy is remote
+        {
+            rpc_signal_rise_client( process_cxy , process_ptr , sig );
+        }
+    }
+
+        return 0;
 }
 

trunk/kernel/kern/signal.h

@@ -128 +128 @@
 {
         sa_handler_t        * sigactions[SIG_NR];
- ster   struct thread_s     * handler;
+    struct thread_s     * handler;
 }
 sig_mgr_t;
@@ -145 +145 @@
 
 /*******************************************************************************************
- * This function TODO
+ * This function register the signal <sig> in the bit_vector of all threads of a given
+ * process identified by its <pid>, in all clusters containing threads for this process.
+ * It can be executed by any thread running in any cluster, as this function uses
+ * remote access to traverse the list of process copies, and the RPC_RISE_SIGNAL 
+ * to deliver the signal to all involved clusters.
+ * The list of process copies is rooted in the owner cluster. 
  ******************************************************************************************/
 int sys_kill( pid_t    pid,
@@ -156 +161 @@
 
 /*******************************************************************************************
- * This function TODO
+ * This function register the signal <sig> in the bit-vector of all threads of a given
+ * process identified by its <pid>, in a given cluster.
+ * It must be executed by a thread running in the same cluster as the target threads
+ * (can be a local thread or a RPC thread).
  ******************************************************************************************/
-error_t signal_init( struct thread_s * thread );
-
-/*******************************************************************************************
- * This function register the signal <sig> in the bit-vector of all threads of a given
- * process identified by its <pid>, on all clusters containing a thread .
- * It can be executed by any thread running in any cluster.
- ******************************************************************************************/
-error_t signal_rise( pid_t     pid, 
-                     uint32_t  sig );
+error_t signal_rise( struct process_s * process, 
+                     uint32_t           sig );
 
 /*******************************************************************************************

trunk/kernel/kern/thread.c

@@ -8 +8 @@
  * Copyright (c) UPMC Sorbonne Universites
  *
- * This file is part of ALMOS-MKH..
+ * This file is part of ALMOS-MKH.
  *
- * ALMOS-MKH. is free software; you can redistribute it and/or modify it
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
  *
- * ALMOS-MKH. is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
@@ -20 +20 @@
  *
  * You should have received a copy of the GNU General Public License
- * along with ALMOS-MKH.; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
@@ -62 +62 @@
 };
 
+//////////////////////////////////////////////////////////////////////////////////////
+// This static function returns a printable string for the thread type.
+//////////////////////////////////////////////////////////////////////////////////////
+char * thread_type_str( uint32_t type )
+{
+    if     ( type == THREAD_USER   ) return "THREAD_USER";
+    else if( type == THREAD_RPC    ) return "THREAD_RPC";
+    else if( type == THREAD_DEV    ) return "THREAD_DEV";
+    else if( type == THREAD_KERNEL ) return "THREAD_KERNEL";
+    else if( type == THREAD_IDLE   ) return "THREAD_IDLE";
+    else                             return "undefined";
+}
+
 /////////////////////////////////////////////////////////////////////////////////////
 // This static function makes the actual allocation and initialisation for a thread
@@ -76 +89 @@
 // @ core_lid   : target core local index.
 /////////////////////////////////////////////////////////////////////////////////////
-static error_t __thread_create( thread_t     ** new_thread,
-                                process_t     * process,
-                                thread_type_t   type,
-                                void          * func,
-                                void          * args,
-                                lid_t           core_lid,
-                                intptr_t        u_stack_base,
-                                uint32_t        u_stack_size )
+static error_t thread_create( thread_t     ** new_thread,
+                              process_t     * process,
+                              thread_type_t   type,
+                              void          * func,
+                              void          * args,
+                              lid_t           core_lid,
+                              intptr_t        u_stack_base,
+                              uint32_t        u_stack_size )
 {
     error_t        error;
@@ -171 +184 @@
     *new_thread = thread;
         return 0;
-} // end __thread_create()
+} // end thread_create()
 
 
@@ -185 +198 @@
     lid_t          core_lid;     // selected core local index
 
+    thread_dmsg("\n[INFO] %s : enters\n", 
+                __FUNCTION__ );
+
         cluster_t    * local_cluster = LOCAL_CLUSTER;
 
@@ -199 +215 @@
 
     // make allocation / initialisation
-    error = __thread_create( &thread,
-                             process,
-                             THREAD_USER,
-                             attr->entry_func,
-                             attr->entry_args,
-                             core_lid,
-                             u_stack_base,
-                             u_stack_size );
+    error = thread_create( &thread,
+                           process,
+                           THREAD_USER,
+                           attr->entry_func,
+                           attr->entry_args,
+                           core_lid,
+                           u_stack_base,
+                           u_stack_size );
     if( error ) return ENOMEM;
 
@@ -220 +236 @@
     error = hal_fpu_context_create( thread ); 
     if( error ) return ENOMEM;
-
-    thread_dmsg("INFO : %s thread %x for process %x on core %d in cluster %x\n", 
-                 __FUNCTION__, thread->trdid, process->pid, core_lid, local_cluster->cxy );
+  
+    thread_dmsg("\n[INFO] %s : exit / trdid = %x / process %x / core = %d\n", 
+                __FUNCTION__ , thread->trdid , process->pid , core_lid );
 
     *new_thread = thread;
@@ -239 +255 @@
     lid_t          core_lid;     // selected core local index
 
+    thread_dmsg("\n[INFO] %s : enters\n", 
+                __FUNCTION__ );
+
     // select a target core in local cluster
     core_lid = cluster_select_local_core();
@@ -246 +265 @@
 
     // make allocation / initialisation
-    error = __thread_create( &new,
-                             process,
-                             THREAD_USER,
-                             this->entry_func,
-                             this->entry_args,
-                             core_lid,
-                             u_stack_base,
-                             u_stack_size );
+    error = thread_create( &new,
+                           process,
+                           THREAD_USER,
+                           this->entry_func,
+                           this->entry_args,
+                           core_lid,
+                           u_stack_base,
+                           u_stack_size );
     if( error ) return ENOMEM;
 
@@ -268 +287 @@
 
     thread_dmsg("INFO : %s thread %x for process %x on core %d in cluster %x\n", 
-                 __FUNCTION__, new->trdid, process->pid, core_lid, local_cluster->cxy );
+                 __FUNCTION__, new->trdid, process->pid, core_lid, local_cxy );
 
     *new_thread = new;
         return 0;
+
 } // end thread_user_fork()
 
@@ -286 +306 @@
         thread_t     * new;        // pointer on new thread descriptor
 
-    cluster_t    * local_cluster = LOCAL_CLUSTER;
-
-    // check type argument
-    if( (type != THREAD_KERNEL) && (type != THREAD_RPC) && 
-        (type != THREAD_IDLE) && (type != THREAD_DEV) )
-    {
-        printk("ERROR : %s received an illegal thread type\n", __FUNCTION__ );
-        hal_core_sleep();
-    }
-
-    // check core local index
-    if( core_lid >= local_cluster->cores_nr )
-    {
-        printk("ERROR : %s received an illegal core_lid\n", __FUNCTION__ );
-        hal_core_sleep();
-    }
+    thread_dmsg("\n[INFO] %s : enters for %s in cluster %x\n",
+                __FUNCTION__ , thread_type_str( type ) , local_cxy );
+
+    assert( ( (type == THREAD_KERNEL) || (type == THREAD_RPC) || 
+              (type == THREAD_IDLE)   || (type == THREAD_DEV) ) ,
+              __FUNCTION__ , "illegal thread type" );
+
+    assert( (core_lid < LOCAL_CLUSTER->cores_nr) , 
+            __FUNCTION__ , "illegal core_lid" );
 
     // make allocation / initialisation
-    error = __thread_create( &new,
-                             &process_zero,
-                             type,
-                             func,
-                             args,
-                             core_lid,
-                             0 , 0 );  // no user stack for a kernel thread
+    error = thread_create( &new,
+                           &process_zero,
+                           type,
+                           func,
+                           args,
+                           core_lid,
+                           0 , 0 );  // no user stack for a kernel thread
     if( error ) 
     {
-        printk("ERROR : %s cannot create thread\n", __FUNCTION__ );
-        hal_core_sleep();
+        printk("\n[ERROR] in %s : cannot create thread\n", __FUNCTION__ );
+        return ENOMEM;
     }
 
@@ -320 +333 @@
         hal_cpu_context_create( new ); 
 
-    thread_dmsg("INFO : %s thread %x in cluster %x on core %d\n", 
-                 __FUNCTION__ , new->trdid , local_cluster->cxy , core_lid );
+    thread_dmsg("\n[INFO] %s : sucessfully exit / trdid = %x / core = %d\n", 
+                 __FUNCTION__ , new->trdid , core_lid );
 
     *new_thread = new; 
         return 0;
+
 } // end thread_kernel_create()
 
@@ -341 +355 @@
     core_t     * core       = thread->core;
 
-    if( thread->children_nr )
-    {
-        printk("\n[PANIC] in %s : thread %x for process %x on core %d in cluster %x"
-               " has still attached children\n",
-               __FUNCTION__, thread->trdid, process->pid, core->lid, local_cxy );
-        hal_core_sleep();
-    }
-
-    if( (thread->local_locks != 0) || (thread->remote_locks != 0) )
-    {
-        printk("\n[PANIC] in %s : thread %x for process %x on core %d in cluster %x"
-               " did not released all locks\n",
-               __FUNCTION__, thread->trdid, process->pid, core->lid, local_cxy );
-        hal_core_sleep();
-    }
+    thread_dmsg("\n[INFO] %s : enters for thread %x in process %x / type = %s\n",
+                __FUNCTION__ , thread->trdid , process->pid , thread_type_str( thread->type ) );
+
+    assert( (thread->children_nr == 0) , __FUNCTION__ , "still attached children" );
+
+    assert( (thread->local_locks == 0) , __FUNCTION__ , "all local locks not released" );
     
+    assert( (thread->remote_locks == 0) , __FUNCTION__ , "all remote locks not released" );
+
         tm_start = hal_time_stamp();
 
@@ -402 +409 @@
         tm_end = hal_time_stamp();
 
-        thread_dmsg("INFO : %s destroy thread %x for process %x on core %d in cluster %x\n"
-                 " / duration = %d / page_faults = %d / ticks = %d\n",
-                       __FUNCTION__, trdid , pid , core_lid , local_cxy ,
-                       tm_end - tm_start , pgfaults , ticks );
+        thread_dmsg("\n[INFO] %s : exit for thread %x in process %x / duration = %d\n",
+                       __FUNCTION__, thread->trdid , process->pid , tm_end - tm_start );
 
 }  // end thread_destroy()
@@ -592 +597 @@
     while( 1 )
     {
-        thread_dmsg("INFO : core %d in cluster %x goes to sleeping state at cycle\n",
-                     core->lid , cluster->cxy, hal_time_stamp() );
+        thread_dmsg("\n[INFO] %s : core %d in cluster %x goes to sleeping state at cycle\n",
+                    __FUNCTION__ , core->lid , local_cxy , hal_time_stamp() );
 
         // force core to sleeping state
         hal_core_sleep();
 
-        thread_dmsg("INFO : core %d in cluster %x wake up at cycle %d\n",
-                     core->lid , cluster->cxy, hal_time_stamp() );
+        thread_dmsg("\n[INFO] %s : core %d in cluster %x wake up at cycle %d\n",
+                    __FUNCTION__ , core->lid , local_cxy , hal_time_stamp() );
 
         // force scheduling at wake-up

trunk/kernel/kern/thread.h

@@ -40 +40 @@
 #include <dev_txt.h>
 #include <dev_mmc.h>
+#include <dev_dma.h>
 
 /***************************************************************************************
@@ -196 +197 @@
         txt_command_t   txt;             /*! TXT device generic command               */
         nic_command_t   nic;             /*! NIC device generic command               */
-        mmc_command_t   mmc;             /*! NIC device generic command               */
+        mmc_command_t   mmc;             /*! MMC device generic command               */
+        dma_command_t   dma;             /*! DMA device generic command               */
     }  
-    dev;
+    command;
     
         cxy_t               rpc_client_cxy;  /*! client cluster index (for a RPC thread)  */