Changeset 623 for trunk/kernel/kern

Timestamp:

Mar 6, 2019, 4:37:15 PM (6 years ago)

Author:

alain

Message:

Introduce three new types of vsegs (KCODE,KDATA,KDEV)
to map the kernel vsegs in the process VSL and GPT.
This now used by both the TSAR and the I86 architectures.

Location:

trunk/kernel/kern

Files:

• kernel_init.c (modified) (28 diffs)
• printk.c (modified) (14 diffs)
• printk.h (modified) (3 diffs)
• process.c (modified) (6 diffs)
• process.h (modified) (4 diffs)
• rpc.c (modified) (18 diffs)
• rpc.h (modified) (8 diffs)
• thread.c (modified) (2 diffs)

trunk/kernel/kern/kernel_init.c

@@ -3 +3 @@
  *
  * Authors :  Mohamed Lamine Karaoui (2015)
- *            Alain Greiner  (2016,2017,2018)
+ *            Alain Greiner  (2016,2017,2018,2019)
  *
  * Copyright (c) Sorbonne Universites
@@ -113 +113 @@
 cxy_t                local_cxy                               CONFIG_CACHE_LINE_ALIGNED;
 
-// This variable is used for CP0 cores synchronisation in kernel_init()
+// This variable is used for core[0] cores synchronisation in kernel_init()
 __attribute__((section(".kdata")))
 xbarrier_t           global_barrier                          CONFIG_CACHE_LINE_ALIGNED;
@@ -126 +126 @@
 
 // kernel_init is the entry point defined in hal/tsar_mips32/kernel.ld
-// It is used by the bootloader.
+// It is used by the bootloader to tranfer control to kernel.
 extern void kernel_init( boot_info_t * info );
 
@@ -466 +466 @@
 // These chdev descriptors are distributed on all clusters, using a modulo on a global 
 // index, identically computed in all clusters.
-// This function is executed in all clusters by the CP0 core, that computes a global index
-// for all external chdevs. Each CP0 core creates only the chdevs that must be placed in 
+// This function is executed in all clusters by the core[0] core, that computes a global index
+// for all external chdevs. Each core[0] core creates only the chdevs that must be placed in 
 // the local cluster, because the global index matches the local index. 
 // The relevant entries in all copies of the devices directory are initialised.
@@ -626 +626 @@
 
 ///////////////////////////////////////////////////////////////////////////////////////////
-// This function is called by CP0 in cluster 0 to allocate memory and initialize the PIC
+// This function is called by core[0] in cluster 0 to allocate memory and initialize the PIC
 // device, namely the informations attached to the external IOPIC controller, that
 // must be replicated in all clusters (struct iopic_input).
@@ -791 +791 @@
 
 ///////////////////////////////////////////////////////////////////////////////////////////
-// This function is called by all CP0s in all cluster to complete the PIC device
+// This function is called by all core[0]s in all cluster to complete the PIC device
 // initialisation, namely the informations attached to the LAPIC controller.
 // This initialisation must be done after the IOPIC initialisation, but before other 
@@ -899 +899 @@
 ///////////////////////////////////////////////////////////////////////////////////////////
 // This function is the entry point for the kernel initialisation.
-// It is executed by all cores in all clusters, but only core[0], called CP0,
-// initializes the shared resources such as the cluster manager, or the local peripherals.
+// It is executed by all cores in all clusters, but only core[0] initializes
+// the shared resources such as the cluster manager, or the local peripherals.
 // To comply with the multi-kernels paradigm, it accesses only local cluster memory, using
 // only information contained in the local boot_info_t structure, set by the bootloader.
-// Only CP0 in cluster 0 print the log messages.
+// Only core[0] in cluster 0 print the log messages.
 ///////////////////////////////////////////////////////////////////////////////////////////
 // @ info    : pointer on the local boot-info structure.
@@ -925 +925 @@
 
     /////////////////////////////////////////////////////////////////////////////////
-    // STEP 0 : Each core get its core identifier from boot_info, and makes 
+    // STEP 1 : Each core get its core identifier from boot_info, and makes 
     //          a partial initialisation of its private idle thread descriptor.
-    //          CP0 initializes the "local_cxy" global variable.
-    //          CP0 in cluster IO initializes the TXT0 chdev to print log messages.
+    //          core[0] initializes the "local_cxy" global variable.
+    //          core[0] in cluster[0] initializes the TXT0 chdev for log messages.
     /////////////////////////////////////////////////////////////////////////////////
 
@@ -936 +936 @@
                                   &core_gid );
 
-    // all CP0s initialize cluster identifier
+    // core[0] initialize cluster identifier
     if( core_lid == 0 ) local_cxy = info->cxy;
 
@@ -956 +956 @@
 #endif
 
-    // all CP0s initialize cluster info
+    // core[0] initializes cluster info
     if( core_lid == 0 ) cluster_info_init( info );
 
-    // CP0 in cluster 0 initialises TXT0 chdev descriptor
+    // core[0] in cluster[0] initialises TXT0 chdev descriptor
     if( (core_lid == 0) && (core_cxy == 0) ) txt0_device_init( info );
+
+    // all cores check identifiers
+    if( error )
+    {
+        printk("\n[PANIC] in %s : illegal core : gid %x / cxy %x / lid %d",
+        __FUNCTION__, core_lid, core_cxy, core_lid );
+        hal_core_sleep();
+    }
 
     /////////////////////////////////////////////////////////////////////////////////
@@ -970 +978 @@
 #if DEBUG_KERNEL_INIT
 if( (core_lid ==  0) & (local_cxy == 0) ) 
-printk("\n[%s] : exit barrier 0 : TXT0 initialized / cycle %d\n",
+printk("\n[%s] : exit barrier 1 : TXT0 initialized / cycle %d\n",
 __FUNCTION__, (uint32_t)hal_get_cycles() );
 #endif
 
-    /////////////////////////////////////////////////////////////////////////////
-    // STEP 1 : all cores check core identifier.
-    //          CP0 initializes the local cluster manager.
-    //          This includes the memory allocators.
-    /////////////////////////////////////////////////////////////////////////////
-
-    // all cores check identifiers
-    if( error )
-    {
-        printk("\n[PANIC] in %s : illegal core : gid %x / cxy %x / lid %d",
-        __FUNCTION__, core_lid, core_cxy, core_lid );
-        hal_core_sleep();
-    }
-
-    // all CP0s initialise DQDT (only CPO in cluster 0 build the quad-tree)
+    /////////////////////////////////////////////////////////////////////////////////
+    // STEP 2 : core[0] initializes the cluter manager,
+    //          including the physical memory allocator. 
+    /////////////////////////////////////////////////////////////////////////////////
+
+    // core[0] initialises DQDT (only core[0] in cluster 0 build the quad-tree)
     if( core_lid == 0 ) dqdt_init();
     
-    // all CP0s initialize other cluster manager complex structures
+    // core[0] initialize other cluster manager complex structures
     if( core_lid == 0 )
     {
@@ -1012 +1011 @@
 #if DEBUG_KERNEL_INIT
 if( (core_lid ==  0) & (local_cxy == 0) ) 
-printk("\n[%s] : exit barrier 1 : clusters initialised / cycle %d\n",
+printk("\n[%s] : exit barrier 2 : cluster manager initialized / cycle %d\n",
 __FUNCTION__, (uint32_t)hal_get_cycles() );
 #endif
 
     /////////////////////////////////////////////////////////////////////////////////
-    // STEP 2 : CP0 initializes the process_zero descriptor.
-    //          CP0 in cluster 0 initializes the IOPIC device.
+    // STEP 3 : core[0] initializes the process_zero descriptor,
+    //          including the kernel VMM (both GPT and VSL) 
     /////////////////////////////////////////////////////////////////////////////////
 
@@ -1025 +1024 @@
     core    = &cluster->core_tbl[core_lid];
 
-    // all CP0s initialize the process_zero descriptor
-    if( core_lid == 0 ) process_zero_create( &process_zero );
-
-    // CP0 in cluster 0 initializes the PIC chdev,
+    // core[0] initializes the process_zero descriptor,
+    if( core_lid == 0 ) process_zero_create( &process_zero , 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[%s] : exit barrier 3 : kernel processs initialized / cycle %d\n",
+__FUNCTION__, (uint32_t)hal_get_cycles() );
+#endif
+
+    /////////////////////////////////////////////////////////////////////////////////
+    // STEP 4 : all cores initialize their private MMU 
+    //          core[0] in cluster 0 initializes the IOPIC device.
+    /////////////////////////////////////////////////////////////////////////////////
+
+    // all cores initialise their MMU
+    hal_mmu_init( &process_zero.vmm.gpt );
+
+    // core[0] in cluster[0] initializes the PIC chdev,
     if( (core_lid == 0) && (local_cxy == 0) ) iopic_init( info );
     
@@ -1039 +1058 @@
 #if DEBUG_KERNEL_INIT
 if( (core_lid ==  0) & (local_cxy == 0) ) 
-printk("\n[%s] : exit barrier 2 : PIC initialised / cycle %d\n",
+printk("\n[%s] : exit barrier 4 : MMU and IOPIC initialized / cycle %d\n",
 __FUNCTION__, (uint32_t)hal_get_cycles() );
 #endif
 
     ////////////////////////////////////////////////////////////////////////////////
-    // STEP 3 : CP0 initializes the distibuted LAPIC descriptor.
-    //          CP0 initializes the internal chdev descriptors
-    //          CP0 initialize the local external chdev descriptors
+    // STEP 5 : core[0] initializes the distibuted LAPIC descriptor.
+    //          core[0] initializes the internal chdev descriptors
+    //          core[0] initialize the local external chdev descriptors
     ////////////////////////////////////////////////////////////////////////////////
 
-    // all CP0s initialize their local LAPIC extension,
+    // all core[0]s initialize their local LAPIC extension,
     if( core_lid == 0 ) lapic_init( info );
 
-    // CP0 scan the internal (private) peripherals,
+    // core[0] scan the internal (private) peripherals,
     // and allocates memory for the corresponding chdev descriptors.
     if( core_lid == 0 ) internal_devices_init( info );
         
 
-    // All CP0s contribute to initialise external peripheral chdev descriptors.
-    // Each CP0[cxy] scan the set of external (shared) peripherals (but the TXT0),
+    // All core[0]s contribute to initialise external peripheral chdev descriptors.
+    // Each core[0][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 the global index value.
@@ -1072 +1091 @@
 #if DEBUG_KERNEL_INIT
 if( (core_lid ==  0) & (local_cxy == 0) ) 
-printk("\n[%s] : exit barrier 3 : all chdevs initialised / cycle %d\n",
+printk("\n[%s] : exit barrier 5 : all chdevs initialised / cycle %d\n",
 __FUNCTION__, (uint32_t)hal_get_cycles() );
 #endif
@@ -1082 +1101 @@
     
     /////////////////////////////////////////////////////////////////////////////////
-    // STEP 4 : All cores enable IPI (Inter Procesor Interrupt),
+    // STEP 6 : All cores enable IPI (Inter Procesor Interrupt),
     //          Alh cores initialize IDLE thread.
-    //          Only CP0 in cluster 0 creates the VFS root inode.
+    //          Only core[0] in cluster[0] creates the VFS root inode.
     //          It access the boot device to initialize the file system context.
     /////////////////////////////////////////////////////////////////////////////////
@@ -1107 +1126 @@
 #endif
 
-    // CPO in cluster 0 creates the VFS root
+    // core[O] in cluster[0] creates the VFS root
     if( (core_lid ==  0) && (local_cxy == 0 ) ) 
     {
@@ -1137 +1156 @@
             // 4. create VFS root inode in cluster 0
             error = vfs_inode_create( FS_TYPE_FATFS,                       // fs_type
-                                      INODE_TYPE_DIR,                      // inode_type
                                       0,                                   // attr
                                       0,                                   // rights
@@ -1150 +1168 @@
             }
 
-            // 5. update FATFS root inode extension  
+            // 5. update FATFS root inode "type" and "extend" fields  
             cxy_t         vfs_root_cxy = GET_CXY( vfs_root_inode_xp );
             vfs_inode_t * vfs_root_ptr = GET_PTR( vfs_root_inode_xp );
+            hal_remote_s32( XPTR( vfs_root_cxy , &vfs_root_ptr->extend ), INODE_TYPE_DIR );
             hal_remote_spt( XPTR( vfs_root_cxy , &vfs_root_ptr->extend ), 
                             (void*)(intptr_t)root_dir_cluster );
@@ -1189 +1208 @@
 #if DEBUG_KERNEL_INIT
 if( (core_lid ==  0) & (local_cxy == 0) ) 
-printk("\n[%s] : exit barrier 4 : VFS root (%x,%x) in cluster 0 / cycle %d\n",
+printk("\n[%s] : exit barrier 6 : VFS root (%x,%x) in cluster 0 / cycle %d\n",
 __FUNCTION__, GET_CXY(process_zero.vfs_root_xp),
 GET_PTR(process_zero.vfs_root_xp), (uint32_t)hal_get_cycles() );
@@ -1195 +1214 @@
 
     /////////////////////////////////////////////////////////////////////////////////
-    // STEP 5 : Other CP0s allocate memory for the selected FS context,
-    //          and initialise both the local FS context and the local VFS context
-    //          from values stored in cluster 0. 
+    // STEP 7 : In all other clusters than cluster[0], the core[0] allocates memory
+    //          for the selected FS context, and initialise the local FS context and 
+    //          the local VFS context from values stored in cluster 0. 
     //          They get the VFS root inode extended pointer from cluster 0.
     /////////////////////////////////////////////////////////////////////////////////
@@ -1259 +1278 @@
 #if DEBUG_KERNEL_INIT
 if( (core_lid ==  0) & (local_cxy == 1) ) 
-printk("\n[%s] : exit barrier 5 : VFS root (%x,%x) in cluster 1 / cycle %d\n",
+printk("\n[%s] : exit barrier 7 : VFS root (%x,%x) in cluster 1 / cycle %d\n",
 __FUNCTION__, GET_CXY(process_zero.vfs_root_xp),
 GET_PTR(process_zero.vfs_root_xp), (uint32_t)hal_get_cycles() );
@@ -1265 +1284 @@
 
     /////////////////////////////////////////////////////////////////////////////////
-    // STEP 6 : CP0 in cluster 0 makes the global DEVFS tree initialisation:
+    // STEP 8 : core[0] in cluster 0 makes the global DEVFS initialisation:
     //          It initializes the DEVFS context, and creates the DEVFS
     //          "dev" and "external" inodes in cluster 0.
@@ -1309 +1328 @@
 #if DEBUG_KERNEL_INIT
 if( (core_lid ==  0) & (local_cxy == 0) ) 
-printk("\n[%s] : exit barrier 6 : DEVFS root initialized in cluster 0 / cycle %d\n",
+printk("\n[%s] : exit barrier 8 : DEVFS root initialized in cluster 0 / cycle %d\n",
 __FUNCTION__, (uint32_t)hal_get_cycles() );
 #endif
 
     /////////////////////////////////////////////////////////////////////////////////
-    // STEP 7 : All CP0s complete in parallel the DEVFS tree initialization.
-    //          Each CP0 get the "dev" and "external" extended pointers from
+    // STEP 9 : All core[0]s complete in parallel the DEVFS initialization.
+    //          Each core[0] get the "dev" and "external" extended pointers from
     //          values stored in cluster 0. 
-    //          Then each CP0 in cluster(i) creates the DEVFS "internal" directory, 
+    //          Then each core[0] in cluster(i) creates the DEVFS "internal" directory, 
     //          and creates the pseudo-files for all chdevs in cluster (i).
     /////////////////////////////////////////////////////////////////////////////////
@@ -1346 +1365 @@
 #if DEBUG_KERNEL_INIT
 if( (core_lid ==  0) & (local_cxy == 0) ) 
-printk("\n[%s] : exit barrier 7 : DEV initialized in cluster 0 / cycle %d\n",
+printk("\n[%s] : exit barrier 9 : DEVFS initialized in cluster 0 / cycle %d\n",
 __FUNCTION__, (uint32_t)hal_get_cycles() );
 #endif
 
-    /////////////////////////////////////////////////////////////////////////////////
-    // STEP 8 : CP0 in cluster 0 creates the first user process (process_init)
+#if( DEBUG_KERNEL_INIT & 1 )
+if( (core_lid ==  0) & (local_cxy == 0) ) 
+vfs_display( vfs_root_inode_xp );
+#endif
+
+    /////////////////////////////////////////////////////////////////////////////////
+    // STEP 10 : core[0] in cluster 0 creates the first user process (process_init).
+    //           This include the first user process VMM (GPT and VSL) creation.
+    //           Finally, it prints the ALMOS-MKH banner.
     /////////////////////////////////////////////////////////////////////////////////
 
     if( (core_lid == 0) && (local_cxy == 0) ) 
     {
-
-#if( DEBUG_KERNEL_INIT & 1 )
-vfs_display( vfs_root_inode_xp );
-#endif
-
        process_init_create();
     }
-
-    /////////////////////////////////////////////////////////////////////////////////
-    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[%s] : exit barrier 8 : process init created / cycle %d\n", 
-__FUNCTION__, (uint32_t)hal_get_cycles() );
-#endif
 
 #if (DEBUG_KERNEL_INIT & 1)
@@ -1381 +1390 @@
 #endif
 
-    /////////////////////////////////////////////////////////////////////////////////
-    // STEP 9 : CP0 in cluster 0 print banner
-    /////////////////////////////////////////////////////////////////////////////////
-    
     if( (core_lid == 0) && (local_cxy == 0) ) 
     {
         print_banner( (info->x_size * info->y_size) , info->cores_nr );
+    }
 
 #if( DEBUG_KERNEL_INIT & 1 )
+if( (core_lid ==  0) & (local_cxy == 0) ) 
 printk("\n\n***** memory fooprint for main kernel objects\n\n"
                    " - thread descriptor  : %d bytes\n"
@@ -1437 +1444 @@
 #endif
 
-    }
+    // each core updates the register(s) definig the kernel
+    // entry points for interrupts, exceptions and syscalls...
+    hal_set_kentry();
 
     // each core activates its private TICK IRQ
@@ -1448 +1457 @@
     /////////////////////////////////////////////////////////////////////////////////
 
-#if DEBUG_KERNEL_INIT
+#if( DEBUG_KERNEL_INIT & 1 )
 thread_t * this = CURRENT_THREAD;
 printk("\n[%s] : thread[%x,%x] on core[%x,%d] jumps to thread_idle_func() / cycle %d\n",

trunk/kernel/kern/printk.c

@@ -48 +48 @@
 
     va_list    args;      // printf arguments
-    uint32_t   ps;        // write pointer to the string buffer
+    uint32_t   ps;        // pointer to the string buffer
 
     ps = 0;   
@@ -57 +57 @@
     while ( *format != 0 ) 
     {
-
         if (*format == '%')   // copy argument to string
         {
@@ -98 +97 @@
                 break;
             }
-            case ('d'):             // decimal signed integer
+            case ('b'):             // excactly 2 digits hexadecimal integer
+            {
+                int  val = va_arg( args, int );
+                int  val_lsb = val & 0xF;
+                int  val_msb = (val >> 4) & 0xF;
+                buf[0] = HexaTab[val_msb];
+                buf[1] = HexaTab[val_lsb];
+                len  = 2;
+                pbuf = buf;
+                break;
+            }
+            case ('d'):             // up to 10 digits decimal signed integer
             {
                 int val = va_arg( args, int );
@@ -108 +118 @@
                 for(i = 0; i < 10; i++) 
                 {
-
                     buf[9 - i] = HexaTab[val % 10];
                     if (!(val /= 10)) break;
@@ -116 +125 @@
                 break;
             }
-            case ('u'):             // decimal unsigned integer
+            case ('u'):             // up to 10 digits decimal unsigned integer
             {
                 uint32_t val = va_arg( args, uint32_t );
@@ -128 +137 @@
                 break;
             }
-            case ('x'):             // 32 bits hexadecimal 
-            case ('l'):             // 64 bits hexadecimal 
+            case ('x'):             // up to 8 digits hexadecimal 
+            case ('l'):             // up to 16 digits hexadecimal 
             {
                 uint32_t imax;
@@ -157 +166 @@
                 break;
             }
-            case ('X'):             // 32 bits hexadecimal on 8 characters
+            case ('X'):             // exactly 8 digits hexadecimal
             {
                 uint32_t val = va_arg( args , uint32_t );
@@ -238 +247 @@
             case ('c'):             /* char conversion */
             {
-                int val = va_arg( *args , int );
+                int  val = va_arg( *args , int );
                 len = 1;
-                buf[0] = val;
+                buf[0] = (char)val;
                 pbuf = &buf[0];
                 break;
             }
-            case ('d'):             /* 32 bits decimal signed  */
+            case ('b'):             // excactly 2 digits hexadecimal
+            {
+                int  val = va_arg( *args, int );
+                int  val_lsb = val & 0xF;
+                int  val_msb = (val >> 4) & 0xF;
+                buf[0] = HexaTab[val_msb];
+                buf[1] = HexaTab[val_lsb];
+                len  = 2;
+                pbuf = buf;
+                break;
+            }
+            case ('d'):             /* up to 10 digits signed decimal */
             {
                 int val = va_arg( *args , int );
@@ -261 +281 @@
                 break;
             }
-            case ('u'):             /* 32 bits decimal unsigned  */
+            case ('u'):             /* up to 10 digits unsigned decimal */
             {
                 uint32_t val = va_arg( *args , uint32_t );
@@ -273 +293 @@
                 break;
             }
-            case ('x'):             /* 32 bits hexadecimal unsigned */
+            case ('x'):             /* up to 8 digits hexadecimal */
             {
                 uint32_t val = va_arg( *args , uint32_t );
@@ -286 +306 @@
                 break;
             }
-            case ('X'):             /* 32 bits hexadecimal unsigned  on 10 char */
+            case ('X'):             /* exactly 8 digits hexadecimal */
             {
                 uint32_t val = va_arg( *args , uint32_t );
@@ -299 +319 @@
                 break;
             }
-            case ('l'):            /* 64 bits hexadecimal unsigned */
-            {
-                unsigned long long val = va_arg( *args , unsigned long long );
+            case ('l'):            /* up to 16 digits hexadecimal */
+            {
+                uint64_t val = va_arg( *args , uint64_t );
                 dev_txt_sync_write( "0x" , 2 );
                 for(i = 0; i < 16; i++) 
@@ -312 +332 @@
                 break;
             }
-            case ('L'):           /* 64 bits hexadecimal unsigned on 18 char */ 
-            {
-                unsigned long long val = va_arg( *args , unsigned long long );
+            case ('L'):           /* exactly 16 digits hexadecimal */ 
+            {
+                uint64_t val = va_arg( *args , uint64_t );
                 dev_txt_sync_write( "0x" , 2 );
                 for(i = 0; i < 16; i++) 
@@ -525 +545 @@
 }
 
+/////////////////////////////
+void putb( char     * string,
+           uint8_t  * buffer,
+           uint32_t   size )
+{
+    uint32_t line;
+    uint32_t byte = 0;
+
+    // get pointers on TXT0 chdev
+    xptr_t    txt0_xp  = chdev_dir.txt_tx[0];
+    cxy_t     txt0_cxy = GET_CXY( txt0_xp );
+    chdev_t * txt0_ptr = GET_PTR( txt0_xp );
+
+    // get extended pointer on remote TXT0 chdev lock
+    xptr_t  lock_xp = XPTR( txt0_cxy , &txt0_ptr->wait_lock );
+
+    // get TXT0 lock 
+    remote_busylock_acquire( lock_xp );
+
+    // display string on TTY0
+    nolock_printk("\n***** %s *****\n", string );
+
+    for ( line = 0 ; line < (size>>4) ; line++ )
+    {
+         nolock_printk(" %X | %b %b %b %b | %b %b %b %b | %b %b %b %b | %b %b %b %b \n",
+         byte,
+         buffer[byte+ 0],buffer[byte+ 1],buffer[byte+ 2],buffer[byte+ 3],
+         buffer[byte+ 4],buffer[byte+ 5],buffer[byte+ 6],buffer[byte+ 7],
+         buffer[byte+ 8],buffer[byte+ 9],buffer[byte+10],buffer[byte+11],
+         buffer[byte+12],buffer[byte+13],buffer[byte+14],buffer[byte+15] );
+
+         byte += 16;
+    }
+
+    // release TXT0 lock
+    remote_busylock_release( lock_xp );
+}
+
+
 
 // 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 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 busylock 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 signalling completion.
-// Both functions use the generic TXT device to call the proper implementation
-// dependant TXT driver.
-// Finally these files define a set of conditional trace <***_dmsg> for debug.
+// to display messages on the kernel terminal TXT0, using a busy waiting policy. 
+// It calls synchronously the TXT0 driver, without descheduling.
 ///////////////////////////////////////////////////////////////////////////////////
 
@@ -44 +34 @@
 #include <stdarg.h>
 
-#include <hal_special.h> // hal_get_cycles()
+#include <hal_special.h> 
 
 /**********************************************************************************
  * This function build a formatted string.
  * The supported formats are defined below :
- *   %c : single character
- *   %d : signed decimal 32 bits integer
- *   %u : unsigned decimal 32 bits integer
- *   %x : hexadecimal 32 bits integer
- *   %l : hexadecimal 64 bits integer
+ *   %b : exactly 2 digits hexadecimal integer (8 bits)
+ *   %c : single ascii character (8 bits)
+ *   %d : up to 10 digits decimal integer (32 bits)
+ *   %u : up to 10 digits unsigned decimal (32 bits) 
+ *   %x : up to 8 digits hexadecimal integer (32 bits) 
+ *   %X : exactly 8 digits hexadecimal integer (32 bits) 
+ *   %l : up to 16 digits hexadecimal integer (64 bits)
+ *   %L : exactly 16 digits hexadecimal integer (64 bits)
  *   %s : NUL terminated character string
  **********************************************************************************
@@ -153 +146 @@
 void putl( uint64_t val );
 
+/**********************************************************************************
+ * This debug function displays on the kernel TXT0 terminal the content of an
+ * array of bytes defined by <buffer> and <size> arguments (16 bytes per line).
+ * The <string> argument is displayed before the buffer content.
+ * The line format is an address folowed by 16 (hexa) bytes.
+ **********************************************************************************
+ * @ string   : buffer name or identifier.
+ * @ buffer   : local pointer on bytes array.
+ * @ size     : number of bytes bytes to display.
+ *********************************************************************************/
+void putb( char     * string,
+           uint8_t  * buffer,
+           uint32_t   size );
+
+
 
 #endif  // _PRINTK_H

trunk/kernel/kern/process.c

@@ -29 +29 @@
 #include <hal_uspace.h>
 #include <hal_irqmask.h>
+#include <hal_vmm.h>
 #include <errno.h>
 #include <printk.h>
@@ -486 +487 @@
     }
 
-    // FIXME decrement the refcount on file pointer by vfs_bin_xp [AG]
+    // FIXME decrement the refcount on file pointer for vfs_bin_xp [AG]
+
     // FIXME close all open files [AG]
+
     // FIXME synchronize dirty files [AG]
 
@@ -1487 +1490 @@
         printk("\n[ERROR] in %s : cannot initialise VMM for %s\n", __FUNCTION__ , path );
         vfs_close( file_xp , file_id );
-        // FIXME restore old process VMM
+        // FIXME restore old process VMM [AG]
         return -1;
     }
@@ -1505 +1508 @@
                 printk("\n[ERROR] in %s : failed to access <%s>\n", __FUNCTION__ , path );
         vfs_close( file_xp , file_id );
-        // FIXME restore old process VMM 
+        // FIXME restore old process VMM [AG]
         return -1;
         }
@@ -1535 +1538 @@
 
 
-///////////////////////////////////////////////
-void process_zero_create( process_t * process )
+////////////////////////////////////////////////
+void process_zero_create( process_t   * process,
+                          boot_info_t * info )
 {
     error_t error;
@@ -1566 +1570 @@
     process->parent_xp  = XPTR( local_cxy , process );
     process->term_state = 0;
+
+    // initialise kernel GPT and VSL, depending on architecture
+    hal_vmm_kernel_init( info );
 
     // reset th_tbl[] array and associated fields

trunk/kernel/kern/process.h

@@ -73 +73 @@
  * is always stored in the same cluster as the inode associated to the file.
  * A free entry in this array contains the XPTR_NULL value.
- * The array size is defined by a the CONFIG_PROCESS_FILE_MAX_NR parameter.
+ * The array size is defined by the CONFIG_PROCESS_FILE_MAX_NR parameter.
  *
  * NOTE: - Only the fd_array[] in the reference process contains a complete list of open
@@ -79 +79 @@
  *       - the fd_array[] in a process copy is simply a cache containing a subset of the
  *         open files to speed the fdid to xptr translation, but the "lock" and "current
- *         fields should not be used.
+ *         fields are not used.
  *       - all modifications made by the process_fd_remove() are done in reference cluster
  *         and reported in all process_copies.
@@ -200 +200 @@
 
 /*********************************************************************************************
- * This function initialize, in each cluster, the kernel "process_zero", that is the owner
- * of all kernel threads in a given cluster. It is called by the kernel_init() function.
+ * This function initialize, in each cluster, the kernel "process_zero", that contains
+ * all kernel threads in a given cluster. It is called by the kernel_init() function.
  * The process_zero descriptor is allocated as a global variable in file kernel_init.c 
  * Both the PID and PPID fields are set to zero, the ref_xp is the local process_zero,
  * and the parent process is set to XPTR_NULL. The th_tbl[] is initialized as empty.
- *********************************************************************************************
- * @ process      : [in] pointer on local process descriptor to initialize.
- ********************************************************************************************/
-void process_zero_create( process_t * process );
+ * The process GPT is initialised as required by the target architecture.
+ * The "kcode" and "kdata" segments are registered in the process VSL.
+ *********************************************************************************************
+ * @ process  : [in] pointer on process descriptor to initialize.
+ * @ info     : pointer on local boot_info_t (for kernel segments base and size). 
+ ********************************************************************************************/
+void process_zero_create( process_t   * process,
+                          boot_info_t * info );
 
 /*********************************************************************************************
@@ -428 +432 @@
  * identified by the <process_xp> argument, register the <file_xp> argument in the
  * allocated slot, and return the slot index in the <fdid> buffer.
- * It can be called by any thread in any cluster, because it uses portable remote access
+ * It can be called by any thread in any cluster, because it uses remote access
  * primitives to access the reference process descriptor.
  * It takes the lock protecting the reference fd_array against concurrent accesses.

trunk/kernel/kern/rpc.c

@@ -2 +2 @@
  * rpc.c - RPC operations implementation.
  * 
- * Author    Alain Greiner (2016,2017,2018)
+ * Author    Alain Greiner (2016,2017,2018,2019)
  *
  * Copyright (c)  UPMC Sorbonne Universites
@@ -58 +58 @@
     &rpc_thread_user_create_server,        // 6
     &rpc_thread_kernel_create_server,      // 7
-    &rpc_undefined,                        // 8    unused slot        
+    &rpc_vfs_fs_update_dentry_server,      // 8
     &rpc_process_sigaction_server,         // 9
 
@@ -67 +67 @@
     &rpc_vfs_file_create_server,           // 14
     &rpc_vfs_file_destroy_server,          // 15
-    &rpc_vfs_fs_get_dentry_server,         // 16
+    &rpc_vfs_fs_new_dentry_server,         // 16
     &rpc_vfs_fs_add_dentry_server,         // 17
     &rpc_vfs_fs_remove_dentry_server,      // 18
@@ -76 +76 @@
     &rpc_kcm_alloc_server,                 // 22
     &rpc_kcm_free_server,                  // 23
-    &rpc_undefined,                        // 24   unused slot
+    &rpc_mapper_sync_server,               // 24
     &rpc_mapper_handle_miss_server,        // 25
     &rpc_vmm_delete_vseg_server,           // 26 
@@ -94 +94 @@
     "THREAD_USER_CREATE",        // 6
     "THREAD_KERNEL_CREATE",      // 7
-    "undefined",                 // 8
+    "VFS_FS_UPDATE_DENTRY",      // 8
     "PROCESS_SIGACTION",         // 9
 
@@ -112 +112 @@
     "KCM_ALLOC",                 // 22
     "KCM_FREE",                  // 23
-    "undefined",                 // 24
+    "MAPPER_SYNC",               // 24
     "MAPPER_HANDLE_MISS",        // 25
     "VMM_DELETE_VSEG",           // 26
@@ -921 +921 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [7]      Marshaling functions attached to RPC_THREAD_KERNEL_CREATE (blocking)
+// [7]      Marshaling functions attached to RPC_THREAD_KERNEL_CREATE 
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -1013 +1013 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [8]   undefined slot
-/////////////////////////////////////////////////////////////////////////////////////////
-
+// [8]   Marshaling functions attached to RPC_VRS_FS_UPDATE_DENTRY
+/////////////////////////////////////////////////////////////////////////////////////////
+
+/////////////////////////////////////////////////////////
+void rpc_vfs_fs_update_dentry_client( cxy_t          cxy,
+                                      vfs_inode_t  * inode,
+                                      vfs_dentry_t * dentry,
+                                      uint32_t       size,
+                                      error_t      * error )
+{
+#if DEBUG_RPC_VFS_FS_UPDATE_DENTRY
+thread_t * this = CURRENT_THREAD;
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VFS_FS_UPDATE_DENTRY )
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+
+    uint32_t responses = 1;
+
+    // initialise RPC descriptor header 
+    rpc_desc_t  rpc;
+    rpc.index    = RPC_VFS_FS_UPDATE_DENTRY;
+    rpc.blocking = true;
+    rpc.rsp      = &responses;
+
+    // set input arguments in RPC descriptor 
+    rpc.args[0] = (uint64_t)(intptr_t)inode;
+    rpc.args[1] = (uint64_t)(intptr_t)dentry;
+    rpc.args[2] = (uint64_t)size;
+
+    // register RPC request in remote RPC fifo
+    rpc_send( cxy , &rpc );
+
+    // get output values from RPC descriptor
+    *error   = (error_t)rpc.args[3];
+
+#if DEBUG_RPC_VFS_FS_UPDATE_DENTRY
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VFS_FS_UPDATE_DENTRY )
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+}
+
+/////////////////////////////////////////////////
+void rpc_vfs_fs_update_dentry_server( xptr_t xp )
+{
+#if DEBUG_RPC_VFS_FS_UPDATE_DENTRY
+thread_t * this = CURRENT_THREAD;
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VFS_FS_UPDATE_DENTRY )
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+
+    error_t        error;
+    vfs_inode_t  * inode;
+    vfs_dentry_t * dentry;
+    uint32_t       size;
+
+    // get client cluster identifier and pointer on RPC descriptor
+    cxy_t        client_cxy  = GET_CXY( xp );
+    rpc_desc_t * desc        = GET_PTR( xp );
+
+    // get input arguments
+    inode  = (vfs_inode_t*)(intptr_t) hal_remote_l64(XPTR(client_cxy , &desc->args[0]));
+    dentry = (vfs_dentry_t*)(intptr_t)hal_remote_l64(XPTR(client_cxy , &desc->args[1]));
+    size   = (uint32_t)               hal_remote_l64(XPTR(client_cxy , &desc->args[2]));
+
+    // call the kernel function
+    error = vfs_fs_update_dentry( inode , dentry , size );
+
+    // set output argument
+    hal_remote_s64( XPTR( client_cxy , &desc->args[3] ) , (uint64_t)error );
+
+#if DEBUG_RPC_VFS_FS_UPDATE_DENTRY
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VFS_FS_UPDATE_DENTRY )
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+}
 
 /////////////////////////////////////////////////////////////////////////////////////////
@@ -1110 +1190 @@
 void rpc_vfs_inode_create_client( cxy_t          cxy,     
                                   uint32_t       fs_type,    // in
-                                  uint32_t       inode_type, // in
                                   uint32_t       attr,       // in
                                   uint32_t       rights,     // in
@@ -1136 +1215 @@
     // set input arguments in RPC descriptor 
     rpc.args[0] = (uint64_t)fs_type;
-    rpc.args[1] = (uint64_t)inode_type;
-    rpc.args[2] = (uint64_t)attr;
-    rpc.args[3] = (uint64_t)rights;
-    rpc.args[4] = (uint64_t)uid;
-    rpc.args[5] = (uint64_t)gid;
+    rpc.args[1] = (uint64_t)attr;
+    rpc.args[2] = (uint64_t)rights;
+    rpc.args[3] = (uint64_t)uid;
+    rpc.args[4] = (uint64_t)gid;
 
     // register RPC request in remote RPC fifo
@@ -1146 +1224 @@
 
     // get output values from RPC descriptor
-    *inode_xp = (xptr_t)rpc.args[6];
-    *error    = (error_t)rpc.args[7];
+    *inode_xp = (xptr_t)rpc.args[5];
+    *error    = (error_t)rpc.args[6];
 
 #if DEBUG_RPC_VFS_INODE_CREATE
@@ -1169 +1247 @@
 
     uint32_t         fs_type;
-    uint32_t         inode_type;
     uint32_t         attr;
     uint32_t         rights;
@@ -1183 +1260 @@
     // get input arguments from client rpc descriptor
     fs_type    = (uint32_t)  hal_remote_l64( XPTR( client_cxy , &desc->args[0] ) );
-    inode_type = (uint32_t)  hal_remote_l64( XPTR( client_cxy , &desc->args[1] ) );
-    attr       = (uint32_t)  hal_remote_l64( XPTR( client_cxy , &desc->args[2] ) );
-    rights     = (uint32_t)  hal_remote_l64( XPTR( client_cxy , &desc->args[3] ) );
-    uid        = (uid_t)     hal_remote_l64( XPTR( client_cxy , &desc->args[4] ) );
-    gid        = (gid_t)     hal_remote_l64( XPTR( client_cxy , &desc->args[5] ) );
+    attr       = (uint32_t)  hal_remote_l64( XPTR( client_cxy , &desc->args[1] ) );
+    rights     = (uint32_t)  hal_remote_l64( XPTR( client_cxy , &desc->args[2] ) );
+    uid        = (uid_t)     hal_remote_l64( XPTR( client_cxy , &desc->args[3] ) );
+    gid        = (gid_t)     hal_remote_l64( XPTR( client_cxy , &desc->args[4] ) );
 
     // call local kernel function
     error = vfs_inode_create( fs_type,
-                              inode_type,
                               attr,
                               rights,
@@ -1199 +1274 @@
 
     // set output arguments
-    hal_remote_s64( XPTR( client_cxy , &desc->args[6] ) , (uint64_t)inode_xp );
-    hal_remote_s64( XPTR( client_cxy , &desc->args[7] ) , (uint64_t)error );
+    hal_remote_s64( XPTR( client_cxy , &desc->args[5] ) , (uint64_t)inode_xp );
+    hal_remote_s64( XPTR( client_cxy , &desc->args[6] ) , (uint64_t)error );
 
 #if DEBUG_RPC_VFS_INODE_CREATE
@@ -1601 +1676 @@
 
 /////////////////////////////////////////////////////////
-void rpc_vfs_fs_get_dentry_client( cxy_t         cxy,
+void rpc_vfs_fs_new_dentry_client( cxy_t         cxy,
                                    vfs_inode_t * parent_inode,    // in
                                    char        * name,            // in
@@ -1643 +1718 @@
 
 //////////////////////////////////////////////
-void rpc_vfs_fs_get_dentry_server( xptr_t xp )
+void rpc_vfs_fs_new_dentry_server( xptr_t xp )
 {
 #if DEBUG_RPC_VFS_FS_GET_DENTRY
@@ -1674 +1749 @@
 
     // call the kernel function
-    error = vfs_fs_get_dentry( parent , name_copy , child_xp );
+    error = vfs_fs_new_dentry( parent , name_copy , child_xp );
 
     // set output argument
@@ -2245 +2320 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [24]          undefined slot 
-/////////////////////////////////////////////////////////////////////////////////////////
+// [25]          Marshaling functions attached to RPC_MAPPER_SYNC 
+/////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////
+void rpc_mapper_sync_client( cxy_t             cxy,
+                             struct mapper_s * mapper,
+                             error_t         * error )
+{
+#if DEBUG_RPC_MAPPER_SYNC
+thread_t * this = CURRENT_THREAD;
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_MAPPER_SYNC )
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+
+    uint32_t responses = 1;
+
+    // initialise RPC descriptor header 
+    rpc_desc_t  rpc;
+    rpc.index    = RPC_MAPPER_SYNC;
+    rpc.blocking = true;
+    rpc.rsp      = &responses;
+
+    // set input arguments in RPC descriptor 
+    rpc.args[0] = (uint64_t)(intptr_t)mapper;
+
+    // register RPC request in remote RPC fifo
+    rpc_send( cxy , &rpc );
+
+    // get output values from RPC descriptor
+    *error   = (error_t)rpc.args[1];
+
+#if DEBUG_RPC_MAPPER_SYNC
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_MAPPER_SYNC )
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+}
+
+////////////////////////////////////////
+void rpc_mapper_sync_server( xptr_t xp )
+{
+#if DEBUG_RPC_MAPPER_SYNC
+thread_t * this = CURRENT_THREAD;
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_MAPPER_SYNC )
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+
+    mapper_t * mapper;
+    error_t    error;
+
+    // get client cluster identifier and pointer on RPC descriptor
+    cxy_t        client_cxy  = GET_CXY( xp );
+    rpc_desc_t * desc        = GET_PTR( xp );
+
+    // get arguments from client RPC descriptor
+    mapper  = (mapper_t *)(intptr_t)hal_remote_l64( XPTR( client_cxy , &desc->args[0] ) );
+
+    // call local kernel function
+    error = mapper_sync( mapper );
+
+    // set output argument to client RPC descriptor
+    hal_remote_s64( XPTR( client_cxy , &desc->args[1] ) , (uint64_t)error );
+
+#if DEBUG_RPC_MAPPER_SYNC
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_MAPPER_SYNC )
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+}
 
 /////////////////////////////////////////////////////////////////////////////////////////

trunk/kernel/kern/rpc.h

@@ -68 +68 @@
     RPC_THREAD_USER_CREATE        = 6,
     RPC_THREAD_KERNEL_CREATE      = 7,
-    RPC_UNDEFINED_8               = 8,
+    RPC_VFS_FS_UPDATE_DENTRY      = 8,
     RPC_PROCESS_SIGACTION         = 9,
 
@@ -86 +86 @@
     RPC_KCM_ALLOC                 = 22,
     RPC_KCM_FREE                  = 23,
-    RPC_UNDEFINED_24              = 24,
+    RPC_MAPPER_SYNC               = 24,
     RPC_MAPPER_HANDLE_MISS        = 25,
     RPC_VMM_DELETE_VSEG           = 26,
@@ -305 +305 @@
 
 /***********************************************************************************
- * [8] undefined slot
- **********************************************************************************/
-
-/***********************************************************************************
- * [9] The RPC_PROCESS_SIGACTION allows any client thread to request to any cluster
- * execute a given sigaction, defined by the <action_type> for a given process,
+ * [8] The RPC_VFS_FS_UPDATE_DENTRY allows a client thread to request a remote
+ * cluster to update the <size> field of a directory entry in the mapper of a
+ * remote directory inode, identified by the <inode> local pointer.
+ * The target entry name is identified by the <dentry> local pointer. 
+ ***********************************************************************************
+ * @ cxy     : server cluster identifier.
+ * @ inode   : [in] local pointer on remote directory inode.
+ * @ dentry  : [in] local pointer on remote dentry.
+ * @ size    : [in] new size value.
+ * @ error   : [out] error status (0 if success).
+ **********************************************************************************/
+void rpc_vfs_fs_update_dentry_client( cxy_t                 cxy,
+                                      struct vfs_inode_s  * inode,
+                                      struct vfs_dentry_s * dentry,
+                                      uint32_t              size,
+                                      error_t             * error );
+
+void rpc_vfs_fs_update_dentry_server( xptr_t xp );
+
+/***********************************************************************************
+ * [9] The RPC_PROCESS_SIGACTION allows a client thread to request a remote cluster
+ * to execute a given sigaction, defined by the <action_type> for a given process,
  * identified by the <pid> argument.
  ***********************************************************************************
@@ -340 +356 @@
 void rpc_vfs_inode_create_client( cxy_t      cxy,
                                   uint32_t   fs_type,
-                                  uint32_t   inode_type,
                                   uint32_t   attr,    
                                   uint32_t   rights,  
@@ -423 +438 @@
 
 /*********************************************************************************** 
- * [16] The RPC_VFS_FS_GET_DENTRY calls the vfs_fs_get_dentry()
+ * [16] The RPC_VFS_FS_GET_DENTRY calls the vfs_fs_new_dentry()
  * function in a remote cluster containing a parent inode directory to scan the 
  * associated mapper, find a directory entry identified by its name, and update
@@ -434 +449 @@
  * @ error          : [out] error status (0 if success).
  **********************************************************************************/
-void rpc_vfs_fs_get_dentry_client( cxy_t                cxy,
+void rpc_vfs_fs_new_dentry_client( cxy_t                cxy,
                                    struct vfs_inode_s * parent_inode,
                                    char               * name,
@@ -440 +455 @@
                                    error_t            * error );
 
-void rpc_vfs_fs_get_dentry_server( xptr_t xp );
+void rpc_vfs_fs_new_dentry_server( xptr_t xp );
 
 /*********************************************************************************** 
@@ -564 +579 @@
 
 /***********************************************************************************
- * [24] undefined slot
- **********************************************************************************/
+ * [24] The RPC_MAPPER_SYNC allows a client thread to synchronize on disk
+ * all dirty pages of a remote mapper.
+ ***********************************************************************************
+ * @ cxy       : server cluster identifier.
+ * @ mapper    : [in] local pointer on mapper in server cluster.
+ * @ error       : [out] error status (0 if success).
+ **********************************************************************************/
+void rpc_mapper_sync_client( cxy_t             cxy,
+                             struct mapper_s * mapper,
+                             error_t         * error );
+
+void rpc_mapper_sync_server( xptr_t xp );
 
 /***********************************************************************************

trunk/kernel/kern/thread.c

@@ -1382 +1382 @@
                                const char * string )
 {
+
     cxy_t      thread_cxy = GET_CXY( thread_xp );
     thread_t * thread_ptr = GET_PTR( thread_xp );
 
-#if( DEBUG_BUSYLOCK )
-
-    xptr_t    iter_xp;
-
-    // get relevant info from target trhead descriptor
+#if DEBUG_BUSYLOCK
+
+    xptr_t     iter_xp;
+
+    // get relevant info from target thread descriptor
     uint32_t    locks   = hal_remote_l32( XPTR( thread_cxy , &thread_ptr->busylocks ) );
     trdid_t     trdid   = hal_remote_l32( XPTR( thread_cxy , &thread_ptr->trdid ) );
@@ -1429 +1430 @@
     remote_busylock_release( txt0_lock_xp );
 
+#else
+
+printk("\n[ERROR] in %s : set DEBUG_BUSYLOCK in kernel_config.h for %s / thread(%x,%x)\n",
+__FUNCTION__, string, thread_cxy, thread_ptr );
+
+#endif
+
     return;
 
-#endif
-
-    // display a warning
-    printk("\n[WARNING] set DEBUG_BUSYLOCK in kernel_config.h to display busylocks" );
-
 }  // end thread_display_busylock()