Index: trunk/kernel/kern/kernel_init.c
===================================================================
--- trunk/kernel/kern/kernel_init.c	(revision 561)
+++ trunk/kernel/kern/kernel_init.c	(revision 564)
@@ -24,5 +24,4 @@
 
 #include <kernel_config.h>
-#include <hard_config.h> // for the USE_TXT_XXX macros
 #include <errno.h>
 #include <hal_kernel_types.h>
@@ -30,7 +29,8 @@
 #include <hal_context.h>
 #include <hal_irqmask.h>
+#include <hal_macros.h>
 #include <hal_ppm.h>
 #include <barrier.h>
-#include <remote_barrier.h>
+#include <xbarrier.h>
 #include <remote_fifo.h>
 #include <core.h>
@@ -59,5 +59,4 @@
 #include <devfs.h>
 #include <mapper.h>
-#include <cluster_info.h>
 
 ///////////////////////////////////////////////////////////////////////////////////////////
@@ -86,11 +85,11 @@
 cluster_t            cluster_manager                         CONFIG_CACHE_LINE_ALIGNED;
 
-// This variable defines the TXT0 kernel terminal (TX only)
+// This variable defines the TXT_TX[0] chdev
 __attribute__((section(".kdata")))
-chdev_t              txt0_chdev                              CONFIG_CACHE_LINE_ALIGNED;
-
-// This variable defines the TXT0 lock for writing characters to MTY0
+chdev_t              txt0_tx_chdev                           CONFIG_CACHE_LINE_ALIGNED;
+
+// This variable defines the TXT_RX[0] chdev
 __attribute__((section(".kdata")))
-spinlock_t           txt0_lock                               CONFIG_CACHE_LINE_ALIGNED;
+chdev_t              txt0_rx_chdev                           CONFIG_CACHE_LINE_ALIGNED;
 
 // This variables define the kernel process0 descriptor
@@ -116,5 +115,5 @@
 // This variable is used for CP0 cores synchronisation in kernel_init()
 __attribute__((section(".kdata")))
-remote_barrier_t     global_barrier                          CONFIG_CACHE_LINE_ALIGNED;
+xbarrier_t           global_barrier                          CONFIG_CACHE_LINE_ALIGNED;
 
 // This variable is used for local cores synchronisation in kernel_init()
@@ -127,8 +126,55 @@
 
 // kernel_init is the entry point defined in hal/tsar_mips32/kernel.ld
-// It will be used by the bootloader.
+// It is used by the bootloader.
 extern void kernel_init( boot_info_t * info );
 
-// these debug variables are used to analyse the sys_read() syscall timing
+// This array is used for debug, and describes the kernel locks usage,
+// It must be kept consistent with the defines in kernel_config.h file.
+char * lock_type_str[] =
+{
+    "unused_0",              //  0
+
+    "CLUSTER_KCM",           //  1
+    "PPM_FREE",              //  2
+    "SCHED_STATE",           //  3
+    "VMM_STACK",             //  4
+    "VMM_MMAP",              //  5
+    "VFS_CTX",               //  6
+    "KCM_STATE",             //  7
+    "KHM_STATE",             //  8
+    "HTAB_STATE",            //  9
+
+    "THREAD_JOIN",           // 10
+    "VFS_MAIN",              // 11
+    "CHDEV_QUEUE",           // 12
+    "CHDEV_TXT0",            // 13
+    "CHDEV_TXTLIST",         // 14
+    "PAGE_STATE",            // 15
+    "MUTEX_STATE",           // 16
+    "CONDVAR_STATE",         // 17
+    "SEM_STATE",             // 18
+    "XHTAB_STATE",           // 19
+
+    "unused_20",             // 20
+
+    "CLUSTER_PREFTBL",       // 21
+    "PPM_DIRTY",             // 22
+
+    "CLUSTER_LOCALS",        // 23
+    "CLUSTER_COPIES",        // 24
+    "PROCESS_CHILDREN",      // 25
+    "PROCESS_USERSYNC",      // 26
+    "PROCESS_FDARRAY",       // 27
+
+    "MAPPER_STATE",          // 28
+    "PROCESS_THTBL",         // 29
+
+    "PROCESS_CWD",           // 30
+    "VFS_INODE",             // 31
+    "VFS_FILE",              // 32
+    "VMM_VSL",               // 33
+};        
+
+// these debug variables are used to analyse the sys_read() and sys_write() syscalls timing
 
 #if DEBUG_SYS_READ
@@ -179,4 +225,10 @@
 uint32_t   exit_tty_isr_write;
 #endif
+
+// intrumentation variables : cumulated costs per syscall type in cluster
+uint32_t   syscalls_cumul_cost[SYSCALLS_NR];
+
+// intrumentation variables : number of syscalls per syscal type in cluster
+uint32_t   syscalls_occurences[SYSCALLS_NR];
 
 ///////////////////////////////////////////////////////////////////////////////////////////
@@ -201,15 +253,16 @@
 
 ///////////////////////////////////////////////////////////////////////////////////////////
-// This function initializes the TXT0 chdev descriptor, that is the "kernel terminal", 
-// shared by all kernel instances for debug messages. 
-// It is a global variable (replicated in all clusters), because this terminal is used
-// before the kmem allocator initialisation, but only the instance in cluster containing
-// the calling core is registered in the "chdev_dir" directory.
+// This function initializes the TXT_TX[0] and TXT_RX[0] chdev descriptors, implementing
+// the "kernel terminal", shared by all kernel instances for debug messages. 
+// These chdev are implemented as global variables (replicated in all clusters),
+// because this terminal is used before the kmem allocator initialisation, but only 
+// the chdevs in cluster 0 are registered in the "chdev_dir" directory.
 // As this TXT0 chdev supports only the TXT_SYNC_WRITE command, we don't create
 // a server thread, we don't allocate a WTI, and we don't initialize the waiting queue.
+// Note: The TXT_RX[0] chdev is created, but is not used by ALMOS-MKH (september 2018).
 ///////////////////////////////////////////////////////////////////////////////////////////
 // @ info    : pointer on the local boot-info structure.
 ///////////////////////////////////////////////////////////////////////////////////////////
-static void txt0_device_init( boot_info_t * info )
+static void __attribute__ ((noinline)) txt0_device_init( boot_info_t * info )
 {
     boot_device_t * dev_tbl;         // pointer on array of devices in boot_info
@@ -237,96 +290,48 @@
         if (func == DEV_FUNC_TXT )
         {
-            assert( (channels > 0) , "number of TXT channels cannot be 0\n");
-
-            // initializes TXT_TX[0] chdev
-            txt0_chdev.func    = func;
-            txt0_chdev.impl    = impl;
-            txt0_chdev.channel = 0;
-            txt0_chdev.base    = base;
-            txt0_chdev.is_rx   = false;
-
-            // initializes lock
-            remote_spinlock_init( XPTR( local_cxy , &txt0_chdev.wait_lock ) );
+            // initialize TXT_TX[0] chdev
+            txt0_tx_chdev.func    = func;
+            txt0_tx_chdev.impl    = impl;
+            txt0_tx_chdev.channel = 0;
+            txt0_tx_chdev.base    = base;
+            txt0_tx_chdev.is_rx   = false;
+            remote_busylock_init( XPTR( local_cxy , &txt0_tx_chdev.wait_lock ),
+                                  LOCK_CHDEV_TXT0 );
             
-            // TXT specific initialisation:
-            // no server thread & no IRQ routing for channel 0
-            dev_txt_init( &txt0_chdev );                 
-
-            // register the TXT0 in all chdev_dir[x][y] structures
+            // initialize TXT_RX[0] chdev
+            txt0_rx_chdev.func    = func;
+            txt0_rx_chdev.impl    = impl;
+            txt0_rx_chdev.channel = 0;
+            txt0_rx_chdev.base    = base;
+            txt0_rx_chdev.is_rx   = true;
+            remote_busylock_init( XPTR( local_cxy , &txt0_rx_chdev.wait_lock ),
+                                  LOCK_CHDEV_TXT0 );
+            
+            // make TXT specific initialisations 
+            dev_txt_init( &txt0_tx_chdev );                 
+            dev_txt_init( &txt0_rx_chdev );
+
+            // register TXT_TX[0] & TXT_RX[0] in chdev_dir[x][y]
+            // for all valid clusters             
             for( x = 0 ; x < info->x_size ; x++ )
             {
-                for( y = 0 ; y < info->y_size; y++ ) // [FIXME]
+                for( y = 0 ; y < info->y_size ; y++ )
                 {
-                    if (cluster_info_is_active(info->cluster_info[x][y])) {
-                        cxy_t  cxy = (x<<info->y_width) + y;
-                        hal_remote_swd( XPTR( cxy , &chdev_dir.txt_tx[0] ) ,
-                                        XPTR( local_cxy , &txt0_chdev ) );
+                    cxy_t cxy = HAL_CXY_FROM_XY( x , y );
+
+                    if( cluster_is_active( cxy ) )
+                    {
+                        hal_remote_s64( XPTR( cxy , &chdev_dir.txt_tx[0] ) ,
+                                        XPTR( local_cxy , &txt0_tx_chdev ) );
+                        hal_remote_s64( XPTR( cxy , &chdev_dir.txt_rx[0] ) ,
+                                        XPTR( local_cxy , &txt0_rx_chdev ) );
                     }
                 }
             }
+
+            hal_fence();
         }
 	} // end loop on devices
 }  // end txt0_device_init()
-
-///////////////////////////////////////////////////////////////////////////////////////////
-// This function is the same as txt0_device_init() but uses the internal multi_tty device
-// attached to cluster (0,0) instead of the external tty_tsar.
-// This function is used instead of txt0_device_init() only for TSAR LETI.
-///////////////////////////////////////////////////////////////////////////////////////////
-// @ info    : pointer on the local boot-info structure.
-///////////////////////////////////////////////////////////////////////////////////////////
-static void mtty0_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          base;            // remote pointer on segment base
-    uint32_t        func;            // device functional 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
-
-    dev_nr = info->int_dev_nr;
-    dev_tbl = info->int_dev;
-
-    // Initialize spinlock for writing to MTY0
-    spinlock_init(&txt0_lock);
-    
-    // Loop on internal peripherals of cluster (0,0) to find MTY0
-    for ( i = 0; i < dev_nr; i++ )
-    {
-        base = dev_tbl[i].base;
-        func = FUNC_FROM_TYPE( dev_tbl[i].type );
-        impl = IMPL_FROM_TYPE( dev_tbl[i].type );
-
-        if ( func == DEV_FUNC_TXT )
-        {
-            txt0_chdev.func     = func;
-            txt0_chdev.impl     = impl;
-            txt0_chdev.channel  = 0;
-            txt0_chdev.base     = base;
-            txt0_chdev.is_rx    = false;
-
-            // Initialize MTY0 chdev lock
-            remote_spinlock_init( XPTR( local_cxy, &txt0_chdev.wait_lock ) );
-
-            // MTY specific initialization
-            dev_txt_init( &txt0_chdev );
-
-            // register the MTY in all chdev_dir[x][y] structures
-            for( x = 0 ; x < info->x_size ; x++ )
-            {
-                for( y = 0 ; y < info->y_size; y++ ) // [FIXME]
-                {
-                    if (cluster_info_is_active(info->cluster_info[x][y])) {
-                        cxy_t  cxy = (x<<info->y_width) + y;
-                        hal_remote_swd( XPTR( cxy , &chdev_dir.txt_tx[0] ) ,
-                                        XPTR( local_cxy , &txt0_chdev ) );
-                    }
-                }
-            }
-        }
-    } // end loop on internal devices
-} // end mty0_device_init()
 
 ///////////////////////////////////////////////////////////////////////////////////////////
@@ -338,5 +343,5 @@
 // @ info    : pointer on the local boot-info structure.
 ///////////////////////////////////////////////////////////////////////////////////////////
-static void internal_devices_init( boot_info_t * info )
+static void __attribute__ ((noinline)) internal_devices_init( boot_info_t * info )
 {
     boot_device_t * dev_tbl;         // pointer on array of internaldevices in boot_info
@@ -367,5 +372,8 @@
         if( func == DEV_FUNC_MMC )  
         {
-            assert( (channels == 1) , "MMC device must be single channel\n" );
+
+            // check channels
+            if( channels != 1 )
+            printk("\n[PANIC] in %s : MMC device must be single channel\n", __FUNCTION__ );
 
             // create chdev in local cluster
@@ -376,6 +384,7 @@
                                       base );
 
-            assert( (chdev_ptr != NULL) ,
-                    "cannot allocate memory for MMC chdev\n" );
+            // check memory
+            if( chdev_ptr == NULL )
+            printk("\n[PANIC] in %s : cannot create MMC chdev\n", __FUNCTION__ );
             
             // make MMC specific initialisation
@@ -385,9 +394,11 @@
             for( x = 0 ; x < info->x_size ; x++ )
             {
-                for( y = 0 ; y < info->y_size; y++ ) // [FIXME]
+                for( y = 0 ; y < info->y_size ; y++ )
                 {
-                    if (cluster_info_is_active(info->cluster_info[x][y])) {
-                        cxy_t  cxy = (x<<info->y_width) + y;
-                        hal_remote_swd( XPTR( cxy , &chdev_dir.mmc[local_cxy] ), 
+                    cxy_t cxy = HAL_CXY_FROM_XY( x , y );
+
+                    if( cluster_is_active( cxy ) )
+                    {
+                        hal_remote_s64( XPTR( cxy , &chdev_dir.mmc[local_cxy] ), 
                                         XPTR( local_cxy , chdev_ptr ) );
                     }
@@ -414,6 +425,8 @@
                                           base );
 
-                assert( (chdev_ptr != NULL) , "cannot allocate memory for DMA chdev" );
-
+                // check memory
+                if( chdev_ptr == NULL )
+                printk("\n[PANIC] in %s : cannot create DMA chdev\n", __FUNCTION__ );
+            
                 // make DMA specific initialisation
                 dev_dma_init( chdev_ptr );     
@@ -430,101 +443,4 @@
             }
         }
-
-        ///////////////////////////////
-        else if ( func == DEV_FUNC_TXT && USE_TXT_MTY == 1 )
-        {
-            assert(impl == IMPL_TXT_MTY,
-                "Internal TTYs should have MTY implementation\n");
-
-            for ( channel = 0; channel < channels; channel++ )
-            {
-                int rx;
-                for ( rx = 0; rx <= 1; rx++ )
-                {
-                    // skip MTY0_TX since it has already been initialized
-                    if ( channel == 0 && rx == 0 ) continue;
-
-                    // create chdev in local cluster
-                    chdev_ptr = chdev_create( func,
-                                              impl,
-                                              channel,
-                                              rx,
-                                              base );
-
-                    assert( (chdev_ptr != NULL) ,
-                        "cannot allocate memory for MTY chdev" );
-
-                    // make MTY specific initialization
-                    dev_txt_init( chdev_ptr );
-
-                    // set the MTY fields in all clusters
-                    xptr_t *chdev_entry;
-                    if ( rx == 1 ) {
-                        chdev_entry = &chdev_dir.txt_rx[channel];
-                    } else {
-                        chdev_entry = &chdev_dir.txt_tx[channel];
-                    }
-                    for ( x = 0; x < info->x_size; x++ )
-                    {
-                        for ( y = 0; y < info->y_size; y++ )
-                        {
-                            if (cluster_info_is_active(info->cluster_info[x][y])) {
-                                cxy_t cxy = (x<<info->y_width) + y;
-                                hal_remote_swd( XPTR( cxy, chdev_entry ),
-                                                XPTR( local_cxy, chdev_ptr ) );
-                            }
-                        }
-                    }
-#if( DEBUG_KERNEL_INIT & 0x1 )
-if( hal_time_stamp() > DEBUG_KERNEL_INIT )
-printk("\n[DBG] %s : created MTY[%d] in cluster %x / chdev = %x\n",
-__FUNCTION__ , channel , local_cxy , chdev_ptr );
-#endif
-                }
-            }
-        }
-
-        ///////////////////////////////
-        else if ( func == DEV_FUNC_IOC )
-        {
-            assert(impl == IMPL_IOC_SPI, __FUNCTION__,
-                "Internal IOC should have SPI implementation\n");
-
-            for ( channel = 0; channel < channels; channel++ )
-            {
-                // create chdev in local cluster
-                chdev_ptr = chdev_create( func,
-                                          impl,
-                                          channel,
-                                          0,
-                                          base );
-
-                assert( (chdev_ptr != NULL) , __FUNCTION__ , 
-                    "cannot allocate memory for IOC chdev" );
-                
-                // make IOC specific initialization
-                dev_ioc_init( chdev_ptr );
-
-                // set the IOC fields in all clusters
-                xptr_t *chdev_entry = &chdev_dir.ioc[channel];
-                for ( x = 0; x < info->x_size; x++ )
-                {
-                    for ( y = 0; y < info->y_size; y++ )
-                    {
-                        if (cluster_info_is_active(info->cluster_info[x][y])) {
-                            cxy_t cxy = (x<<info->y_width) + y;
-                            hal_remote_swd( XPTR( cxy, chdev_entry ),
-                                            XPTR( local_cxy, chdev_ptr ) );
-                        }
-                    }
-    }
-#if( DEBUG_KERNEL_INIT & 0x1 )
-if( hal_time_stamp() > DEBUG_KERNEL_INIT )
-printk("\n[DBG] %s : created IOC[%d] in cluster %x / chdev = %x\n",
-__FUNCTION__ , channel , local_cxy , chdev_ptr );
-#endif
-            }
-        }
-
     }
 }  // end internal_devices_init()
@@ -586,14 +502,11 @@
 
         // check PIC device initialized
-        assert( (chdev_dir.pic != XPTR_NULL ) ,
-              "PIC device must be initialized before other devices\n" );
+        if( chdev_dir.pic == XPTR_NULL )
+        printk("\n[PANIC] in %s : PIC device must be initialized first\n", __FUNCTION__ );
 
         // check external device functionnal type
-        assert( ( (func == DEV_FUNC_IOB) ||
-                  (func == DEV_FUNC_IOC) ||
-                  (func == DEV_FUNC_TXT) ||
-                  (func == DEV_FUNC_NIC) ||
-                  (func == DEV_FUNC_FBF) ) ,
-                  "undefined external peripheral type\n" );
+        if( (func != DEV_FUNC_IOB) && (func != DEV_FUNC_IOC) && (func != DEV_FUNC_TXT) &&
+            (func != DEV_FUNC_NIC) && (func != DEV_FUNC_FBF) )
+        printk("\n[PANIC] in %s : undefined peripheral type\n", __FUNCTION__ );
 
         // loops on channels
@@ -603,38 +516,25 @@
             for( rx = 0 ; rx < directions ; rx++ )
             {
-                // skip TXT_TX[0] chdev that has already been created & registered
-                if( USE_TXT_MTY == 0 && (func == DEV_FUNC_TXT) && (channel == 0) && (rx == 0) )
+                // skip TXT0 that has already been initialized
+                if( (func == DEV_FUNC_TXT) && (channel == 0) ) continue;
+
+                // all kernel instances compute the target cluster for all chdevs,
+                // computing the global index ext_chdev_gid[func,channel,direction]
+                cxy_t target_cxy;
+                while( 1 )
                 {
-                    continue;
+                    uint32_t offset     = ext_chdev_gid % ( info->x_size * info->y_size );
+                    uint32_t x          = offset / info->y_size;
+                    uint32_t y          = offset % info->y_size;
+
+                    target_cxy = HAL_CXY_FROM_XY( x , y );
+
+                    // exit loop if target cluster is active
+                    if( cluster_is_active( target_cxy ) ) break;
+                
+                    // increment global index otherwise
+                    ext_chdev_gid++;
                 }
 
-                // skip TXT chdevs because they are initialized in internal_devices_init()
-                if ( USE_TXT_MTY == 1 && func == DEV_FUNC_TXT )
-                {
-                    continue;
-                }
-
-                if ( func == DEV_FUNC_IOC && impl == IMPL_IOC_SPI )
-                {
-                    continue;
-                }
-
-                // compute target cluster for chdev[func,channel,direction]
-                uint32_t offset;
-                uint32_t cx;
-                uint32_t cy;
-                uint32_t target_cxy;
-                while (1) {
-                    offset     = ext_chdev_gid % ( info->x_size * (info->y_size) );
-                    cx         = offset / (info->y_size);
-                    cy         = offset % (info->y_size);
-                    target_cxy = (cx<<info->y_width) + cy;
-                    // ext_chdev_gid that results in empty target clusters are skipped
-                    if ( cluster_info_is_active( LOCAL_CLUSTER->cluster_info[cx][cy] ) == 0 ) {
-                        ext_chdev_gid++;
-                    } else { // The ext_chdev_gid resulted in a full target cluster
-                        break;
-                    }
-                }
                 // allocate and initialize a local chdev
                 // when local cluster matches target cluster
@@ -647,6 +547,7 @@
                                           base );
 
-                    assert( (chdev != NULL),
-                            "cannot allocate external device" );
+                    if( chdev == NULL )
+                    printk("\n[PANIC] in %s : cannot allocate chdev for external device\n",
+                    __FUNCTION__ );
 
                     // make device type specific initialisation
@@ -672,9 +573,11 @@
                     for( x = 0 ; x < info->x_size ; x++ )
                     {
-                        for ( y = 0; y < info->y_size; y++ )
+                        for( y = 0 ; y < info->y_size ; y++ )
                         {
-                            if (cluster_info_is_active(info->cluster_info[x][y])) {
-                                cxy_t  cxy = (x<<info->y_width) + y;
-                                hal_remote_swd( XPTR( cxy , entry ),
+                            cxy_t cxy = HAL_CXY_FROM_XY( x , y );
+
+                            if( cluster_is_active( cxy ) )
+                            {
+                                hal_remote_s64( XPTR( cxy , entry ),
                                                 XPTR( local_cxy , chdev ) );
                             }
@@ -706,5 +609,5 @@
 // @ info    : pointer on the local boot-info structure.
 ///////////////////////////////////////////////////////////////////////////////////////////
-static void iopic_init( boot_info_t * info )
+static void __attribute__ ((noinline)) iopic_init( boot_info_t * info )
 {
     boot_device_t * dev_tbl;         // pointer on boot_info external devices array
@@ -723,4 +626,8 @@
     dev_tbl     = info->ext_dev;
 
+    // avoid GCC warning
+    base        = XPTR_NULL;
+    impl        = 0;
+
     // loop on external peripherals to get the IOPIC  
 	for( i = 0 , found = false ; i < dev_nr ; i++ )
@@ -737,5 +644,7 @@
     }
 
-    assert( found , "PIC device not found\n" );
+    // check PIC existence
+    if( found == false )
+    printk("\n[PANIC] in %s : PIC device not found\n", __FUNCTION__ );
 
     // allocate and initialize the PIC chdev in cluster 0
@@ -746,5 +655,7 @@
                           base );
 
-    assert( (chdev != NULL), "no memory for PIC chdev\n" );
+    // check memory
+    if( chdev == NULL )
+    printk("\n[PANIC] in %s : no memory for PIC chdev\n", __FUNCTION__ );
 
     // make PIC device type specific initialisation
@@ -757,9 +668,11 @@
     for( x = 0 ; x < info->x_size ; x++ )
     {
-        for ( y = 0; y < info->y_size; y++ )
+        for( y = 0 ; y < info->y_size ; y++ )
         {
-            if (cluster_info_is_active(info->cluster_info[x][y])) {
-                cxy_t  cxy = (x<<info->y_width) + y;
-                hal_remote_swd( XPTR( cxy , entry ) , 
+            cxy_t cxy = HAL_CXY_FROM_XY( x , y );
+
+            if( cluster_is_active( cxy ) )
+            {
+                hal_remote_s64( XPTR( cxy , entry ) , 
                                 XPTR( local_cxy , chdev ) );
             }
@@ -773,9 +686,12 @@
     for( x = 0 ; x < info->x_size ; x++ )
     {
-        for ( y = 0; y < info->y_size; y++ )
+        for( y = 0 ; y < info->y_size ; y++ )
         {
-            if (cluster_info_is_active(info->cluster_info[x][y])) {
-                cxy_t  cxy = (x<<info->y_width) + y;
-                hal_remote_memset( XPTR( cxy , &iopic_input ) , 0xFF , sizeof(iopic_input_t) );
+            cxy_t cxy = HAL_CXY_FROM_XY( x , y );
+
+            if( cluster_is_active( cxy ) )
+            {
+                hal_remote_memset( XPTR( cxy , &iopic_input ), 
+                                   0xFF , sizeof(iopic_input_t) );
             }
         }
@@ -807,14 +723,16 @@
             else if((func == DEV_FUNC_NIC) && (is_rx != 0)) ptr = &iopic_input.nic_rx[channel];
             else if( func == DEV_FUNC_IOB )                 ptr = &iopic_input.iob;
-            else     assert( false , "illegal source device for IOPIC input" );
+            else     printk("\n[PANIC] in %s : illegal source device for IOPIC input" );
 
             // set one entry in all "iopic_input" structures
             for( x = 0 ; x < info->x_size ; x++ )
             {
-                for ( y = 0; y < info->y_size; y++ )
+                for( y = 0 ; y < info->y_size ; y++ )
                 {
-                    if (cluster_info_is_active(info->cluster_info[x][y])) {
-                        cxy_t  cxy = (x<<info->y_width) + y;
-                        hal_remote_swd( XPTR( cxy , ptr ) , id ); 
+                    cxy_t cxy = HAL_CXY_FROM_XY( x , y );
+
+                    if( cluster_is_active( cxy ) )
+                    {
+                        hal_remote_s64( XPTR( cxy , ptr ) , id ); 
                     }
                 }
@@ -824,5 +742,5 @@
 
 #if( DEBUG_KERNEL_INIT & 0x1 )
-if( hal_time_stamp() > DEBUG_KERNEL_INIT )
+if( hal_tim_stamp() > DEBUG_KERNEL_INIT )
 {
     printk("\n[DBG] %s created PIC chdev in cluster %x at cycle %d\n",
@@ -843,5 +761,5 @@
 // @ info    : pointer on the local boot-info structure.
 ///////////////////////////////////////////////////////////////////////////////////////////
-static void lapic_init( boot_info_t * info )
+static void __attribute__ ((noinline)) lapic_init( boot_info_t * info )
 {
     boot_device_t * dev_tbl;      // pointer on boot_info internal devices array
@@ -896,7 +814,5 @@
                 if     ( func == DEV_FUNC_MMC ) lapic_input.mmc = id;
                 else if( func == DEV_FUNC_DMA ) lapic_input.dma[channel] = id;
-                else if( func == DEV_FUNC_TXT ) lapic_input.mtty = id;
-                else if( func == DEV_FUNC_IOC ) lapic_input.sdcard = id;
-                else assert( false , "illegal source device for LAPIC input" );
+                else     printk("\n[PANIC] in %s : illegal source device for LAPIC input" );
             }
         }
@@ -913,8 +829,8 @@
 // @ return 0 if success / return EINVAL if not found.
 ///////////////////////////////////////////////////////////////////////////////////////////
-static error_t get_core_identifiers( boot_info_t * info,
-                                     lid_t       * lid,
-                                     cxy_t       * cxy,
-                                     gid_t       * gid )
+static error_t __attribute__ ((noinline)) get_core_identifiers( boot_info_t * info,
+                                                                lid_t       * lid,
+                                                                cxy_t       * cxy,
+                                                                gid_t       * gid )
 {
     uint32_t   i;
@@ -989,30 +905,28 @@
     thread->core = &LOCAL_CLUSTER->core_tbl[core_lid];
 
-    // each core initializes the idle thread lists of locks
-    list_root_init( &thread->locks_root );
-    xlist_root_init( XPTR( local_cxy , &thread->xlocks_root ) );
-    thread->local_locks = 0;
-    thread->remote_locks = 0;
-
-    // CP0 in cluster 0 initializes TXT0 chdev descriptor
-    if( core_cxy == 0 && core_lid == 0 ) // [MODIF]
-    {
-        if( USE_TXT_MTY == 1 ) {
-            mtty0_device_init( info );
-        } else {
-            txt0_device_init( info );
-        }
-    }
-
-    /////////////////////////////////////////////////////////////////////////////////
-    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]
-                                        cluster_info_nb_actives(info->cluster_info) );
+    // each core initializes the idle thread locks counters
+    thread->busylocks = 0;
+
+#if DEBUG_BUSYLOCK
+    // each core initialise the idle thread list of busylocks
+    xlist_root_init( XPTR( local_cxy , &thread->busylocks_root ) );
+#endif
+
+    // CP0 initializes cluster info
+    if( core_lid == 0 ) cluster_info_init( info );
+
+    // CP0 in cluster 0 initialises TXT0 chdev descriptor
+    if( (core_lid == 0) && (core_cxy == 0) ) txt0_device_init( info );
+
+    /////////////////////////////////////////////////////////////////////////////////
+    if( core_lid == 0 ) xbarrier_wait( XPTR( 0 , &global_barrier ), 
+                                        (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
     /////////////////////////////////////////////////////////////////////////////////
 
 #if DEBUG_KERNEL_INIT
-if( (core_lid ==  0) & (local_cxy == 0) ) 
-printk("\n[DBG] %s : exit barrier 0 : TXT0 initialized / cycle %d\n",
-__FUNCTION__, (uint32_t)hal_get_cycles() );
+// if( (core_lid ==  0) & (local_cxy == 0) ) 
+printk("\n[DBG] %s : exit barrier 0 : TXT0 initialized / sr %x / cycle %d\n",
+__FUNCTION__, (uint32_t)hal_get_sr(), (uint32_t)hal_get_cycles() );
 #endif
 
@@ -1025,25 +939,20 @@
     // all cores check identifiers
     if( error )
-    {
-        assert( false ,
-        "illegal core identifiers gid = %x / cxy = %x / lid = %d",
-        core_lid , core_cxy , core_lid );
-    }
-
-    // CP0 initializes cluster manager
+    printk("\n[PANIC] in %s : illegal core : gid %x / cxy %x / lid %d",
+    __FUNCTION__, core_lid, core_cxy, core_lid );
+
+    // CP0 initializes cluster manager complex structures
     if( core_lid == 0 )
     {
-        error = cluster_init( info );
+        error = cluster_manager_init( info );
 
         if( error )
-        {
-            assert( false ,
-            "cannot initialise cluster %x", local_cxy );
-        }
+        printk("\n[PANIC] in %s : cannot initialize cluster manager in cluster %x\n",
+        __FUNCTION__, local_cxy );
     }
 
     /////////////////////////////////////////////////////////////////////////////////
-    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]
-                                        cluster_info_nb_actives(info->cluster_info) );
+    if( core_lid == 0 ) xbarrier_wait( XPTR( 0 , &global_barrier ), 
+                                        (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
     /////////////////////////////////////////////////////////////////////////////////
@@ -1051,6 +960,6 @@
 #if DEBUG_KERNEL_INIT
 if( (core_lid ==  0) & (local_cxy == 0) ) 
-printk("\n[DBG] %s : exit barrier 1 : clusters initialised / cycle %d\n",
-__FUNCTION__, (uint32_t)hal_get_cycles() );
+printk("\n[DBG] %s : exit barrier 1 : clusters initialised / sr %x / cycle %d\n",
+__FUNCTION__, (uint32_t)hal_get_sr(), (uint32_t)hal_get_cycles() );
 #endif
 
@@ -1071,6 +980,6 @@
     
     ////////////////////////////////////////////////////////////////////////////////
-    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]
-                                        cluster_info_nb_actives(info->cluster_info) );
+    if( core_lid == 0 ) xbarrier_wait( XPTR( 0 , &global_barrier ), 
+                                        (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
     ////////////////////////////////////////////////////////////////////////////////
@@ -1078,6 +987,6 @@
 #if DEBUG_KERNEL_INIT
 if( (core_lid ==  0) & (local_cxy == 0) ) 
-printk("\n[DBG] %s : exit barrier 2 : PIC initialised / cycle %d\n",
-__FUNCTION__, (uint32_t)hal_get_cycles() );
+printk("\n[DBG] %s : exit barrier 2 : PIC initialised / sr %x / cycle %d\n",
+__FUNCTION__, (uint32_t)hal_get_sr(), (uint32_t)hal_get_cycles() );
 #endif
 
@@ -1104,6 +1013,6 @@
 
     /////////////////////////////////////////////////////////////////////////////////
-    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]
-                                        cluster_info_nb_actives(info->cluster_info) );
+    if( core_lid == 0 ) xbarrier_wait( XPTR( 0 , &global_barrier ), 
+                                        (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
     /////////////////////////////////////////////////////////////////////////////////
@@ -1111,6 +1020,6 @@
 #if DEBUG_KERNEL_INIT
 if( (core_lid ==  0) & (local_cxy == 0) ) 
-printk("\n[DBG] %s : exit barrier 3 : all chdev initialised / cycle %d\n",
-__FUNCTION__, (uint32_t)hal_get_cycles() );
+printk("\n[DBG] %s : exit barrier 3 : all chdev initialised / sr %x / cycle %d\n",
+__FUNCTION__, (uint32_t)hal_get_sr(), (uint32_t)hal_get_cycles() );
 #endif
 
@@ -1127,12 +1036,7 @@
     /////////////////////////////////////////////////////////////////////////////////
 
-    // All cores enable the shared IPI channel
+    // All cores enable IPI 
     dev_pic_enable_ipi();
     hal_enable_irq( &status );
-
-#if DEBUG_KERNEL_INIT
-printk("\n[DBG] %s: IPI enabled for core %d cluster %d\n", __FUNCTION__,
-  core_lid, local_cxy);
-#endif
 
     // all cores initialize the idle thread descriptor
@@ -1163,6 +1067,7 @@
             fatfs_ctx_t * fatfs_ctx = fatfs_ctx_alloc();
 
-            assert( (fatfs_ctx != NULL) ,
-                    "cannot create FATFS context in cluster 0\n" );
+            if( fatfs_ctx == NULL )
+            printk("\n[PANIC] in %s : cannot create FATFS context in cluster 0\n",
+            __FUNCTION__ );
 
             // 2. access boot device to initialize FATFS context
@@ -1175,5 +1080,13 @@
             uint32_t total_clusters   = fatfs_ctx->fat_sectors_count << 7;
  
-            // 4. create VFS root inode in cluster 0
+            // 4. initialize the FATFS entry in the vfs_context[] array 
+            vfs_ctx_init( FS_TYPE_FATFS,                               // fs type
+                          0,                                           // attributes: unused 
+	                      total_clusters,                
+	                      cluster_size,
+	                      vfs_root_inode_xp,                           // VFS root
+                          fatfs_ctx );                                 // extend
+
+            // 5. create VFS root inode in cluster 0
             error = vfs_inode_create( XPTR_NULL,                           // dentry_xp
                                       FS_TYPE_FATFS,                       // fs_type
@@ -1185,25 +1098,22 @@
                                       0,                                   // gid
                                       &vfs_root_inode_xp );                // return
-
-            assert( (error == 0) ,
-                    "cannot create VFS root inode\n" );
-
-            // 5. initialize VFS context for FAT in cluster 0
-            vfs_ctx_init( FS_TYPE_FATFS,                 // file system type
-                          0,                             // attributes 
-	                      total_clusters,                
-	                      cluster_size,
-	                      vfs_root_inode_xp,             // VFS root
-                          fatfs_ctx );                   // extend
-
-            // 6. check initialisation
+            if( error )
+            printk("\n[PANIC] in %s : cannot create VFS root inode in cluster 0\n",
+            __FUNCTION__ );
+
+            // 6. update the FATFS entry in vfs_context[] array
+            fs_context[FS_TYPE_FATFS].vfs_root_xp = vfs_root_inode_xp;
+
+            // 7. check FATFS initialization
             vfs_ctx_t   * vfs_ctx = &fs_context[FS_TYPE_FATFS];
-            assert( (((fatfs_ctx_t *)vfs_ctx->extend)->sectors_per_cluster == 8),
-             "illegal value for FATFS context in cluster %x\n", local_cxy );
+
+            if( ((fatfs_ctx_t *)vfs_ctx->extend)->sectors_per_cluster != 8 )
+            printk("\n[PANIC] in %s : illegal FATFS context in cluster 0\n",
+            __FUNCTION__ );
         }
         else
         {
-            assert( false ,
-            "root FS must be FATFS" );
+            printk("\n[PANIC] in %s : unsupported VFS type in cluster 0\n",
+            __FUNCTION__ );
         }
 
@@ -1214,6 +1124,6 @@
 
     /////////////////////////////////////////////////////////////////////////////////
-    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]
-                                        cluster_info_nb_actives(info->cluster_info) );
+    if( core_lid == 0 ) xbarrier_wait( XPTR( 0 , &global_barrier ), 
+                                        (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
     /////////////////////////////////////////////////////////////////////////////////
@@ -1221,6 +1131,6 @@
 #if DEBUG_KERNEL_INIT
 if( (core_lid ==  0) & (local_cxy == 0) ) 
-printk("\n[DBG] %s : exit barrier 4 : VFS_root = %l in cluster 0 / cycle %d\n",
-__FUNCTION__, vfs_root_inode_xp , (uint32_t)hal_get_cycles());
+printk("\n[DBG] %s : exit barrier 4 : VFS root initialized in cluster 0 / sr %x / cycle %d\n",
+__FUNCTION__, (uint32_t)hal_get_sr(), (uint32_t)hal_get_cycles() );
 #endif
 
@@ -1241,6 +1151,8 @@
             fatfs_ctx_t * local_fatfs_ctx = fatfs_ctx_alloc();
 
-            assert( (local_fatfs_ctx != NULL) ,
-            "cannot create FATFS context in cluster %x\n", local_cxy );
+            // check memory
+            if( local_fatfs_ctx == NULL )
+            printk("\n[PANIC] in %s : cannot create FATFS context in cluster %x\n",
+            __FUNCTION__ , local_cxy );
 
             // 2. get local pointer on VFS context for FATFS
@@ -1261,11 +1173,11 @@
             vfs_ctx->extend = local_fatfs_ctx;
 
-            // 7. check initialisation
-            assert( (((fatfs_ctx_t *)vfs_ctx->extend)->sectors_per_cluster == 8),
-            "illegal value for FATFS context in cluster %x\n", local_cxy );
+            if( ((fatfs_ctx_t *)vfs_ctx->extend)->sectors_per_cluster != 8 )
+            printk("\n[PANIC] in %s : illegal FATFS context in cluster %x\n",
+            __FUNCTION__ , local_cxy );
         }
 
         // get extended pointer on VFS root inode from cluster 0
-        vfs_root_inode_xp = hal_remote_lwd( XPTR( 0 , &process_zero.vfs_root_xp ) );
+        vfs_root_inode_xp = hal_remote_l64( XPTR( 0 , &process_zero.vfs_root_xp ) );
 
         // update local process_zero descriptor
@@ -1275,41 +1187,52 @@
 
     /////////////////////////////////////////////////////////////////////////////////
-    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]
-                                        cluster_info_nb_actives(info->cluster_info) );
+    if( core_lid == 0 ) xbarrier_wait( XPTR( 0 , &global_barrier ), 
+                                        (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
     /////////////////////////////////////////////////////////////////////////////////
 
 #if DEBUG_KERNEL_INIT
-if( (core_lid ==  0) & (local_cxy == 0) ) 
-printk("\n[DBG] %s : exit barrier 5 : VFS_root = %l in cluster 0 / cycle %d\n",
-__FUNCTION__, vfs_root_inode_xp , (uint32_t)hal_get_cycles());
-#endif
-
-    /////////////////////////////////////////////////////////////////////////////////
-    // STEP 6 : CP0 in cluster IO makes the global DEVFS tree initialisation:
-    //          It creates the DEVFS directory "dev", and the DEVFS "external"
-    //          directory in cluster IO and mount these inodes into VFS.
-    /////////////////////////////////////////////////////////////////////////////////
-
-    if( (core_lid ==  0) && (local_cxy == 0) )  // [FIXME]
+if( (core_lid ==  0) & (local_cxy == 1) ) 
+printk("\n[DBG] %s : exit barrier 5 : VFS root initialized in cluster 1 / sr %x / cycle %d\n",
+__FUNCTION__, (uint32_t)hal_get_sr(), (uint32_t)hal_get_cycles() );
+#endif
+
+    /////////////////////////////////////////////////////////////////////////////////
+    // STEP 6 : CP0 in cluster 0 makes the global DEVFS tree initialisation:
+    //          It initializes the DEVFS context, and creates the DEVFS
+    //          "dev" and "external" inodes in cluster 0.
+    /////////////////////////////////////////////////////////////////////////////////
+
+    if( (core_lid ==  0) && (local_cxy == 0) ) 
     {
-        // create "dev" and "external" directories.
+        // 1. allocate memory for DEVFS context extension in cluster 0
+        devfs_ctx_t * devfs_ctx = devfs_ctx_alloc();
+
+        if( devfs_ctx == NULL )
+        printk("\n[PANIC] in %s : cannot create DEVFS context in cluster 0\n",
+        __FUNCTION__ , local_cxy );
+
+        // 2. initialize the DEVFS entry in the vfs_context[] array 
+        vfs_ctx_init( FS_TYPE_DEVFS,                                // fs type
+                      0,                                            // attributes: unused
+	                  0,                                            // total_clusters: unused
+	                  0,                                            // cluster_size: unused 
+	                  vfs_root_inode_xp,                            // VFS root
+                      devfs_ctx );                                  // extend
+
+        // 3. create "dev" and "external" inodes (directories)
         devfs_global_init( process_zero.vfs_root_xp,
                            &devfs_dev_inode_xp,
                            &devfs_external_inode_xp );
 
-        // creates the DEVFS context in cluster IO
-        devfs_ctx_t * devfs_ctx = devfs_ctx_alloc();
-
-        assert( (devfs_ctx != NULL) ,
-                "cannot create DEVFS context in cluster IO\n");
-
-        // register DEVFS root and external directories
-        devfs_ctx_init( devfs_ctx, devfs_dev_inode_xp, devfs_external_inode_xp );
+        // 4. initializes DEVFS context extension
+        devfs_ctx_init( devfs_ctx,
+                        devfs_dev_inode_xp,
+                        devfs_external_inode_xp );
     }    
 
     /////////////////////////////////////////////////////////////////////////////////
-    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]
-                                        cluster_info_nb_actives(info->cluster_info) );
+    if( core_lid == 0 ) xbarrier_wait( XPTR( 0 , &global_barrier ), 
+                                        (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
     /////////////////////////////////////////////////////////////////////////////////
@@ -1317,6 +1240,6 @@
 #if DEBUG_KERNEL_INIT
 if( (core_lid ==  0) & (local_cxy == 0) ) 
-printk("\n[DBG] %s : exit barrier 6 : dev_root = %l in cluster 0 / cycle %d\n",
-__FUNCTION__, devfs_dev_inode_xp , (uint32_t)hal_get_cycles() );
+printk("\n[DBG] %s : exit barrier 6 : DEVFS root initialized in cluster 0 / sr %x / cycle %d\n",
+__FUNCTION__, (uint32_t)hal_get_sr(), (uint32_t)hal_get_cycles() );
 #endif
 
@@ -1324,6 +1247,6 @@
     // STEP 7 : All CP0s complete in parallel the DEVFS tree initialization.
     //          Each CP0 get the "dev" and "external" extended pointers from
-    //          values stored in cluster IO. 
-    //          Then each CP0 in cluster(i) creates the DEVFS "internal directory, 
+    //          values stored in cluster 0. 
+    //          Then each CP0 in cluster(i) creates the DEVFS "internal" directory, 
     //          and creates the pseudo-files for all chdevs in cluster (i).
     /////////////////////////////////////////////////////////////////////////////////
@@ -1331,12 +1254,12 @@
     if( core_lid == 0 )
     {
-        // get extended pointer on "extend" field of VFS context for DEVFS in cluster IO
-        xptr_t  extend_xp = XPTR( 0 , &fs_context[FS_TYPE_DEVFS].extend ); // [FIXME]
+        // get extended pointer on "extend" field of VFS context for DEVFS in cluster 0
+        xptr_t  extend_xp = XPTR( 0 , &fs_context[FS_TYPE_DEVFS].extend );
 
         // get pointer on DEVFS context in cluster 0
         devfs_ctx_t * devfs_ctx = hal_remote_lpt( extend_xp );
         
-        devfs_dev_inode_xp      = hal_remote_lwd( XPTR( 0 , &devfs_ctx->dev_inode_xp ) );
-        devfs_external_inode_xp = hal_remote_lwd( XPTR( 0 , &devfs_ctx->external_inode_xp ) );
+        devfs_dev_inode_xp      = hal_remote_l64( XPTR( 0 , &devfs_ctx->dev_inode_xp ) );
+        devfs_external_inode_xp = hal_remote_l64( XPTR( 0 , &devfs_ctx->external_inode_xp ) );
 
         // populate DEVFS in all clusters
@@ -1347,6 +1270,6 @@
 
     /////////////////////////////////////////////////////////////////////////////////
-    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]
-                                        cluster_info_nb_actives(info->cluster_info) );
+    if( core_lid == 0 ) xbarrier_wait( XPTR( 0 , &global_barrier ), 
+                                        (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
     /////////////////////////////////////////////////////////////////////////////////
@@ -1354,6 +1277,6 @@
 #if DEBUG_KERNEL_INIT
 if( (core_lid ==  0) & (local_cxy == 0) ) 
-printk("\n[DBG] %s : exit barrier 7 : dev_root = %l in cluster 0 / cycle %d\n",
-__FUNCTION__, devfs_dev_inode_xp , (uint32_t)hal_get_cycles() );
+printk("\n[DBG] %s : exit barrier 7 : DEV initialized in cluster 0 / sr %x / cycle %d\n",
+__FUNCTION__, (uint32_t)hal_get_sr(), (uint32_t)hal_get_cycles() );
 #endif
 
@@ -1373,6 +1296,6 @@
 
     /////////////////////////////////////////////////////////////////////////////////
-    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]
-                                        cluster_info_nb_actives(info->cluster_info) );
+    if( core_lid == 0 ) xbarrier_wait( XPTR( 0 , &global_barrier ),
+                                        (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
     /////////////////////////////////////////////////////////////////////////////////
@@ -1380,10 +1303,10 @@
 #if DEBUG_KERNEL_INIT
 if( (core_lid ==  0) & (local_cxy == 0) ) 
-printk("\n[DBG] %s : exit barrier 8 : process init created / cycle %d\n", 
-__FUNCTION__ , (uint32_t)hal_get_cycles() );
+printk("\n[DBG] %s : exit barrier 8 : process init created / sr %x / cycle %d\n", 
+__FUNCTION__, (uint32_t)hal_get_sr(), (uint32_t)hal_get_cycles() );
 #endif
 
 #if (DEBUG_KERNEL_INIT & 1)
-if( (core_lid ==  0) /*& (local_cxy == 0)*/ ) 
+if( (core_lid ==  0) & (local_cxy == 0) ) 
 sched_display( 0 );
 #endif
@@ -1393,5 +1316,5 @@
     /////////////////////////////////////////////////////////////////////////////////
     
-    if( (core_lid ==  0) && (local_cxy == 0) ) // [FIXME]
+    if( (core_lid == 0) && (local_cxy == 0) ) 
     {
         print_banner( (info->x_size * info->y_size) , info->cores_nr );
@@ -1415,28 +1338,32 @@
                    " - list item          : %d bytes\n"
                    " - xlist item         : %d bytes\n"
-                   " - spinlock           : %d bytes\n"
-                   " - remote spinlock    : %d bytes\n"
+                   " - busylock           : %d bytes\n"
+                   " - remote busylock    : %d bytes\n"
+                   " - queuelock          : %d bytes\n"
+                   " - remote queuelock   : %d bytes\n"
                    " - rwlock             : %d bytes\n"
                    " - remote rwlock      : %d bytes\n",
-                   sizeof( thread_t          ),
-                   sizeof( process_t         ),
-                   sizeof( cluster_t         ),
-                   sizeof( chdev_t           ),
-                   sizeof( core_t            ),
-                   sizeof( scheduler_t       ),
-                   sizeof( remote_fifo_t     ),
-                   sizeof( page_t            ),
-                   sizeof( mapper_t          ),
-                   sizeof( ppm_t             ),
-                   sizeof( kcm_t             ),
-                   sizeof( khm_t             ),
-                   sizeof( vmm_t             ),
-                   sizeof( gpt_t             ),
-                   sizeof( list_entry_t      ),
-                   sizeof( xlist_entry_t     ),
-                   sizeof( spinlock_t        ),
-                   sizeof( remote_spinlock_t ),
-                   sizeof( rwlock_t          ),
-                   sizeof( remote_rwlock_t   ));
+                   sizeof( thread_t           ),
+                   sizeof( process_t          ),
+                   sizeof( cluster_t          ),
+                   sizeof( chdev_t            ),
+                   sizeof( core_t             ),
+                   sizeof( scheduler_t        ),
+                   sizeof( remote_fifo_t      ),
+                   sizeof( page_t             ),
+                   sizeof( mapper_t           ),
+                   sizeof( ppm_t              ),
+                   sizeof( kcm_t              ),
+                   sizeof( khm_t              ),
+                   sizeof( vmm_t              ),
+                   sizeof( gpt_t              ),
+                   sizeof( list_entry_t       ),
+                   sizeof( xlist_entry_t      ),
+                   sizeof( busylock_t         ),
+                   sizeof( remote_busylock_t  ),
+                   sizeof( queuelock_t        ),
+                   sizeof( remote_queuelock_t ),
+                   sizeof( rwlock_t           ),
+                   sizeof( remote_rwlock_t    ));
 #endif
 
