Changeset 623 for trunk

trunk/Makefile

-                      r610
+                      r623
 -include params-soft.mk
 ifeq ($(ARCH_NAME),)
 $(error Please define in ARCH_NAME parameter in params-soft.mk!)
+$(error Please define ARCH_NAME parameter in params-soft.mk!)
 endif
 …
 MTOOLS_SKIP_CHECK := 1
+# Rule to generate boot.elf, kernel.elf, all user.elf files, and update virtual disk.
+##########################################################################################
+# Rule to generate boot.elf, kernel.elf, all user.elf files, and update the virtual disk
+# when the corresponding sources files have been modified or destroyed.
+# The /home directory on the virtual disk is not modified
 compile: dirs                              \
-         build_disk                        \
          hard_config.h                     \
          build_libs                        \
 …
          user/idbg/build/idbg.elf          \
          user/sort/build/sort.elf          \
          user/fft/build/fft.elf           \
+         user/fft/build/fft.elf            \
          list
 …
         mcopy -o -i $(DISK_IMAGE) ::/home .
+##############################################################
 # Rules to delete all binary files from Unix File System
 # without modifying the virtual disk.
 …
         mmd                     -o -i $(DISK_IMAGE) ::/bin/user    || true
         mmd                     -o -i $(DISK_IMAGE) ::/home        || true
-        mcopy           -o -i $(DISK_IMAGE) Makefile ::/home
         mdir             -/ -b -i $(DISK_IMAGE) ::/
 …
 # Rules to generate hardware description files (hard_config.h,
 # arch_info.bin and arch_info.xml), and update the virtual disk.
 hard_config.h: build_disk $(ARCH)/arch_info.py
+hard_config.h: $(ARCH)/arch_info.py
         tools/arch_info/genarch.py      --arch=$(ARCH)                  \
                                                                 --x_size=$(X_SIZE)              \

trunk/boot/tsar_mips32/boot.c

-                      r578
+                      r623
+ *
  * Authors :   Vu Son  (2016)
  *             Alain Greiner (2016, 2017,2018)
+ *             Alain Greiner (2016,2017,2018,2019)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
  * This file contains the ALMOS-MKH. boot-loader for the TSAR architecture. *
  *                                                                          *
  * It supports clusterised shared memory multi-processor architectures,     *
+ * It supports a clusterised, shared memory, multi-processor architecture,  *
  * where each processor core is identified by a composite index [cxy,lid]   *
  * with one physical memory bank per cluster.                               *
  *                                                                          *
  * The 'boot.elf' file (containing the boot-loader binary code) is stored   *
  * on disk and is loaded into memory by core[0,0] (cxy = 0 / lid = 0),      *
  * and is copied in each other cluter by the local CP0 (lid = 0].           *
+ * on disk (not in the FAT file system), and must be loaded into memory by  *
+ * the preloader running on the core[0][0] (cxy = 0 / lid = 0).             *
  *                                                                          *
+ * 1) The boot-loader first phase is executed by core[0,0], while           *
+ *    all other cores are waiting in the preloader.                         *
+ *    It does the following tasks:                                          *
+ *      - load into the memory bank of cluster 0 the 'arch_info.bin'        *
+ *        file (containing the hardware architecture description) and the   *
+ *        'kernel.elf' file, at temporary locations,                        *
+ *      - initializes the 'boot_info_t' structure in cluster(0,0)           *
+ *        (there is 1 'boot_info_t' per cluster), which contains both       *
+ *        global and cluster specific information that will be used for     *
+ *        kernel initialisation.                                            *
+ *      - activate CP0s in all other clusters, using IPIs.                  *
+ *      - wait completion reports from CP0s on a global barrier.            *
+ * The main task of the boot-loader is to load in the first physical page   *
+ * of each cluster a copy of the kernel code (segments "kcode" and "kdata") *
+ * and to build - in each cluster - a cluster specific description of the   *
+ * hardware archtecture, stored in the "kdata" segment as the boot_info_t   *
+ * structure. The "kernel.elf" and "arch_info.bin" files are supposed to be *
+ * stored on disk in a FAT32 file system.                                   *
  *                                                                          *
+ * 2) The boot-loader second phase is then executed in parallel by all      *
+ *    CP0s (other than core[0,0]). Each CP0 performs the following tasks:   *
+ *      - copies into the memory bank of the local cluster the 'boot.elf',  *
+ *        the 'arch_info.bin' (at the same addresses as the 'boot.elf' and  *
+ *        the 'arch_info.bin' in the memory bank of the cluster(0,0), and   *
+ *        the kernel image (at address 0x0),                                *
+ *      - initializes the 'boot_info_t' structure of the local cluster,     *
+ *      - activate all other cores in the same cluster (CPi).               *
+ *      - wait local CPi completion reports on a local barrier.             *
+ *      - report completion  on the global barrier.                         *
+ * All cores contribute to the boot procedure, but all cores are not        *
+ * simultaneously active:                                                   *
+ * - in a first phase, only core[0][0] is running (core 0 in cluster 0).    *
+ * - in a second phase, only core[cxy][0] is running in each cluster.       *
+ * - in last phase, all core[cxy][lid] are running.                         *
  *                                                                          *
+ * 3) The boot-loader third phase is executed in parallel by all cores.     *
+ *    In each cluster (i) the CP0                                           *
+ *      - activates the other cores of cluster(i),                          *
+ *      - blocks on the local barrier waiting for all local CPi to report   *
+ *        completion on the local barrier,                                  *
+ *      - moves the local kernel image from the temporary location to the   *
+ *        address 0x0, (erasing the preloader code).                        *
+ * Finally, all cores jump to the kernel_init() function that makes the     *
+ * actual kernel initialisation.                                            *
  *                                                                          *
+ * 4) All cores jump to kern_init() (maybe not at the same time).           *
+ * Implementation note:                                                     *                      *                                                                          *
+ * To allows each core to use the local copy of both the boot code and the  *
+ * kernel code, the boot-loader builds a minimal and temporary BPT (Boot    *
+ * Page Table) containing only two big pages: page[0] maps the kernel code, *
+ * and page 1 maps the boot code.                                           *
  ****************************************************************************/
 …
  ****************************************************************************/
+// the Boot Page Table contains two PTE1, and should be aligned on 8 Kbytes
+uint32_t                        boot_pt[2] __attribute__((aligned(2048)));
 // synchronization variables.
 volatile boot_remote_spinlock_t tty0_lock;       // protect TTY0 access
 volatile boot_remote_barrier_t  global_barrier;  // synchronize CP0 cores
 volatile boot_remote_barrier_t  local_barrier;   // synchronize cores in one cluster
 uint32_t                        active_cp0s_nr;  // number of expected CP0s
+volatile boot_remote_spinlock_t tty0_lock;        // protect TTY0 access
+volatile boot_remote_barrier_t  global_barrier;   // synchronize CP0 cores
+volatile boot_remote_barrier_t  local_barrier;    // synchronize cores in one cluster
+uint32_t                        active_cores_nr;  // number of expected CP0s
 // kernel segments layout variables
 …
 uint32_t                        kernel_entry;    // kernel entry point
 // Functions called by boot_entry.S
+// Functions
 extern void boot_entry( void );    // boot_loader entry point
 …
 /*********************************************************************************
  * This function is called by all CP0 to activate the other CPi cores.
+ * This function is called by all CP0s to activate the other CPi cores.
  * @ boot_info  : pointer to local 'boot_info_t' structure.
  *********************************************************************************/
 …
 } // boot_wake_local_cores()
+/*********************************************************************************
+ * This function is called by all core[cxy][0] to initialize the Boot Page Table:
+ * map two local big pages for the boot code and kernel code.
+ * @ cxy    : local cluster identifier.
+ *********************************************************************************/
+void boot_page_table_init( cxy_t  cxy )
+{
+    // set PTE1 in slot[0] for kernel code
+    uint32_t kernel_attr  = 0x8A800000;                   // flagss : V,C,X,G
+    uint32_t kernel_ppn1  = (cxy << 20) >> 9;             // big physical page index == 0
+    boot_pt[0]            = kernel_attr | kernel_ppn1;
+    // set PTE1 in slot[1] for boot code (no global flag)
+    uint32_t boot_attr    = 0x8A000000;                   // flags : V,C,X
+    uint32_t boot_ppn1    = ((cxy << 20) + 512) >> 9;     // big physical page index == 1
+    boot_pt[1]            = boot_attr | boot_ppn1;
+}
+/*********************************************************************************
+ * This function is called by all cores to activate the instruction MMU,
+ * and use the local copy of boot code.
+ *********************************************************************************/
+void boot_activate_ins_mmu( cxy_t cxy )
+{
+    // set mmu_ptpr register
+    uint32_t ptpr = ((uint32_t)boot_pt >> 13) | (cxy << 19);
+    asm volatile ( "mtc2   %0,   $0         \n" : : "r" (ptpr) );
+    // set ITLB bit in mmu_mode
+    asm volatile ( "mfc2   $26,  $1         \n"
+                   "ori    $26,  $26,  0x8  \n"
+                   "mtc2   $26,  $1         \n" );
+}
 /*********************************************************************************
 …
     if (lid == 0)
+    {
         /****************************************************
          * PHASE A : only CP0 in boot cluster executes it
          ***************************************************/
         if (cxy == BOOT_CORE_CXY)
+        /************************************i**********************
+         * PHASE Sequencial : only core[0][0] executes it
+         **********************************************************/
+        if (cxy == 0)
+        {
             boot_printf("\n[BOOT] core[%x,%d] enters at cycle %d\n",
 …
             boot_check_core(boot_info, lid);
+            // Activate other CP0s / get number of active CP0s
+            active_cp0s_nr = boot_wake_all_cp0s() + 1;
+// TO BE DONE
+// core[0][0] identity maps two big pages for the boot and kernel code,
+// boot_page_table_init( 0 );
+// TO BE DONE
+// core[0][0] activates the instruction MMU to use the local copy of boot code
+// boot_activate_ins_mmu( 0 );
+            // Activate other core[cxy][0] / get number of activated cores
+            active_cores_nr = boot_wake_all_cp0s() + 1;
             // Wait until all clusters (i.e all CP0s) ready to enter kernel.
             boot_remote_barrier( XPTR( BOOT_CORE_CXY , &global_barrier ) ,
                                  active_cp0s_nr );
+                                 active_cores_nr );
             // activate other local cores
             boot_wake_local_cores( boot_info );
-// display address extensions
-// uint32_t cp2_data_ext;
-// uint32_t cp2_ins_ext;
-// asm volatile( "mfc2   %0,  $24" : "=&r" (cp2_data_ext) );
-// asm volatile( "mfc2   %0,  $25" : "=&r" (cp2_ins_ext) );
-// boot_printf("\n[BOOT] core[%x,%d] CP2_DATA_EXT = %x / CP2_INS_EXT = %x\n",
-// cxy , lid , cp2_data_ext , cp2_ins_ext );
             // Wait until all local cores in cluster ready
 …
                                  boot_info->cores_nr );
+        }
         /******************************************************************
          * PHASE B : all CP0s other than CP0 in boot cluster execute it
          *****************************************************************/
+        /**************************************************************************
+         * PHASE partially parallel : all core[cxy][0] with (cxy != 0) execute it
+         **************************************************************************/
         else
+        {
+            // at this point, all INSTRUCTION address extension registers
+            // point on cluster(0,0), but the DATA extension registers point
+            // already on the local cluster to use the local stack.
+            // To access the bootloader global variables we must first copy
+            // the boot code (data and instructions) in the local cluster.
+            // at this point, the DATA extension registers point
+            // already on the local cluster cxy to use the local stack,
+            // but all cores must access the code stored in cluster 0
+            // Each CP0 copies the boot code (data and instructions)
+            // from the cluster 0 to the local cluster.
             boot_remote_memcpy( XPTR( cxy           , BOOT_BASE ),
                                 XPTR( BOOT_CORE_CXY , BOOT_BASE ),
                                 BOOT_MAX_SIZE );
             // from now, it is safe to refer to the boot code global variables
+            // from now, it is safe to refer to the boot global variables
             boot_printf("\n[BOOT] core[%x,%d] replicated boot code at cycle %d\n",
             cxy , lid , boot_get_proctime() );
+                        // switch to the INSTRUCTION local memory space, to avoid contention.
+            // asm volatile("mtc2  %0, $25" :: "r"(cxy));
+            // Copy the arch_info.bin file into the local memory.
+// TO BE DONE
+// Each core identity maps two big pages for the boot and kernel code,
+// boot_page_table_init( cxy );
+// Each core activates the instruction MMU to use the local copy of boot code
+// boot_activate_ins_mmu( cxy );
+            // Each CP0 copies the arch_info.bin into the local memory.
             boot_remote_memcpy(XPTR(cxy,           ARCHINFO_BASE),
                                XPTR(BOOT_CORE_CXY, ARCHINFO_BASE),
 …
             cxy , lid , boot_get_proctime() );
             // Copy the kcode segment into local memory
+            // Each CP0 copies the kcode segment into local memory
             boot_remote_memcpy( XPTR( cxy           , seg_kcode_base ),
                                 XPTR( BOOT_CORE_CXY , seg_kcode_base ),
                                 seg_kcode_size );
             // Copy the kdata segment into local memory
+            // Each CP0 copies the kdata segment into local memory
             boot_remote_memcpy( XPTR( cxy           , seg_kdata_base ),
                                 XPTR( BOOT_CORE_CXY , seg_kdata_base ),
                                 seg_kdata_size );
+            // Copy the kentry segment into local memory
+            // [TO BE REMOVED<D-°>
+            // Each CP0 copies the kentry segment into local memory
             boot_remote_memcpy( XPTR( cxy           , seg_kentry_base ),
                                 XPTR( BOOT_CORE_CXY , seg_kentry_base ),
 …
             cxy , lid , boot_get_proctime() );
             // Get local boot_info_t structure base address.
+            // Each CP0 get local boot_info_t structure base address.
             boot_info = (boot_info_t*)seg_kdata_base;
             // Initialize local boot_info_t structure.
+            // Each CP0 initializes local boot_info_t structure.
             boot_info_init( boot_info , cxy );
 …
             cxy , lid , boot_get_proctime() );
             // Check core information.
+            // Each CP0 checks core information.
             boot_check_core( boot_info , lid );
             // get number of active clusters from BOOT_CORE cluster
             uint32_t count = boot_remote_lw( XPTR( BOOT_CORE_CXY , &active_cp0s_nr ) );
             // Wait until all clusters (i.e all CP0s) ready to enter kernel
+            // Each CP0 get number of active clusters from BOOT_CORE cluster
+            uint32_t count = boot_remote_lw( XPTR( 0 , &active_cores_nr ) );
+            // Wait until all clusters (i.e all CP0s) ready
             boot_remote_barrier( XPTR( BOOT_CORE_CXY , &global_barrier ) , count );
             // activate other local cores
             boot_wake_local_cores( boot_info );
-// display address extensions
-// uint32_t cp2_data_ext;
-// uint32_t cp2_ins_ext;
-// asm volatile( "mfc2   %0,  $24" : "=&r" (cp2_data_ext) );
-// asm volatile( "mfc2   %0,  $25" : "=&r" (cp2_ins_ext) );
-// boot_printf("\n[BOOT] core[%x,%d] CP2_DATA_EXT = %x / CP2_INS_EXT = %x\n",
-// cxy , lid , cp2_data_ext , cp2_ins_ext );
             // Wait until all local cores in cluster ready
 …
     else
+    {
         /***************************************************************
          * PHASE C: all non CP0 cores in all clusters execute it
          **************************************************************/
+        // Switch to the INSTRUCTIONS local memory space
+        // to avoid contention at the boot cluster.
         asm volatile("mtc2  %0, $25" :: "r"(cxy));
+        /***********************************************************************
+         * PHASE fully parallel : all cores[cxy][lid] with (lid! = 0) execute it
+         **********************************************************************/
+// TO BE DONE
+// each core activate the instruction MMU to use the local copy of the boot code
+// boot_activate_ins_mmu( cxy );
         // Get local boot_info_t structure base address.
 …
         boot_check_core(boot_info, lid);
-// display address extensions
-// uint32_t cp2_data_ext;
-// uint32_t cp2_ins_ext;
-// asm volatile( "mfc2   %0,  $24" : "=&r" (cp2_data_ext) );
-// asm volatile( "mfc2   %0,  $25" : "=&r" (cp2_ins_ext) );
-// boot_printf("\n[BOOT] core[%x,%d] CP2_DATA_EXT = %x / CP2_INS_EXT = %x\n",
-// cxy , lid , cp2_data_ext , cp2_ins_ext );
         // Wait until all local cores in cluster ready
         boot_remote_barrier( XPTR( cxy , &local_barrier ) , boot_info->cores_nr );
+    }
+    // the "kernel_entry" global variable, set by boot_kernel_load() define
+    // the adress of the kernel_init() function.
     // Each core initialise the following registers before jumping to kernel:
+    // - sp_29    : stack pointer on idle thread,
+    // - c0_sr    : reset BEV bit
+    // - a0_04    : pointer on boot_info structure
+    // - c0_ebase : kentry_base(and jump to kernel_entry.
+    // - gr_29    : stack pointer / kernel stack allocated in idle thread descriptor,
+    // - c0_sr    : status register / reset BEV bit
+    // - gr_04    : kernel_init() argument / pointer on boot_info structure
+    // - c0_ebase : kentry_base
+    // compute "sp" from base address of idle thread descriptors array and lid.
     // The array of idle-thread descriptors is allocated in the kdata segment,
+    // just after the boot_info structure
+    uint32_t sp;
+    // just after the boot_info structure.
     uint32_t base;
     uint32_t offset = sizeof( boot_info_t );
     uint32_t pmask  = CONFIG_PPM_PAGE_MASK;
     uint32_t psize  = CONFIG_PPM_PAGE_SIZE;
-    // compute base address of idle thread descriptors array
     if( offset & pmask ) base = seg_kdata_base + (offset & ~pmask) + psize;
     else                 base = seg_kdata_base + offset;
+    // compute stack pointer
+    sp = base + ((lid + 1) * CONFIG_THREAD_DESC_SIZE) - 16;
+    uint32_t sp = base + ((lid + 1) * CONFIG_THREAD_DESC_SIZE) - 16;
+    // get "ebase" from kerneL_info
+    uint32_t ebase = boot_info->kentry_base;
+// TO BE DONE
+// The cp0_ebase will not be set by the assenbly code below
+// when the kentry segment will be removed => done in kernel init
     asm volatile( "mfc0  $27,  $12           \n"
 …
                   : "r"(boot_info) ,
                     "r"(sp) ,
                     "r"(boot_info->kentry_base) ,
+                    "r"(ebase) ,
                     "r"(kernel_entry)
                   : "$26" , "$27" , "$29" , "$4" );

trunk/boot/tsar_mips32/boot_entry.S

-                      r439
+                      r623
 /**********************************************************************************************
  * This file contains the entry point of the ALMOS-MK boot-loader for TSAR architecture.      *
  * It supports a generic multi-clusters / multi-processors architecture                       *
+ * This file contains the entry point of the ALMOS-MK boot-loader for TSAR architecture,      *
+ * that is a generic multi-clusters / multi-processors architecture.                          *
  *                                                                                            *
  * - The number of clusters is defined by the (X_SIZE, Y_SIZE) parameters in the              *
 …
  *   hard_config.h file (up to 4 processors per cluster).                                     *
  *                                                                                            *
+ * This assembly code is executed by all cores. It has 2 versions (in order to see if the     *
+ * contention created by the ARCHINFO core descriptor table scanning loops is acceptable):    *
+ * with or without the assumption that the core hardware identifier gid has a fixed format:   *
+ * This assembly code is executed by all cores, but at the same time, because all cores       *
+ * are not simultaneously activated. It makes the assuption that the CPO register containing  *
+ * the core gid (global hardware identifier) has a fixed format:                              *
+ *    gid == (((x << Y_WIDTH) + y) << P_WIDTH) + lid                                          *
  *                                                                                            *
+ * - Version with fixed format: gid == (((x << Y_WIDTH) + y) << PADDR_WIDTH) + lid            *
+ *   It does 3 things:                                                                        *
+ *      + It initializes the stack pointer depending on the lid extracted from the gid,       *
+ *        using the BOOT_STACK_BASE and BOOT_STACK_SIZE parameters defined in the             *
+ *        'boot_config.h' file,                                                               *
+ *      + It changes the value of the address extension registers using the cxy extracted     *
+ *        from the gid,                                                                       *
+ *      + It jumps to the boot_loader() function defined in the 'boot.c' file and passes 2    *
+ *        arguments which are the cxy and lid of each core to this function.                  *
+ *                                                                                            *
+ * - Version without fixed format                                                             *
+ *   It has to perform an additional step in order to extract the (cxy,lid) values from the   *
+ *   arch_info.bin structure that has been loaded in the cluster (0,0) memory by the bscpu.   *
+ *      + Each core other than the bscpu scans the core descriptor table in the arch_info.bin *
+ *        structure to make an associative search on the (gid), and get the (cxy,lid).        *
+ *      + It initializes the stack pointer depending on the lid, using the BOOT_STACK_BASE    *
+ *        and BOOT_STACK_SIZE parameters defined in the 'boot_config.h' file,                 *
+ *      + It changes the value of the address extension registers using cxy obtained          *
+ *        previously,                                                                         *
+ *      + It jumps to the boot_loader() function defined in the 'boot.c' file and passes 2    *
+ *        arguments which are the cxy and lid of each core to this function.                  *
+ * It does 3 things:                                                                          *
+ * - It initializes the stack pointer depending on the lid extracted from the gid,            *
+ *   using the BOOT_STACK_BASE and BOOT_STACK_SIZE parameters defined in the                  *
+ *   'boot_config.h' file,                                                                    *
+ * - It changes the value of the DATA address extension register using the cxy extracted      *
+ *   from the gid,                                                                            *
+ * - It jumps to the boot_loader() function defined in the 'boot.c' file, passing the two     *
+ *   arguments (cxy and lid).                                                                 *
  *********************************************************************************************/
 …
 boot_entry:
+#if USE_FIXED_FORMAT
+/*************
+ * VERSION 1 *
+ *************/
+    /*
+     * Get (cxy, lid) values from gid contained in coprocessor0 register.
+     */
+    /* Get (cxy, lid) values from gid contained in CP0 register  */
     mfc0    k0,     CP0_PROCID
 …
     srl     t2,     k0,     P_WIDTH                     /* t2 <= cxy                        */
     /* Initialize stack pointer from previously retrieved lid value  */
+    /* Initialize stack pointer from lid value  */
     la      t0,     BOOT_STACK_BASE                     /* t0 <= BOOT_STACK_BASE            */
 …
     multu   k1,     t1
     mflo    k0                                          /* k0 <= BOOT_STACK_SIZE * lid      */
     subu    sp,     t0,     k0                          /* P[cxy,lid] stack top initialized */
+    subu    sp,     t0,     k0                          /* P[cxy,lid] sp initialized        */
     /* Switch to local DSPACE by changing the value of the address extension registers  */
+    /* Switch to local DSPACE by changing the value of the address extension register       */
     mtc2    t2,     CP2_DATA_PADDR_EXT
     /* Jump to boot_loader() function after passing 2 arguments in the registers  */
+    /* Jump to boot_loader() function after passing (cxy,lid) arguments in the registers    */
     or      a0,     zero,   t1                          /* a0 <= lid                        */
 …
     nop
-#else
-/*************
- * VERSION 2 *
- *************/
-    /* Test if this is bscpu  */
-    mfc0    k0,     CP0_PROCID
-    andi    k0,     k0,     0xFFF                       /* k0 <= gid                        */
-    li      t1,     BOOT_CORE_GID                       /* t1 <= bscpu gid                  */
-    or      t3,     zero,   zero                        /* t3 <= bscpu lid = 0              */
-    beq     k0,     t1,     bscpu_exit                  /* if bscpu, skip scanning core tbl */
-    li      t4,     BOOT_CORE_CXY                       /* t4 <= bscpu cxy                  */
-    /* Get base address of the core descriptor table in 'arch_info.bin' file */
-    la      t0,     ARCHINFO_BASE                       /* t0 <= ARCHINFO_BASE              */
-    li      t1,     0x80                                /* t1 <= ARCHINFO_HEADER_SIZE       */
-    addu    t2,     t0,     t1                          /* t2 <= ARCHINFO_CORE_BASE         */
-    /* scan the core descriptor table if this is not bscpu. TODO If not found?  */
-    li      t3,     0x8                                 /* t3 <= ARCHINFO_CORE_SIZE         */
-scanning_core_table:
-    lw      t1,     0(t2)                               /* t1 <= archinfo_core.gid          */
-    bne     t1,     k0,     scanning_core_table         /* if (t1 != k0) => loop            */
-    addu    t2,     t2,     t3                          /* t2 <= @ next archinfo_core       */
-    /* Get (cxy, lid) values from the found core descriptor  */
-    lw      t3,     -8(t2)                              /* t3 <= lid                        */
-    lw      t4,     -4(t2)                              /* t4 <= cxy                        */
-    /* Initialize stack pointer from previously retrieved lid value  */
-bscpu_exit:
-    la      t0,     BOOT_STACK_BASE                     /* t0 <= BOOT_STACK_BASE            */
-    li      k1,     BOOT_STACK_SIZE                     /* k1 <= BOOT_STACK_SIZE            */
-    multu   k1,     t3
-    mflo    k0                                          /* k0 <= BOOT_STACK_SIZE * lid      */
-    subu    sp,     t0,     k0                          /* P[cxy,lid] stack top initialized */
-    /* Switch to local DSPACE by changing the value of the address extension registers  */
-    mtc2    t4,     CP2_DATA_PADDR_EXT
-    /* Jumping to boot_loader() function after passing 2 arguments in registers */
-    or      a0,     zero,   t3                          /* a0 <= lid                        */
-    or      a1,     zero,   t4                          /* a1 <= cxy                        */
-    la      ra,     boot_loader
-    jr      ra
-    nop
-#endif
     .end boot_entry

trunk/hal/generic/hal_gpt.h

-                      r587
+                      r623
 /****************************************************************************************
  * This function allocates physical memory for first level page table (PT1),
  * and initializes the page table descriptor.
+ * and initializes the GPT descriptor, creating an empty GPT.
  ****************************************************************************************
  * @ gpt     : pointer on generic page table descriptor.
 …
 /****************************************************************************************
  * This function map a - local or remote - GPT entry identified by its VPN, from values
  * defined by the <ppn> and <attr> arguments. It allocates physical memory in remote
  * cluster for the GPT PT2, using a RPC_PMEM_GET_PAGES, if required.
  ****************************************************************************************
  * @ gpt       : [in] pointer on the page table
+ * This function maps in a - local or remote - GPT identified by the <gpt_xp> argument
+ * an entry identified by the <vpn> argument, as defined by <ppn> and <attr> arguments.
+ * It allocates physical memory for the GPT PT2, using a RPC_PMEM_GET_PAGES if required.
+ ****************************************************************************************
+ * @ gpt_xp    : [in] pointer on the page table
  * @ vpn       : [in] virtual page number
  * @ attr      : [in] generic attributes
 …
 /****************************************************************************************
  * This function returns in the <attr> and <ppn> arguments the current values stored
  * in a -local or remote - GPT entry, identified by the <gpt> and <vpn> arguments.
+ * in a - local or remote - GPT entry, identified by the <gpt> and <vpn> arguments.
  ****************************************************************************************
  * @ gpt_xp    : [in]  extended pointer on the page table

trunk/hal/generic/hal_special.h

-                      r619
+                      r623
 struct thread_s;
+struct gpt_s;
 ///////////////////////////////////////////////////////////////////////////////////////////
 …
 // ALMOS-MKH uses the following API to access the core protected registers.
 ///////////////////////////////////////////////////////////////////////////////////////////
+/*****************************************************************************************
+ * This function initialise - for architectures requiring it - the protected register(s)
+ * containing the kernel_entry adresse(s) for interrupts / exceptions / syscalls.
+ ****************************************************************************************/
+void hal_set_kentry( void );
+/*****************************************************************************************
+ * This function initializes - for architectures requiring it - the MMU registers
+ * as required by the target architecture to execute the kernel threads attached
+ * to kernel process zero. It is called by all cores in the kernel_init() function.
+ *****************************************************************************************
+ * @ gpt :  local pointer on the kernel page table descriptor.
+ ****************************************************************************************/
+void hal_mmu_init( struct gpt_s * gpt );
 /*****************************************************************************************
 …
 /*****************************************************************************************
  * This function makes an uncachable read to a 32 bits variable in local memory.
+ *****************************************************************************************
  * @ ptr     : pointer on the variable
  * @ returns the value
 …
 /*****************************************************************************************
  * This function returns information on MMU exceptions :
+ *****************************************************************************************
  * @ mmu_ins_excp_code : [out] instruction fetch exception code
  * @ mmu_ins_bad_vaddr : [out] instruction fetch faulty virtual address

trunk/hal/generic/hal_vmm.h

-                      r457
+                      r623
 /*
  * hal_vmm.h - Generic Virtual Memory Manager initialisation
+ * hal_vmm.h - Kernel Virtual Memory Manager initialisation
+ *
  * Authors  Alain Greiner (2016,2017)
+ * Authors  Alain Greiner (2016,2017,2018,2019)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
  */
 #ifndef _HAL_PPM_H_
 #define _HAL_PPM_H_
+#ifndef _HAL_VMM_H_
+#define _HAL_VMM_H_
 #include <hal_kernel_types.h>
 …
 /////////////////////////////////////////////////////////////////////////////////////////
 //    Generic Virtual Memory Manager initialisation (implementation in hal_vmm.c)
+//    Kernel Virtual Memory Manager initialisation (implementation in hal_vmm.c)
 //
 // Any arch-specific implementation must implement this API.
 …
 /****  Forward declarations  ****/
+struct vmm_s;
+struct process_s;
+struct boot_info_s;
 /****************************************************************************************
+ * This function makes all architecture specific initialisations
+ * in the VSL (Virtual segments List) and in the GPT (Generic Page Table).
+ * Depending on the hardware architecture, this function creates (i.e. allocates memory
+ * and initializes) the VSL (Virtual segments List) and the GPT (Generic Page Table),
+ * for all vsegs required by the kernel process.
  ****************************************************************************************
  * @ vmm   : pointer on virtual memory manager.
+ * @ info  : local pointer on boot_info (for kernel segments base & size).
  * @ return 0 if success / return ENOMEM if failure.
  ***************************************************************************************/
 error_t hal_vmm_init( struct vmm_s * vmm );
+error_t hal_vmm_kernel_init( struct boot_info_s * info );
+#endif  /* HAL_PPM_H_ */
+/****************************************************************************************
+ * Depending on the hardware architecture, this function updates the VMM of an user
+ * process identified by the <process> argument. It registers in VSL and GPT all
+ * kernel vsegs required by this architecture.
+ ****************************************************************************************
+ * @ process   : local pointer on user process descriptor.
+ * @ return 0 if success / return ENOMEM if failure.
+ ***************************************************************************************/
+error_t hal_vmm_kernel_update( struct process_s * process );
+#endif  /* HAL_VMM_H_ */

trunk/hal/tsar_mips32/core/hal_gpt.c

-                      r611
+                      r623
 #endif
+    // check page size
+    assert( (CONFIG_PPM_PAGE_SIZE == 4096) ,
+    "for TSAR, the page size must be 4 Kbytes\n" );
+// check page size
+assert( (CONFIG_PPM_PAGE_SIZE == 4096) , "for TSAR, the page size must be 4 Kbytes\n" );
     // allocates 2 physical pages for PT1
 …
     vpn_t      vpn;
+    assert( (process != NULL) , "NULL process pointer\n");
+// check argument
+assert( (process != NULL) , "NULL process pointer\n");
     // get pointer on gpt
 …
     pt1 = (uint32_t *)gpt->ptr;
     printk("\n***** Generic Page Table for process %x : &gpt = %x / &pt1 = %x\n\n",
+    printk("\n***** Tsar Page Table for process %x : &gpt = %x / &pt1 = %x\n\n",
     process->pid , gpt , pt1 );
 …
+/////////////////////////////////////////////////////////////////////////////////////
+// FOr the TSAR architecture, this function allocates a first level PT1 (8 Kbytes),
+// and maps one single big page for the kerne code segment in slot[0].
+/////////////////////////////////////////////////////////////////////////////////////
+void hal_gpt_build_kpt( cxy_t   cxy,
+                        gpt_t * gpt )
+{
+    error_t error;
+    // allocate memory for one gpt
+    error = hal_gpt_create( gpt );
+    if( error )
+    {
+        printk("\n[PANIC] in %s : cannot allocate kernel GPT in cluster %x\n",
+        __FUNCTION__ , cxy );
+        hal_core_sleep();
+    }
+    // compute attr and ppn for one PTE1
+    uint32_t attr  = 0xCA800000;           // bits : V,T,C,X,G
+    uint32_t ppn   = (cxy << 20) >> 9;
+    // set PTE1
+    error = hal_gpt_set_pte( XPTR( cxy , gpt ) , 0 , attr , ppn );
+    if( error )
+    {
+        printk("\n[PANIC] in %s : cannot initialize kernel GPT in cluster %x\n",
+        __FUNCTION__ , cxy );
+        hal_core_sleep();
+    }
+}
 //////////////////////////////////////////
 error_t hal_gpt_set_pte( xptr_t    gpt_xp,
 …
         if( small == 0 )     // map a big page in PT1
+    {
+        assert( (pte1 == 0) ,
+                "try to set a big page in a mapped PT1 entry / PT1[%d] = %x\n", ix1 , pte1 );
+// check PT1 entry not mapped
+assert( (pte1 == 0) , "try to set a big page in a mapped PT1 entry\n" );
+// check VPN aligned
+assert( (ix2 == 0) , "illegal vpn for a big page\n" );
+// check PPN aligned
+assert( ((ppn & 0x1FF) == 0) , "illegal ppn for a big page\n" );
         // set the PTE1 value in PT1
         pte1 = (tsar_attr  & TSAR_MMU_PTE1_ATTR_MASK) | ((ppn >> 9) & TSAR_MMU_PTE1_PPN_MASK);

trunk/hal/tsar_mips32/core/hal_special.c

-                      r619
+                      r623
 struct thread_s;
+//////////////////////////////////////////////////////////////////////////////////
+//   Extern global variables
+//////////////////////////////////////////////////////////////////////////////////
+extern cxy_t local_cxy;
+extern void  hal_kentry_enter( void );
+/////////////////////////////////////////////////////////////////////////////////
+// For the TSAR architecture, this function register the physical address of
+// the first level page table (PT1) in the PTPR register.
+// It activates the intructions MMU, and de-activates the data MMU.
+/////////////////////////////////////////////////////////////////////////////////
+void hal_mmu_init( gpt_t * gpt )
+{
+    // set PT1 base address in mmu_ptpr register
+    uint32_t ptpr = (((uint32_t)gpt->ptr) >> 13) | (local_cxy << 19);
+    asm volatile ( "mtc2   %0,   $0         \n" : : "r" (ptpr) );
+    // set ITLB | ICACHE | DCACHE bits in mmu_mode register
+    asm volatile ( "ori    $26,  $0,  0xB   \n"
+                   "mtc2   $26,  $1         \n" );
+}
+////////////////////////////////////////////////////////////////////////////////
+// For the TSAR architecture, this function registers the address of the
+// hal_kentry_enter() function in the MIPS32 cp0_ebase register.
+////////////////////////////////////////////////////////////////////////////////
+void hal_set_kentry( void )
+{
+    uint32_t kentry = (uint32_t)(&hal_kentry_enter);
+    asm volatile("mtc0   %0,  $15,  1" : : "r" (kentry) );
+}
 ////////////////////////////////
 inline gid_t hal_get_gid( void )

trunk/hal/tsar_mips32/core/hal_vmm.c

-                      r587
+                      r623
  * hal_vmm.c - Virtual Memory Manager Initialisation for TSAR
+ *
  * Authors  Alain Greiner (2016,2017)
+ * Authors  Alain Greiner (2016,2017,2018,2019)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
 #include <hal_vmm.h>
 #include <hal_gpt.h>
+#include <process.h>
 #include <vseg.h>
 #include <xlist.h>
 …
 //////////////////////////////////////////////////////////////////////////////////////////
+// This file contains the TSAR specific code to initialize the Virtual Memory Manager.
+// The "kentry" vseg contains the kernel code executed when a core enter/exit the kernel,
+// in case of Interrupt, Exception, or Syscall.
+// For the TSAR architecture, the kernel uses physical addresses, and this code must be
+// identity mapped. The following function is called by the generic vmm_init() function
+// and identity map all pages of the "kentry" vseg.
+// We dont take the locks protecting the VSL and the GPT, because there is no concurrent
+// accesses to VMM during VMM initialization.
+// This file contains the TSAR specific code used to initialize the kernel process VMM,
+// or to update an user process VMM with informations related to the kernel vsegs.
+// As the TSAR architure does not use the DATA MMU, but use only the DATA extension
+// address register to access local and remote kernel data, the kernel VSL contains only
+// one "kcode" segment, and the kernel GPT contains only one big page in PT1[0] slot.
 //////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////
+error_t  hal_vmm_init( vmm_t * vmm )
+// extern global variables
+extern process_t process_zero;
+//////////////////////////////////////////////////////////////////////////////////////////
+// This function is called by the process_zero_init() function during kernel_init.
+// It initializes the VMM of the kernel proces_zero (containing all kernel threads)
+// in the local cluster.
+//////////////////////////////////////////////////////////////////////////////////////////
+error_t  hal_vmm_kernel_init( boot_info_t * info )
+{
     error_t error;
+    error_t   error;
+    // map all pages of "kentry" vseg
+    uint32_t vpn;
+    uint32_t attr;
+    attr = GPT_MAPPED | GPT_SMALL | GPT_EXECUTABLE | GPT_CACHABLE | GPT_GLOBAL;
+    for( vpn = CONFIG_VMM_KENTRY_BASE;
+         vpn < (CONFIG_VMM_KENTRY_BASE + CONFIG_VMM_KENTRY_SIZE); vpn++ )
+    // get pointer on kernel GPT
+    gpt_t * gpt = &process_zero.vmm.gpt;
+    // get cluster identifier
+    cxy_t cxy = local_cxy;
+    // allocate memory for kernel GPT
+    error = hal_gpt_create( gpt );
+    if( error )
+    {
+        error = hal_gpt_set_pte( XPTR( local_cxy , &vmm->gpt ),
+                                 vpn,
+                                 attr,
+                                 (local_cxy<<20) | (vpn & 0xFFFFF) );
+        if( error ) return error;
+        printk("\n[PANIC] in %s : cannot allocate kernel GPT in cluster %x\n",
+        __FUNCTION__ , cxy );
+        hal_core_sleep();
+    }
     // scan the VSL to found the "kentry" vseg
     xptr_t         root_xp = XPTR( local_cxy , &vmm->vsegs_root );
     xptr_t         iter_xp;
+    xptr_t         vseg_xp;
     vseg_t       * vseg;
     bool_t         found = false;
     XLIST_FOREACH( root_xp , iter_xp )
+    // compute attr and ppn for one PTE1
+    uint32_t attr  = 0x8A800000;           // bits : V,C,X,G
+    uint32_t ppn   = (cxy << 20) >> 9;     // physical page index is 0
+    // set PTE1  in slot[0]
+    error = hal_gpt_set_pte( XPTR( cxy , gpt ) , 0 , attr , ppn );
+    if( error )
+    {
+        vseg_xp = XLIST_ELEMENT( iter_xp , vseg_t , xlist );
+        vseg    = (vseg_t *)GET_PTR( vseg_xp );
+        // set the IDENT flag in "kentry" vseg descriptor
+        if( vseg->vpn_base == CONFIG_VMM_KENTRY_BASE )
+        {
+            vseg->flags |= VSEG_IDENT;
+            found = true;
+            break;
+        }
+        printk("\n[PANIC] in %s : cannot initialize kernel GPT in cluster %x\n",
+        __FUNCTION__ , cxy );
+        hal_core_sleep();
+    }
+    if( found == false ) return 0XFFFFFFFF;
+    return 0;
+    // create kcode vseg and register it in kernel VSL
+    vseg_t * vseg = vmm_create_vseg( &process_zero,
+                                     VSEG_TYPE_CODE,
+                                     info->kcode_base,
+                                     info->kcode_size,
+, 0,                  // file ofset and file size (unused)
+                                     XPTR_NULL,             // no mapper
+                                     local_cxy );
+    if( vseg == NULL )
+    {
+        printk("\n[PANIC] in %s : cannot register vseg to VSL in cluster %x\n",
+        __FUNCTION__ , cxy );
+        hal_core_sleep();
+    }
 }  // end hal_vmm_init()
+//////////////////////////////////////////////////////////////////////////////////////////
+// This function is called by the vmm_init() function to update the VMM of an user
+// process identified by the <process> argument.
+// It registers in the user VSL the "kcode" vseg, registered in the local kernel VSL,
+// and register in the user GPT the big page[0] mapped in the local kernel GPT.
+//////////////////////////////////////////////////////////////////////////////////////////
+error_t hal_vmm_kernel_update( process_t * process )
+{
+    error_t error;
+    uint32_t attr;
+    uint32_t ppn;
+// TODO check ppn value in kernel GPT (must be 0)
+    // get cluster identifier
+    cxy_t cxy = local_cxy;
+    // get extended pointer on user GPT
+    xptr_t gpt_xp = XPTR( cxy , &process->vmm.gpt );
+    // get ppn and attributes from slot[0] in kernel GPT
+    hal_gpt_get_pte( gpt_xp , 0 , &attr , &ppn );
+// check ppn and attributes
+assert( (attr == 0x8A800000) && (ppn == ((cxy << 20) >> 9)),  __FUNCTION__,
+"bad ppn = %x or attr = %x in slot[0] of kernel GPT\n", ppn , attr );
+    // update user GPT : set PTE1 in slot[0]
+    error = hal_gpt_set_pte( gpt_xp , 0 , attr , ppn );
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot update GPT in cluster %x\n",
+        __FUNCTION__ , cxy );
+        return -1;
+    }
+    // get pointer on the unique vseg registered in kernel VSL
+    xptr_t root_xp = XPTR( cxy , &process_zero.vmm.vsegs_root );
+    vseg_t * vseg = XLIST_FIRST( root_xp , vseg_t , xlist );
+// check vsegs_nr
+assert( (process_zero.vmm.vsegs_nr == 1 ) , __FUNCTION__,
+"bad vsegs number in kernel VSL\n" );
+    // update user VSL : register one new vseg for kcode
+    vseg_t * new = vmm_create_vseg( process,
+                                    vseg->type,
+                                    vseg->min,
+                                    vseg->max - vseg->min,
+, 0,                  // file ofset and file size (unused)
+                                    XPTR_NULL,             // no mapper
+                                    local_cxy );
+    if( new == NULL )
+    {
+        printk("\n[ERROR] in %s : cannot update VSL in cluster %x\n",
+        __FUNCTION__ , cxy );
+        return -1;
+    }
+}

trunk/hal/tsar_mips32/kernel.ld

r570	r623
4	4	* loadable segments, that MUST be identity mapped for the TSAR architecture.
5	5	*
6		* WARNING ~~the seg_kentry_base and seg_kcode_base defined below must be kept~~ coherent
	6	* WARNING : the seg_kentry_base and seg_kcode_base defined below must be coherent
7	7	* with the values defined in the boot_config.h file used by the TSAR bootloader.
8	8	**************************************************************************************/

trunk/kernel/fs/devfs.c

-                      r614
+                      r623
+ *
  * Author   Mohamed Lamine Karaoui (2014,2015)
  *          Alain Greiner (2016,2017)
+ *          Alain Greiner (2016,2017,2018,2019)
+ *
  * Copyright (c) Sorbonne Universites
 …
                         xptr_t * devfs_external_inode_xp )
+{
+    error_t  error;
+    xptr_t   unused_xp;   // required by vfs_add_child_in_parent()
+    error_t       error;
+    xptr_t        unused_xp;   // required by vfs_add_child_in_parent()
+    vfs_inode_t * inode;
     // create DEVFS "dev" inode in cluster 0
     error = vfs_add_child_in_parent( 0,                // cxy
-                                     INODE_TYPE_DIR,
                                      FS_TYPE_DEVFS,
                                      root_inode_xp,
 …
                                      devfs_dev_inode_xp );
+    // update inode "type" field
+    inode = GET_PTR( *devfs_dev_inode_xp );
+    inode->type = INODE_TYPE_DIR;
     // create dentries <.> and <..> in <dev>
     error |= vfs_add_special_dentries( *devfs_dev_inode_xp,
                                        root_inode_xp );
+// check success
+assert( (error == 0) , "cannot create <dev>\n" );
+    if( error )
+    {
+        printk("\n[PANIC] in %s : cannot create <dev> directory\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
 #if DEBUG_DEVFS_GLOBAL_INIT
 …
     // create DEVFS "external" inode in cluster 0
     error = vfs_add_child_in_parent( 0,               // cxy
-                                     INODE_TYPE_DIR,
                                      FS_TYPE_DEVFS,
                                      *devfs_dev_inode_xp,
 …
                                      devfs_external_inode_xp );
+    // update inode "type" field
+    inode = GET_PTR( *devfs_external_inode_xp );
+    inode->type = INODE_TYPE_DIR;
     // create dentries <.> and <..> in <external>
     error |= vfs_add_special_dentries( *devfs_external_inode_xp,
                                        *devfs_dev_inode_xp );
+// check success
+assert( (error == 0) , "cannot create <external>\n" );
+    if( error )
+    {
+        printk("\n[PANIC] in %s : cannot create <external> directory\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
 #if DEBUG_DEVFS_GLOBAL_INIT
 …
     chdev_t     * chdev_ptr;
     xptr_t        inode_xp;
-    cxy_t         inode_cxy;
     vfs_inode_t * inode_ptr;
     uint32_t      channel;
 …
     error = vfs_add_child_in_parent( local_cxy,
-                                     INODE_TYPE_DIR,
                                      FS_TYPE_DEVFS,
                                      devfs_dev_inode_xp,
 …
                                      devfs_internal_inode_xp );
+    // set inode "type" field
+    inode_ptr = GET_PTR( *devfs_internal_inode_xp );
+    inode_ptr->type = INODE_TYPE_DEV;
     // create dentries <.> and <..> in <internal>
     error |= vfs_add_special_dentries( *devfs_internal_inode_xp,
                                        devfs_dev_inode_xp );
+// check success
+assert( (error == 0) , "cannot create <external>\n" );
+    if( error )
+    {
+        printk("\n[PANIC] in %s : cannot create <internal> directory\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
 #if DEBUG_DEVFS_LOCAL_INIT
 …
         chdev_cxy = GET_CXY( chdev_xp );
+assert( (chdev_cxy == local_cxy ), "illegal MMC chdev in cluster %x\n", local_cxy );
+        if( chdev_cxy != local_cxy )
+        {
+            printk("\n[PANIC] in %s : illegal MMC chdev in cluster %x\n",
+            __FUNCTION__, local_cxy );
+            hal_core_sleep();
+        }
         error = vfs_add_child_in_parent( local_cxy,
-                                         INODE_TYPE_DEV,
                                          FS_TYPE_DEVFS,
                                          *devfs_internal_inode_xp,
 …
                                          &inode_xp );
+assert( (error == 0) , "cannot create MMC inode\n" );
+        // update child inode "extend" field
+        inode_cxy = GET_CXY( inode_xp );
+        if( error )
+        {
+            printk("\n[PANIC] in %s : cannot create MMC inode in cluster %x\n",
+            __FUNCTION__, local_cxy );
+            hal_core_sleep();
+        }
+        // update child inode "extend" and "type" fields
         inode_ptr = GET_PTR( inode_xp );
+        hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
+        inode_ptr->extend = chdev_ptr;
+        inode_ptr->type   = INODE_TYPE_DEV;
 #if DEBUG_DEVFS_LOCAL_INIT
 …
             chdev_cxy = GET_CXY( chdev_xp );
+assert( (chdev_cxy == local_cxy ), "illegal DMA chdev in cluster %x\n", local_cxy );
+            if( chdev_cxy != local_cxy )
+            {
+                printk("\d[PANIC] in %s : illegal DMA chdev in cluster %x\n",
+                __FUNCTION__, local_cxy );
+                hal_core_sleep();
+            }
             error = vfs_add_child_in_parent( local_cxy,
-                                             INODE_TYPE_DEV,
                                              FS_TYPE_DEVFS,
                                              *devfs_internal_inode_xp,
 …
                                              &unused_xp,
                                              &inode_xp );
+assert( (error == 0) , "cannot create DMA inode\n" );
+            // update child inode "extend" field
+            inode_cxy = GET_CXY( inode_xp );
+            if( error )
+            {
+                printk("\n[PANIC] in %s : cannot create DMA inode in cluster %x\n",
+                __FUNCTION__, local_cxy );
+                hal_core_sleep();
+            }
+            // update child inode "extend" and "type" fields
             inode_ptr = GET_PTR( inode_xp );
+            hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
+            inode_ptr->extend = chdev_ptr;
+            inode_ptr->type   = INODE_TYPE_DEV;
 #if DEBUG_DEVFS_LOCAL_INIT
 …
+        {
             error = vfs_add_child_in_parent( local_cxy,
-                                             INODE_TYPE_DEV,
                                              FS_TYPE_DEVFS,
                                              devfs_external_inode_xp,
 …
                                              &unused_xp,
                                              &inode_xp );
+assert( (error == 0) , "cannot create IOB inode\n" );
+            // update child inode "extend" field
+            inode_cxy = GET_CXY( inode_xp );
+            if( error )
+            {
+                printk("\n[PANIC] in %s : cannot create IOB inode in cluster %x\n",
+                __FUNCTION__, local_cxy );
+                hal_core_sleep();
+            }
+            // update child inode "extend" and "type" fields
             inode_ptr = GET_PTR( inode_xp );
+            hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
+            inode_ptr->extend = chdev_ptr;
+            inode_ptr->type   = INODE_TYPE_DEV;
 #if DEBUG_DEVFS_LOCAL_INIT
 …
+        {
             error = vfs_add_child_in_parent( local_cxy,
-                                             INODE_TYPE_DEV,
                                              FS_TYPE_DEVFS,
                                              devfs_external_inode_xp,
 …
                                              &inode_xp );
+assert( (error == 0) , "cannot create PIC inode\n" );
+            if( error )
+            {
+                printk("\n[PANIC] in %s : cannot create PIC inode in cluster %x\n",
+                __FUNCTION__, local_cxy );
+                hal_core_sleep();
+            }
             // update child inode "extend" field
-            inode_cxy = GET_CXY( inode_xp );
             inode_ptr = GET_PTR( inode_xp );
+            hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
+            inode_ptr->extend = chdev_ptr;
+            inode_ptr->type   = INODE_TYPE_DEV;
 #if DEBUG_DEVFS_LOCAL_INIT
 …
+            {
                 error = vfs_add_child_in_parent( local_cxy,
-                                                 INODE_TYPE_DEV,
                                                  FS_TYPE_DEVFS,
                                                  devfs_external_inode_xp,
 …
                                                  &inode_xp );
+assert( (error == 0) , "cannot create TXT_RX inode\n" );
+                // update child inode "extend" field
+                inode_cxy = GET_CXY( inode_xp );
+                if( error )
+                {
+                    printk("\n[PANIC] in %s : cannot create TXT_RX inode in cluster %x\n",
+                    __FUNCTION__, local_cxy );
+                    hal_core_sleep();
+                }
+                // update child inode "extend" and "type" fields
                 inode_ptr = GET_PTR( inode_xp );
+                hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
+                inode_ptr->extend = chdev_ptr;
+                inode_ptr->type   = INODE_TYPE_DEV;
 #if DEBUG_DEVFS_LOCAL_INIT
 …
+            {
                 error = vfs_add_child_in_parent( local_cxy,
-                                                 INODE_TYPE_DEV,
                                                  FS_TYPE_DEVFS,
                                                  devfs_external_inode_xp,
 …
                                                  &unused_xp,
                                                  &inode_xp );
+assert( (error == 0) , "cannot create TXT_TX inode\n" );
+                // update child inode "extend" field
+                inode_cxy = GET_CXY( inode_xp );
+                if( error )
+                {
+                    printk("\n[PANIC] in %s : cannot create TXT_TX inode in cluster %x\n",
+                    __FUNCTION__, local_cxy );
+                    hal_core_sleep();
+                }
+                // update child inode "extend" and "type" fields
                 inode_ptr = GET_PTR( inode_xp );
+                hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
+                inode_ptr->extend = chdev_ptr;
+                inode_ptr->type   = INODE_TYPE_DEV;
 #if DEBUG_DEVFS_LOCAL_INIT
 …
+            {
                 error = vfs_add_child_in_parent( local_cxy,
-                                                 INODE_TYPE_DEV,
                                                  FS_TYPE_DEVFS,
                                                  devfs_external_inode_xp,
 …
                                                  &unused_xp,
                                                  &inode_xp );
+assert( (error == 0) , "cannot create IOC inode\n" );
+                // update child inode "extend" field
+                inode_cxy = GET_CXY( inode_xp );
+                if( error )
+                {
+                    printk("\n[PANIC] in %s : cannot create IOC inode in cluster %x\n",
+                    __FUNCTION__, local_cxy );
+                    hal_core_sleep();
+                }
+                // update child inode "extend" and "type" fields
                 inode_ptr = GET_PTR( inode_xp );
+                hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
+                inode_ptr->extend = chdev_ptr;
+                inode_ptr->type   = INODE_TYPE_DEV;
 #if DEBUG_DEVFS_LOCAL_INIT
 …
+            {
                 error = vfs_add_child_in_parent( local_cxy,
-                                                 INODE_TYPE_DEV,
                                                  FS_TYPE_DEVFS,
                                                  devfs_external_inode_xp,
 …
                                                  &unused_xp,
                                                  &inode_xp );
+assert( (error == 0) , "cannot create FBF inode\n" );
+                // update child inode "extend" field
+                inode_cxy = GET_CXY( inode_xp );
+                if( error )
+                {
+                    printk("\n[PANIC] in %s : cannot create FBF inode in cluster %x\n",
+                    __FUNCTION__, local_cxy );
+                    hal_core_sleep();
+                }
+                // update child inode "extend" and "type" fields
                 inode_ptr = GET_PTR( inode_xp );
+                hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
+                inode_ptr->extend = chdev_ptr;
+                inode_ptr->type   = INODE_TYPE_DEV;
 #if DEBUG_DEVFS_LOCAL_INIT
 …
+            {
                 error = vfs_add_child_in_parent( local_cxy,
-                                                 INODE_TYPE_DEV,
                                                  FS_TYPE_DEVFS,
                                                  devfs_external_inode_xp,
 …
                                                  &unused_xp,
                                                  &inode_xp );
+assert( (error == 0) , "cannot create NIC_RX inode\n" );
+                // update child inode "extend" field
+                inode_cxy = GET_CXY( inode_xp );
+                if( error )
+                {
+                    printk("\n[PANIC] in %s : cannot create NIC_RX inode in cluster %x\n",
+                    __FUNCTION__, local_cxy );
+                    hal_core_sleep();
+                }
+                // update child inode "extend" and "type" fields
                 inode_ptr = GET_PTR( inode_xp );
+                hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
+                inode_ptr->extend = chdev_ptr;
+                inode_ptr->type   = INODE_TYPE_DEV;
 #if DEBUG_DEVFS_LOCAL_INIT
 …
+            {
                 error = vfs_add_child_in_parent( local_cxy,
-                                                 INODE_TYPE_DEV,
                                                  FS_TYPE_DEVFS,
                                                  devfs_external_inode_xp,
 …
                                                  &unused_xp,
                                                  &inode_xp );
+assert( (error == 0) , "cannot create NIC_TX inode\n" );
+                // update child inode "extend" field
+                inode_cxy = GET_CXY( inode_xp );
+                if( error )
+                {
+                    printk("\n[PANIC] in %s : cannot create NIC_TX inode in cluster %x\n",
+                    __FUNCTION__, local_cxy );
+                    hal_core_sleep();
+                }
+                // update child inode "extend" and "type" fields
                 inode_ptr = GET_PTR( inode_xp );
+                hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
+                inode_ptr->extend = chdev_ptr;
+                inode_ptr->type   = INODE_TYPE_DEV;
 #if DEBUG_DEVFS_LOCAL_INIT

trunk/kernel/fs/fatfs.c

-                      r614
+                      r623
 #if (DEBUG_FATFS_CTX_INIT & 0x1)
 if( DEBUG_FATFS_CTX_INIT < cycle )
+{
+    uint32_t   line;
+    uint32_t   byte = 0;
+    printk("\n***** %s : FAT boot record\n", __FUNCTION__ );
+    for ( line = 0 ; line < 32 ; line++ )
+    {
+        printk(" %X | %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x |\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;
+    }
+}
+putb( "boot record", buffer , 256 );
 #endif
 …
 assert( (inode != NULL) , "inode pointer is NULL\n" );
 assert( (dentry != NULL) , "dentry pointer is NULL\n" );
-assert( (inode->type == INODE_TYPE_DIR) , "inode is not a directory\n" );
 assert( (inode->mapper != NULL ) , "mapper pointer is NULL\n" );
 …
 }  // end fatfs_remove_dentry
+/////////////////////////////////////////////////////
+error_t fatfs_get_dentry( vfs_inode_t * parent_inode,
+                          char        * name,
+                          xptr_t        child_inode_xp )
+//////////////////////////////////////////////////////////////////////////////////////////////
+// This static function scan the pages of a mapper containing a FAT32 directory, identified
+// by the <mapper> argument, to find the directory entry identified by the <name> argument,
+// and return a pointer on the directory entry, described as and array of 32 bytes, and the
+// incex of this entry in the FAT32 mapper, seen as an array of 32 bytes entries.
+// It is called by the fatfs_new_dentry() and fatfs_update_dentry() functions.
+// It must be called by a thread running in the cluster containing the mapper.
+//////////////////////////////////////////////////////////////////////////////////////////////
+// @ mapper    : [in]  local pointer on directory mapper.
+// @ name      : [in]  searched directory entry name.
+// @ entry     : [out] buffer for the pointer on the 32 bytes directory entry (when found).
+// @ index     : [out] buffer for the directory entry index in mapper.
+// @ return 0 if found / return 1 if not found / return -1 if mapper access error.
+//////////////////////////////////////////////////////////////////////////////////////////////
+error_t fatfs_scan_directory( mapper_t *  mapper,
+                              char     *  name,
+                              uint8_t  ** entry,
+                              uint32_t *  index )
+{
     // Two embedded loops to scan the directory mapper:
 …
     // - scan the directory entries in each 4 Kbytes page
+#if DEBUG_FATFS_GET_DENTRY
+// check parent_inode and child_inode
+assert( (mapper != NULL) , "mapper pointer is NULL\n" );
+assert( (name   != NULL ), "child name is undefined\n" );
+assert( (entry  != NULL ), "entry buffer undefined\n" );
+#if DEBUG_FATFS_SCAN_DIRECTORY
 char       parent_name[CONFIG_VFS_MAX_NAME_LENGTH];
 uint32_t   cycle = (uint32_t)hal_get_cycles();
 thread_t * this  = CURRENT_THREAD;
 vfs_inode_get_name( XPTR( local_cxy , parent_inode ) , parent_name );
 if( DEBUG_FATFS_GET_DENTRY < cycle )
 printk("\n[%s]  thread[%x,%x] enter for child <%s> in parent <%s> / cycle %d\n",
+vfs_inode_get_name( XPTR( local_cxy , mapper->inode ) , parent_name );
+if( DEBUG_FATFS_SCAN_DIRECTORY < cycle )
+printk("\n[%s]  thread[%x,%x] enter to search child <%s> in parent <%s> / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, name , parent_name , cycle );
 #endif
+// check parent_inode and child_inode
+assert( (parent_inode != NULL) , "parent_inode is NULL\n" );
+assert( (child_inode_xp != XPTR_NULL ) , "child_inode is XPTR_NULL\n" );
+    mapper_t * mapper    = parent_inode->mapper;
+    xptr_t     mapper_xp = XPTR( local_cxy , mapper );
+// check parent mapper
+assert( (mapper != NULL) , "parent mapper is NULL\n");
+    char       cname[CONFIG_VFS_MAX_NAME_LENGTH];  // name extracter from each directory entry
+    char       cname[CONFIG_VFS_MAX_NAME_LENGTH];  // name extracted from each directory entry
     char       lfn1[16];         // buffer for one partial cname
     char       lfn2[16];         // buffer for one partial cname
     char       lfn3[16];         // buffer for one partial cname
+    xptr_t     mapper_xp;        // extended pointer on mapper descriptor
     xptr_t     page_xp;          // extended pointer on page descriptor
     xptr_t     base_xp;          // extended pointer on page base
 …
     uint32_t   seq;              // sequence index
     uint32_t   lfn       = 0;    // LFN entries number
+    uint32_t   size      = 0;    // searched file/dir size (bytes)
+    uint32_t   cluster   = 0;    // searched file/dir cluster index
+    uint32_t   is_dir    = 0;    // searched file/dir type
+    int32_t    found     = 0;    // not found (0) / name found (1) / end of dir (-1)
+    int32_t    found     = 0;    // not yet = 0 / success = 1 / not found = 2 / error = -1
     uint32_t   page_id   = 0;    // page index in mapper
-    uint32_t   dentry_id = 0;    // directory entry index
     uint32_t   offset    = 0;    // byte offset in page
+    // scan the parent directory mapper
+    mapper_xp = XPTR( local_cxy , mapper );
+    // scan the mapper pages
     while ( found == 0 )
+    {
 …
         page_xp = mapper_remote_get_page( mapper_xp , page_id );
+        if( page_xp == XPTR_NULL) return EIO;
+        if( page_xp == XPTR_NULL)
+        {
+            found = -1;
+        }
         // get page base
 …
         base    = (uint8_t *)GET_PTR( base_xp );
 #if (DEBUG_FATFS_GET_DENTRY & 0x1)
 if( DEBUG_FATFS_GET_DENTRY < cycle )
+#if (DEBUG_FATFS_SCAN_DIRECTORY & 0x1)
+if( DEBUG_FATFS_SCAN_DIRECTORY < cycle )
 mapper_display_page( mapper_xp , page_id , 256 );
 #endif
 …
             if (ord == NO_MORE_ENTRY)                 // no more entry => break
+            {
                 found = -1;
+                found = 2;
+            }
             else if ( ord == FREE_ENTRY )             // free entry => skip
 …
                 if ( strcmp( name , cname ) == 0 )
+                {
+                    cluster = (fatfs_get_record( DIR_FST_CLUS_HI , base + offset , 1 ) << 16) |
+                              (fatfs_get_record( DIR_FST_CLUS_LO , base + offset , 1 )      ) ;
+                    dentry_id = ((page_id<<12) + offset)>>5;
+                    is_dir    = ((attr & ATTR_DIRECTORY) == ATTR_DIRECTORY);
+                    size      = fatfs_get_record( DIR_FILE_SIZE , base + offset , 1 );
+                    *entry = base + offset;
+                    *index = ((page_id<<12) + offset)>>5;
                     found     = 1;
+                }
 …
     }  // end loop on pages
+    // analyse the result of scan
+    if ( found == -1 )  // found end of directory => failure
+    {
+    if( found == 1 )
+    {
+#if DEBUG_FATFS_SCAN_DIRECTORY
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_FATFS_SCAN_DIRECTORY < cycle )
+printk("\n[%s]  thread[%x,%x] exit / found child <%s> in <%s>\n",
+__FUNCTION__, this->process->pid, this->trdid, name, parent_name );
+#endif
+        return 0;
+    }
+    else if( found == 2 )
+    {
+#if DEBUG_FATFS_SCAN_DIRECTORY
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_FATFS_SCAN_DIRECTORY < cycle )
+printk("\n[%s]  thread[%x,%x] exit / child <%s> in <%s> not found\n",
+__FUNCTION__, this->process->pid, this->trdid, name, parent_name );
+#endif
+        return 1;
+    }
+    else
+    {
+        printk("\n[ERROR] in %s : cannot get page %d from mapper\n",
+        __FUNCTION__, page_id );
+        return -1;
+    }
+}  // end fatfs_scan_directory()
+/////////////////////////////////////////////////////
+error_t fatfs_new_dentry( vfs_inode_t * parent_inode,
+                          char        * name,
+                          xptr_t        child_inode_xp )
+{
+    uint8_t  * entry;    // pointer on FAT32 directory entry (array of 32 bytes)
+    uint32_t   index;    // index of FAT32 directory entry in mapper
+    mapper_t * mapper;   // pointer on directory mapper
+    uint32_t   cluster;  // directory entry cluster
+    uint32_t   size;     // directory entry size
+    bool_t     is_dir;   // directory entry type (file/dir)
+    error_t    error;
+// check arguments
+assert( (parent_inode != NULL)         , "parent_inode is NULL\n" );
+assert( (name         != NULL)         , "name is NULL\n" );
+assert( (child_inode_xp != XPTR_NULL ) , "child_inode is XPTR_NULL\n" );
+#if DEBUG_FATFS_GET_DENTRY
+char       parent_name[CONFIG_VFS_MAX_NAME_LENGTH];
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+thread_t * this  = CURRENT_THREAD;
+vfs_inode_get_name( XPTR( local_cxy , parent_inode ) , parent_name );
+if( DEBUG_FATFS_GET_DENTRY < cycle )
+printk("\n[%s]  thread[%x,%x] enter for child <%s> in parent <%s> / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, name , parent_name , cycle );
+#endif
+    // get pointer and index of searched directory entry in mapper
+    mapper = parent_inode->mapper;
+    error  = fatfs_scan_directory( mapper, name , &entry , &index );
+    // update child inode and dentry descriptors if sucess
+    if( error == 0 )
+    {
 #if DEBUG_FATFS_GET_DENTRY
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_FATFS_GET_DENTRY < cycle )
+printk("\n[%s]  thread[%x,%x] exit / child <%s> not found / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, name, cycle );
+#endif
+        return -1;
+    }
+    // get child inode cluster and local pointer
+    cxy_t          inode_cxy = GET_CXY( child_inode_xp );
+    vfs_inode_t  * inode_ptr = GET_PTR( child_inode_xp );
+    // build extended pointer on parent dentried root
+    xptr_t parents_root_xp = XPTR( inode_cxy , &inode_ptr->parents );
+printk("\n[%s]  thread[%x,%x] exit / intialised child <%s> in %s / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, name, parent_name, cycle );
+#endif
+        // get relevant infos from FAT32 directory entry
+        cluster = (fatfs_get_record( DIR_FST_CLUS_HI , entry , 1 ) << 16) |
+                  (fatfs_get_record( DIR_FST_CLUS_LO , entry , 1 )      ) ;
+        is_dir  = (fatfs_get_record( DIR_ATTR        , entry , 1 ) & ATTR_DIRECTORY);
+        size    =  fatfs_get_record( DIR_FILE_SIZE   , entry , 1 );
+        // get child inode cluster and local pointer
+        cxy_t          inode_cxy = GET_CXY( child_inode_xp );
+        vfs_inode_t  * inode_ptr = GET_PTR( child_inode_xp );
+        // build extended pointer on root of list of prent dentries
+        xptr_t parents_root_xp = XPTR( inode_cxy , &inode_ptr->parents );
 // check child inode has at least one parent
 assert( (xlist_is_empty( parents_root_xp ) == false ), "child inode must have one parent\n");
     // get dentry pointers and cluster
     xptr_t         dentry_xp  = XLIST_FIRST( parents_root_xp , vfs_dentry_t , parents );
     vfs_dentry_t * dentry_ptr = GET_PTR( dentry_xp );
     cxy_t          dentry_cxy = GET_CXY( dentry_xp );
+        // get dentry pointers and cluster
+        xptr_t         dentry_xp  = XLIST_FIRST( parents_root_xp , vfs_dentry_t , parents );
+        vfs_dentry_t * dentry_ptr = GET_PTR( dentry_xp );
+        cxy_t          dentry_cxy = GET_CXY( dentry_xp );
 // check dentry descriptor in same cluster as parent inode
 assert( (dentry_cxy == local_cxy) , "illegal dentry cluster\n" );
+    // update the child inode "type", "size", and "extend" fields
+    vfs_inode_type_t type = (is_dir) ? INODE_TYPE_DIR : INODE_TYPE_FILE;
+    hal_remote_s32( XPTR( inode_cxy , &inode_ptr->type   ) , type );
+    hal_remote_s32( XPTR( inode_cxy , &inode_ptr->size   ) , size );
+    hal_remote_s32( XPTR( inode_cxy , &inode_ptr->extend ) , cluster );
+    // update the dentry "extend" field
+    dentry_ptr->extend = (void *)(intptr_t)dentry_id;
+#if DEBUG_FATFS_GET_DENTRY
+        // update the child inode "type", "size", and "extend" fields
+        vfs_inode_type_t type = (is_dir) ? INODE_TYPE_DIR : INODE_TYPE_FILE;
+        hal_remote_s32( XPTR( inode_cxy , &inode_ptr->type   ) , type );
+        hal_remote_s32( XPTR( inode_cxy , &inode_ptr->size   ) , size );
+        hal_remote_s32( XPTR( inode_cxy , &inode_ptr->extend ) , cluster );
+        // update the dentry "extend" field
+        dentry_ptr->extend = (void *)(intptr_t)index;
+        return 0;
+    }
+    else
+    {
+        return -1;
+    }
+}  // end fatfs_new_dentry()
+//////////////////////////////////////////////////
+error_t fatfs_update_dentry( vfs_inode_t  * inode,
+                             vfs_dentry_t * dentry,
+                             uint32_t       size )
+{
+    uint8_t  * entry;    // pointer on FAT32 directory entry (array of 32 bytes)
+    uint32_t   index;    // index of FAT32 directory entry in mapper
+    mapper_t * mapper;   // pointer on directory mapper
+    error_t    error;
+// check arguments
+assert( (inode  != NULL) , "inode is NULL\n" );
+assert( (dentry != NULL) , "dentry is NULL\n" );
+assert( (size   != 0   ) , "size is 0\n" );
+#if DEBUG_FATFS_UPDATE_DENTRY
+char       dir_name[CONFIG_VFS_MAX_NAME_LENGTH];
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+thread_t * this  = CURRENT_THREAD;
+vfs_inode_get_name( XPTR( local_cxy , inode ) , dir_name );
+if( DEBUG_FATFS_UPDATE_DENTRY < cycle )
+printk("\n[%s]  thread[%x,%x] enter for entry <%s> in dir <%s> / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, dentry->name , dir_name , cycle );
+#endif
+    // get pointer and index of searched directory entry in mapper
+    mapper = inode->mapper;
+    error  = fatfs_scan_directory( mapper, dentry->name , &entry , &index );
+    // update size in mapper if found
+    if( error == 0 )
+    {
+#if DEBUG_FATFS_UPDATE_DENTRY
 cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_FATFS_GET_DENTRY < cycle )
+printk("\n[%s]  thread[%x,%x] exit / child <%s> loaded in <%s> / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, name, parent_name, cycle );
+#endif
+    return 0;
+}  // end fatfs_get_dentry()
+if( DEBUG_FATFS_UPDATE_DENTRY < cycle )
+printk("\n[%s]  thread[%x,%x] exit / found entry <%s> in <%s> / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, dentry->name, dir_name, cycle );
+#endif
+        // set size in FAT32 directory entry
+        fatfs_set_record( DIR_FILE_SIZE , entry , 1 , size );
+        // get local pointer on modified page base
+        void * base = (void *)((intptr_t)entry & (~CONFIG_PPM_PAGE_MASK));
+        // get extended pointer on modified page descriptor
+        xptr_t    page_xp = ppm_base2page( XPTR( local_cxy , base ) );
+        // mark page as dirty
+        ppm_page_do_dirty( page_xp );
+        return 0;
+    }
+    else
+    {
+        return -1;
+    }
+}  // end fatfs_update_dentry()
 ///////////////////////////////////////////////////////
 …
 assert( (inode_xp != XPTR_NULL) , "inode pointer is NULL\n" );
     // get first_cluster from inode extension
+    // get inode cluster and local pointer
     inode_ptr     = GET_PTR( inode_xp );
     inode_cxy     = GET_CXY( inode_xp );
+    // get first_cluster from inode extension
     first_xp      = XPTR( inode_cxy , &inode_ptr->extend );
     first_cluster = (uint32_t)(intptr_t)hal_remote_lpt( first_xp );
 …
 printk("\n[%s] thread[%x,%x] enter for <%s> / first_cluster %x / cycle %d\n",
 __FUNCTION__ , this->process->pid, this->trdid, name, first_cluster, cycle );
+#endif
+#if (DEBUG_FATFS_RELEASE_INODE & 1)
+fatfs_display_fat( 0 , 512 );
 #endif

trunk/kernel/fs/fatfs.h

-                      r614
+                      r623
 /*****************************************************************************************
+ * This function implements the generic vfs_fs_get_dentry() function for the FATFS.
+ *****************************************************************************************
+ * It initialises a new child (new inode/dentry couple in Inode Tree), identified
+ * by the <child_inode_xp> argument, from the parent directory mapper, identified by the
+ * <parent_inode> argument.
+ * This function implements the generic vfs_fs_new_dentry() function for the FATFS.
+ *****************************************************************************************
+ * It initializes a new inode/dentry couple in Inode Tree, attached to the directory
+ * identified by the <parent_inode> argument. The new directory entry is identified
+ * by the <name> argument. The child inode descriptor identified by the <child_inode_xp>
+ * argument, and the dentry descriptor must have been previously allocated.
  * It scan the parent mapper to find the <name> argument.
  * It set the "type", "size", and "extend" fields in inode descriptor.
 …
  * @ return 0 if success / return ENOENT if child not found.
  ****************************************************************************************/
 error_t fatfs_get_dentry( struct vfs_inode_s * parent_inode,
+error_t fatfs_new_dentry( struct vfs_inode_s * parent_inode,
                           char               * name,
                           xptr_t               child_inode_xp );
 /*****************************************************************************************
+ * This function implements the generic vfs_fs_update_dentry() function for the FATFS.
+ *****************************************************************************************
+ * It update the size of a directory entry identified by the <dentry> argument in
+ * the mapper of a directory identified by the <inode> argument, as defined by the <size>
+ * argument.
+ * It scan the mapper to find the entry identified by the dentry "name" field.
+ * It set the "size" field in the in the directory mapper AND marks the page as DIRTY.
+ * It must be called by a thread running in the cluster containing the directory inode.
+ *****************************************************************************************
+ * @ inode        : local pointer on inode (directory).
+ * @ dentry       : local pointer on dentry (for name).
+ * @ size         : new size value.
+ * @ return 0 if success / return ENOENT if child not found.
+ ****************************************************************************************/
+error_t fatfs_update_dentry( struct vfs_inode_s  * inode,
+                             struct vfs_dentry_s * dentry,
+                             uint32_t              size );
+/*****************************************************************************************
  * This function implements the generic vfs_fs_get_user_dir() function for the FATFS.
  *****************************************************************************************
  * It is called by the remote_dir_create() function to scan the mapper of a directory
  * identified by the <inode> argument and copy up to <max_dirent> valid dentries to a
+ * identified by the <inode> argument, and copy up to <max_dirent> valid dentries to a
  * local dirent array, defined by the <array> argument. The <min_dentry> argument defines
  * the index of the first dentry to copied to the target dirent array.
+ * the index of the first dentry to be copied to the target dirent array.
  * This function returns in the <entries> buffer the number of dentries actually written,
  * and signals in the <done> buffer when the last valid entry has been found.
  * If the <detailed> argument is true, a dentry/inode couple that does not exist in
  * the Inode Tree is dynamically created, and all dirent fiels are documented in the
+ * the Inode Tree is dynamically created, and all dirent fields are documented in the
  * dirent array. Otherwise, only the dentry name is documented.
  * It must be called by a thread running in the cluster containing the directory inode.
 …
  * The page - and the mapper - can be located in another cluster than the calling thread.
  * The pointer on the mapper and the page index in file are found in the page descriptor.
  * It is used for both for a regular file/directory mapper, and the FAT mapper.
+ * It is used for both a regular file/directory mapper, and the FAT mapper.
  * For the FAT mapper, it access the FATFS to get the location on IOC device.
  * For a regular file, it access the FAT mapper to get the cluster index on IOC device.

trunk/kernel/fs/ramfs.c

-                      r602
+                      r623
                      char   * ramfs_root_name )
+{
+    xptr_t    unused_xp;   // required by vfs_add_child_in_parent()
+    xptr_t        dentry_xp;     // unused but required by vfs_add_child_in_parent()
+    xptr_t        inode_xp;
+    vfs_inode_t * inode_ptr;
     cxy_t     cxy = cluster_random_select();
 …
     // create VFS dentry and VFS inode for RAMFS root directory
     return  vfs_add_child_in_parent( cxy,
-                                     INODE_TYPE_DIR,
                                      FS_TYPE_RAMFS,
                                      parent_inode_xp,
                                      ramfs_root_name,
+                                     &unused_xp,
+                                     &unused_xp );
+                                     &dentry_xp,
+                                     &inode_xp );
+    // update inode type field
+    inode_ptr = GET_PTR( inode_xp );
+    inode_ptr->type = INODE_TYPE_DIR;
+}

trunk/kernel/fs/vfs.c

-                      r614
+                      r623
+ *
  * Author  Mohamed Lamine Karaoui (2015)
  *         Alain Greiner (2016,2017,2018)
+ *         Alain Greiner (2016,2017,2018,2019)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
 ////////////////////////////////////////////////////
 error_t vfs_inode_create( vfs_fs_type_t     fs_type,
-                          vfs_inode_type_t  inode_type,
                           uint32_t          attr,
                           uint32_t          rights,
 …
     // initialize inode descriptor
     inode->type       = inode_type;
+    inode->type       = INODE_TYPE_FILE;     // default value
     inode->inum       = inum;
     inode->attr       = attr;
 …
     mapper->inode     = inode;
-    // initialise threads waiting queue
-    // xlist_root_init( XPTR( local_cxy , &inode->wait_root ) );
     // initialize chidren dentries xhtab
     xhtab_init( &inode->children , XHTAB_DENTRY_TYPE );
 …
     vfs_inode_t * ptr = GET_PTR( inode_xp );
+    // build extended pointers on lock & size
+    xptr_t   lock_xp = XPTR( cxy , &ptr->size_lock );
+    xptr_t   size_xp = XPTR( cxy , &ptr->size );
+    // take lock in read mode
+    remote_rwlock_rd_acquire( lock_xp );
     // get size
+    remote_rwlock_rd_acquire( XPTR( cxy , &ptr->size_lock ) );
+    uint32_t size = hal_remote_l32( XPTR( cxy , &ptr->size ) );
+    remote_rwlock_rd_release( XPTR( cxy , &ptr->size_lock ) );
+    uint32_t size = hal_remote_l32( size_xp );
+    // release lock from read mode
+    remote_rwlock_rd_release( lock_xp );
     return size;
+}
 ////////////////////////////////////////////
 void vfs_inode_set_size( xptr_t    inode_xp,
                          uint32_t  size )
+///////////////////////////////////////////////
+void vfs_inode_update_size( xptr_t    inode_xp,
+                            uint32_t  size )
+{
     // get inode cluster and local pointer
 …
     vfs_inode_t * ptr = GET_PTR( inode_xp );
+    // set size
+    remote_rwlock_wr_release( XPTR( cxy , &ptr->size_lock ) );
+    hal_remote_s32( XPTR( cxy , &ptr->size ) , size );
+    remote_rwlock_wr_release( XPTR( cxy , &ptr->size_lock ) );
+    // build extended pointers on lock & size
+    xptr_t   lock_xp = XPTR( cxy , &ptr->size_lock );
+    xptr_t   size_xp = XPTR( cxy , &ptr->size );
+    // take lock in write mode
+    remote_rwlock_wr_acquire( lock_xp );
+    // get current size
+    uint32_t current_size = hal_remote_l32( size_xp );
+    // set size if required
+    if( current_size < size ) hal_remote_s32( size_xp , size );
+    // release lock from write mode
+    remote_rwlock_wr_release( lock_xp );
+}
 …
 // check refcount
 assert( (file->refcount == 0) , "refcount non zero\n" );
+// assert( (file->refcount == 0) , "refcount non zero\n" );
         kmem_req_t req;
 …
 #if DEBUG_VFS_CLOSE
+char name[CONFIG_VFS_MAX_NAME_LENGTH];
+vfs_file_get_name( XPTR( local_cxy , file ) , name );
 thread_t * this = CURRENT_THREAD;
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_VFS_CLOSE < cycle )
 printk("\n[%s] thread[%x,%x] deleted file %x in cluster %x / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, file, local_cxy, cycle );
+printk("\n[%s] thread[%x,%x] deleted file <%s> in cluster %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, name, local_cxy, cycle );
 #endif
 …
     hal_remote_atomic_add( XPTR( file_cxy , &file_ptr->refcount ) , -1 );
+}
+///////////////////////////////////////
+void vfs_file_get_name( xptr_t file_xp,
+                        char * name )
+{
+    // get cluster and local pointer on remote file
+    vfs_file_t * file_ptr = GET_PTR( file_xp );
+    cxy_t        file_cxy = GET_CXY( file_xp );
+    // get pointers on remote inode
+    vfs_inode_t * inode_ptr = hal_remote_lpt( XPTR( file_cxy , &file_ptr->inode ) );
+    xptr_t        inode_xp  = XPTR( file_cxy , inode_ptr );
+    // call the relevant function
+    vfs_inode_get_name( inode_xp , name );
+}
 //////////////////////////////////////////////////////////////////////////////////////////
 …
 }  // vfs_lseek()
 ///////////////////////////////////
+////////////////////////////////////
 error_t vfs_close( xptr_t   file_xp,
                    uint32_t file_id )
+{
+    cluster_t  * cluster;          // local pointer on local cluster
+    cxy_t        file_cxy;         // cluster containing the file descriptor.
+    vfs_file_t * file_ptr;         // local ponter on file descriptor
+    cxy_t        owner_cxy;        // process owner cluster
+    lpid_t       lpid;             // process local index
+    xptr_t       root_xp;          // root of list of process copies
+    xptr_t       lock_xp;          // lock protecting the list of copies
+    xptr_t       iter_xp;          // iterator on list of process copies
+    xptr_t       process_xp;       // extended pointer on one process copy
+    cxy_t        process_cxy;      // process copy cluster
+    process_t  * process_ptr;      // process copy local pointer
+// check arguments
+assert( (file_xp != XPTR_NULL) , "file_xp == XPTR_NULL\n" );
+assert( (file_id < CONFIG_PROCESS_FILE_MAX_NR) , "illegal file_id\n" );
+    cxy_t         file_cxy;         // cluster containing the file descriptor.
+    vfs_file_t  * file_ptr;         // local ponter on file descriptor
+    cxy_t         owner_cxy;        // process owner cluster
+    pid_t         pid;              // process identifier
+    lpid_t        lpid;             // process local index
+    xptr_t        root_xp;          // root of xlist (processes , or dentries)
+    xptr_t        lock_xp;          // lock protecting the xlist
+    xptr_t        iter_xp;          // iterator on xlist
+    mapper_t    * mapper_ptr;       // local pointer on associated mapper
+    xptr_t        mapper_xp;        // extended pointer on mapper
+    vfs_inode_t * inode_ptr;        // local pointer on associated inode
+    xptr_t        inode_xp;         // extended pointer on inode
+    uint32_t      size;             // current file size (from inode descriptor)
+    error_t       error;
+    char          name[CONFIG_VFS_MAX_NAME_LENGTH];  // file name
+// check argument
+assert( (file_xp != XPTR_NULL) , "file_xp is XPTR_NULL\n" );
     thread_t  * this    = CURRENT_THREAD;
     process_t * process = this->process;
+    cluster_t * cluster = LOCAL_CLUSTER;
+    // get file name
+    vfs_file_get_name( file_xp , name );
 #if DEBUG_VFS_CLOSE
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_VFS_CLOSE < cycle )
+printk("\n[%s] thread[%x,%x] enter / fdid %d / cycle %d\n",
+__FUNCTION__, process->pid, this->trdid, file_id, cycle );
+#endif
+    // get local pointer on local cluster manager
+    cluster = LOCAL_CLUSTER;
+printk("\n[%s] thread[%x,%x] enter for <%s> / cycle %d\n",
+__FUNCTION__, process->pid, this->trdid, name, cycle );
+#endif
+    // get cluster and local pointer on remote file descriptor
+    file_cxy = GET_CXY( file_xp );
+    file_ptr = GET_PTR( file_xp );
+    //////// 1) update all dirty pages from mapper to device
+    // get pointers on mapper associated to file
+    mapper_ptr = hal_remote_lpt( XPTR( file_cxy , &file_ptr->mapper ) );
+    mapper_xp  = XPTR( file_cxy , mapper_ptr );
+    // copy all dirty pages from mapper to device
+    if( file_cxy == local_cxy )
+    {
+        error = mapper_sync( mapper_ptr );
+    }
+    else
+    {
+        rpc_mapper_sync_client( file_cxy,
+                                mapper_ptr,
+                                &error );
+    }
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot synchronise dirty pages for <%s>\n",
+        __FUNCTION__, name );
+        return -1;
+    }
+#if DEBUG_VFS_CLOSE
+if( DEBUG_VFS_CLOSE < cycle )
+printk("\n[%s] thread[%x,%x] synchronised mapper of <%s> to device\n",
+__FUNCTION__, process->pid, this->trdid, name );
+#endif
+    //////// 2) update file size in all parent directory mapper(s) and on device
+    // get pointers on remote inode
+    inode_ptr = hal_remote_lpt( XPTR( file_cxy , &file_ptr->inode ) );
+    inode_xp  = XPTR( file_cxy , inode_ptr );
+    // get file size from remote inode
+    size = hal_remote_l32( XPTR( file_cxy , &inode_ptr->size ) );
+    // get root of list of parents dentry
+    root_xp = XPTR( file_cxy , &inode_ptr->parents );
+    // loop on all parents
+    XLIST_FOREACH( root_xp , iter_xp )
+    {
+        // get pointers on parent directory dentry
+        xptr_t         parent_dentry_xp  = XLIST_ELEMENT( iter_xp , vfs_dentry_t , parents );
+        cxy_t          parent_cxy        = GET_CXY( parent_dentry_xp );
+        vfs_dentry_t * parent_dentry_ptr = GET_PTR( parent_dentry_xp );
+        // get local pointer on parent directory inode
+        vfs_inode_t * parent_inode_ptr = hal_remote_lpt( XPTR( parent_cxy,
+                                                         &parent_dentry_ptr->parent ) );
+        // get local pointer on parent directory mapper
+        mapper_t * parent_mapper_ptr = hal_remote_lpt( XPTR( parent_cxy,
+                                                       &parent_inode_ptr->mapper ) );
+        // update dentry size in parent directory mapper
+        if( parent_cxy == local_cxy )
+        {
+            error = vfs_fs_update_dentry( parent_inode_ptr,
+                                          parent_dentry_ptr,
+                                          size );
+        }
+        else
+        {
+            rpc_vfs_fs_update_dentry_client( parent_cxy,
+                                             parent_inode_ptr,
+                                             parent_dentry_ptr,
+                                             size,
+                                             &error );
+        }
+        if( error )
+        {
+            printk("\n[ERROR] in %s : cannot update size in parent\n",
+            __FUNCTION__ );
+            return -1;
+        }
+#if DEBUG_VFS_CLOSE
+char parent_name[CONFIG_VFS_MAX_NAME_LENGTH];
+vfs_inode_get_name( XPTR( parent_cxy , parent_inode_ptr ) , parent_name );
+if( DEBUG_VFS_CLOSE < cycle )
+printk("\n[%s] thread[%x,%x] updated size of <%s> in parent <%s>\n",
+__FUNCTION__, process->pid, this->trdid, name, parent_name );
+#endif
+        // copy all dirty pages from parent mapper to device
+        if( parent_cxy == local_cxy )
+        {
+            error = mapper_sync( parent_mapper_ptr );
+        }
+        else
+        {
+            rpc_mapper_sync_client( parent_cxy,
+                                    parent_mapper_ptr,
+                                    &error );
+        }
+        if( error )
+        {
+            printk("\n[ERROR] in %s : cannot synchronise parent mapper to device\n",
+            __FUNCTION__ );
+            return -1;
+        }
+#if DEBUG_VFS_CLOSE
+if( DEBUG_VFS_CLOSE < cycle )
+printk("\n[%s] thread[%x,%x] synchonized mapper of parent <%s> to device\n",
+__FUNCTION__, process->pid, this->trdid, parent_name );
+#endif
+    }
+    //////// 3) loop on the process copies to reset all fd_array[file_id] entries
     // get owner process cluster and lpid
+    owner_cxy  = CXY_FROM_PID( process->pid );
+    lpid       = LPID_FROM_PID( process->pid );
+    pid        = process->pid;
+    owner_cxy  = CXY_FROM_PID( pid );
+    lpid       = LPID_FROM_PID( pid );
     // get extended pointers on copies root and lock
 …
     lock_xp = XPTR( owner_cxy , &cluster->pmgr.copies_lock[lpid] );
-    // 1) loop on the process descriptor copies to reset all fd_array[file_id] entries
     // take the lock protecting the list of copies
     remote_queuelock_acquire( lock_xp );
 …
     XLIST_FOREACH( root_xp , iter_xp )
+    {
+        process_xp  = XLIST_ELEMENT( iter_xp , process_t , copies_list );
+        process_cxy = GET_CXY( process_xp );
+        process_ptr = GET_PTR( process_xp );
+#if (DEBUG_VFS_CLOSE & 1 )
+if( DEBUG_VFS_CLOSE < cycle )
+printk("\n[%s]  reset fd_array[%d] for process %x in cluster %x\n",
+__FUNCTION__, file_id, process_ptr, process_cxy );
+#endif
+// fd_array lock is required for atomic write of a 64 bits word
+// xptr_t fd_array_lock_xp = XPTR( process_cxy , &process_ptr->fd_array.lock );
+        xptr_t entry_xp         = XPTR( process_cxy , &process_ptr->fd_array.array[file_id] );
+// remote_rwlock_wr_acquire( fd_array_lock_xp );
+        xptr_t      process_xp  = XLIST_ELEMENT( iter_xp , process_t , copies_list );
+        cxy_t       process_cxy = GET_CXY( process_xp );
+        process_t * process_ptr = GET_PTR( process_xp );
+        xptr_t entry_xp = XPTR( process_cxy , &process_ptr->fd_array.array[file_id] );
         hal_remote_s64( entry_xp , XPTR_NULL );
-// remote_rwlock_wr_release( fd_array_lock_xp );
         vfs_file_count_down( file_xp );
         hal_fence();
+    }
 …
     remote_queuelock_release( lock_xp );
 #if (DEBUG_VFS_CLOSE & 1)
+#if DEBUG_VFS_CLOSE
 if( DEBUG_VFS_CLOSE < cycle )
+printk("\n[%s] thread[%x,%x] reset all fd-array copies\n",
+__FUNCTION__, process->pid, this->trdid );
+#endif
+    // 2) release memory allocated to file descriptor in remote cluster
+    // get cluster and local pointer on remote file descriptor
+    file_cxy = GET_CXY( file_xp );
+    file_ptr = GET_PTR( file_xp );
+printk("\n[%s] thread[%x,%x] reset all fd-array copies for <%x>\n",
+__FUNCTION__, process->pid, this->trdid, name );
+#endif
+    //////// 4) release memory allocated to file descriptor in remote cluster
     if( file_cxy == local_cxy )             // file cluster is local
 …
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_VFS_CLOSE < cycle )
 printk("\n[%s] thread[%x,%x] exit / fdid %d closed / cycle %d\n",
 __FUNCTION__, process->pid, this->trdid, file_id, cycle );
+printk("\n[%s] thread[%x,%x] exit / <%s> closed / cycle %d\n",
+__FUNCTION__, process->pid, this->trdid, name, cycle );
 #endif
 …
+    {
         error = vfs_inode_create( parent_fs_type,
-                                  INODE_TYPE_DIR,
                                   attr,
                                   rights,
 …
         rpc_vfs_inode_create_client( inode_cxy,
                                      parent_fs_type,
-                                     INODE_TYPE_DIR,
                                      attr,
                                      rights,
 …
     // get new inode local pointer
     inode_ptr = GET_PTR( inode_xp );
+    // update inode "type" field
+    hal_remote_s32( XPTR( inode_cxy , &inode_ptr->type ) , INODE_TYPE_DIR );
 #if(DEBUG_VFS_MKDIR & 1)
 …
     xptr_t            dentry_xp;          // extended pointer on dentry to unlink
     vfs_dentry_t    * dentry_ptr;         // local pointer on dentry to unlink
+    vfs_ctx_t       * ctx_ptr;            // local pointer on FS context
+    vfs_fs_type_t     fs_type;            // File system type
     char              name[CONFIG_VFS_MAX_NAME_LENGTH];  // name of link to remove
 …
 vfs_inode_get_name( root_xp , root_name );
 if( DEBUG_VFS_UNLINK < cycle )
 printk("\n[%s] thread[%x,%x] enter / root <%s> / path <%s> / cycle %d\n",
+printk("\n[%s] thread[%x,%x] : enter for root <%s> / path <%s> / cycle %d\n",
 __FUNCTION__, process->pid, this->trdid, root_name, path, cycle );
 #endif
 …
 vfs_inode_get_name( parent_xp , parent_name );
 if( DEBUG_VFS_UNLINK < cycle )
 printk("\n[%s] thread[%x,%x] parent inode <%s> is (%x,%x)\n",
+printk("\n[%s] thread[%x,%x] : parent inode <%s> is (%x,%x)\n",
 __FUNCTION__, process->pid, this->trdid, parent_name, parent_cxy, parent_ptr );
 #endif
 …
     xptr_t children_xp = XPTR( parent_cxy , &parent_ptr->children );
     // get extended pointer on dentry to unlink
+    // try to get extended pointer on dentry from Inode Tree
     dentry_xp = xhtab_lookup( children_xp , name );
+    if( dentry_xp == XPTR_NULL )
+    {
+        remote_rwlock_wr_release( lock_xp );
+        printk("\n[ERROR] in %s : cannot get target dentry <%s> in <%s>\n",
+        __FUNCTION__, name, path );
+        return -1;
+    }
+    // get local pointer on dentry to unlink
+    dentry_ptr = GET_PTR( dentry_xp );
+    // when dentry not found in Inode Tree, try to get it from inode tree
+    if( dentry_xp == XPTR_NULL )           // miss target dentry in Inode Tree
+    {
 #if( DEBUG_VFS_UNLINK & 1 )
 if( DEBUG_VFS_UNLINK < cycle )
+printk("\n[%s] thread[%x,%x] dentry <%s> to unlink is (%x,%x)\n",
+__FUNCTION__, process->pid, this->trdid, name, parent_cxy, dentry_ptr );
+#endif
+    // get pointer on target inode
+    inode_xp  = hal_remote_l64( XPTR( parent_cxy , &dentry_ptr->child_xp ) );
+    inode_cxy = GET_CXY( inode_xp );
+    inode_ptr = GET_PTR( inode_xp );
+printk("\n[%s] thread[%x,%x] : inode <%s> not found => scan parent mapper\n",
+__FUNCTION__, process->pid, this->trdid, name );
+#endif
+        // get parent inode FS type
+        ctx_ptr    = hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->ctx ) );
+        fs_type    = hal_remote_l32( XPTR( parent_cxy , &ctx_ptr->type ) );
+        // select a cluster for new inode
+        inode_cxy = cluster_random_select();
+        // speculatively insert a new child dentry/inode couple in inode tree
+        error = vfs_add_child_in_parent( inode_cxy,
+                                         fs_type,
+                                         parent_xp,
+                                         name,
+                                         &dentry_xp,
+                                         &inode_xp );
+        if( error )
+        {
+            printk("\n[ERROR] in %s : cannot create inode <%s> in path <%s>\n",
+            __FUNCTION__ , name, path );
+            vfs_remove_child_from_parent( dentry_xp );
+            return -1;
+        }
+        // get local pointers on new dentry and new inode descriptors
+        inode_ptr  = GET_PTR( inode_xp );
+        dentry_ptr = GET_PTR( dentry_xp );
+        // scan parent mapper to find the missing dentry, and complete
+        // initialisation of new dentry and new inode descriptors In Inode Tree
+        if( parent_cxy == local_cxy )
+        {
+            error = vfs_fs_new_dentry( parent_ptr,
+                                       name,
+                                       inode_xp );
+        }
+        else
+        {
+            rpc_vfs_fs_new_dentry_client( parent_cxy,
+                                          parent_ptr,
+                                          name,
+                                          inode_xp,
+                                          &error );
+        }
+        if ( error )   // dentry not found in parent mapper
+        {
+            printk("\n[ERROR] in %s : cannot get dentry <%s> in path <%s>\n",
+            __FUNCTION__ , name, path );
+            return -1;
+        }
+#if (DEBUG_VFS_UNLINK & 1)
+if( DEBUG_VFS_UNLINK < cycle )
+printk("\n[%s] thread[%x,%x] : created missing inode & dentry <%s> in cluster %x\n",
+__FUNCTION__, process->pid, this->trdid, name, inode_cxy );
+#endif
+    }
+    else                                  // found target dentry in Inode Tree
+    {
+        dentry_ptr = GET_PTR( dentry_xp );
+        // get pointer on target inode from dentry
+        inode_xp  = hal_remote_l64( XPTR( parent_cxy , &dentry_ptr->child_xp ) );
+        inode_cxy = GET_CXY( inode_xp );
+        inode_ptr = GET_PTR( inode_xp );
+    }
+    // At this point the Inode Tree contains the target dentry and child inode
+    // we can safely remove this dentry from both the parent mapper, and the Inode Tree.
 #if( DEBUG_VFS_UNLINK & 1 )
-char inode_name[CONFIG_VFS_MAX_NAME_LENGTH];
-vfs_inode_get_name( inode_xp , inode_name );
 if( DEBUG_VFS_UNLINK < cycle )
 printk("\n[%s] thread[%x,%x] target inode <%s> is (%x,%x) / cycle %d\n",
 __FUNCTION__, process->pid, this->trdid, inode_name, inode_cxy, inode_ptr, cycle );
+printk("\n[%s] thread[%x,%x] : dentry (%x,%x) / inode (%x,%x)\n",
+__FUNCTION__, process->pid, this->trdid, parent_cxy, dentry_ptr, inode_cxy, inode_ptr );
 #endif
 …
     inode_links  = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->links ) );
-// check target inode links counter
-assert( (inode_links >= 1), "illegal inode links count %d for <%s>\n", inode_links, path );
     ///////////////////////////////////////////////////////////////////////
     if( (inode_type == INODE_TYPE_FILE) || (inode_type == INODE_TYPE_DIR) )
+    {
+#if( DEBUG_VFS_UNLINK & 1 )
+if( DEBUG_VFS_UNLINK < cycle )
+printk("\n[%s] thread[%x,%x] : unlink inode <%s> / type %s / %d links\n",
+__FUNCTION__, process->pid, this->trdid, name, vfs_inode_type_str(inode_type), inode_links );
+#endif
         // 1. Release clusters allocated to target inode
         //    and synchronize the FAT on IOC device if last link.
 …
             // build extended pointer on target inode "children" number
             xptr_t inode_children_xp = XPTR( inode_cxy , &inode_ptr->children.items );
+printk("\n@@@ in %s : children_xp = (%x,%x)\n",
+__FUNCTION__, inode_cxy, &inode_ptr->children.items );
             // get target inode number of children
 …
 }  // end vfs_stat()
-/////////////////////////////////////////////
-error_t vfs_readdir( xptr_t          file_xp,
-                     struct dirent * k_dirent )
+{
-    assert( false , "not implemented file_xp: %x, k_dirent ptr %x\n",
-      file_xp, k_dirent );
-    return 0;
+}
-////////////////////////////////////
-error_t vfs_rmdir( xptr_t   file_xp,
-                   char   * path )
+{
-    assert( false , "not implemented file_xp: %x, path <%s>\n",
-      file_xp, path );
-    return 0;
+}
 ////////////////////////////////////
 …
     cxy_t              child_cxy;    // cluster for child inode
     vfs_inode_t      * child_ptr;    // local pointer on child inode
-    vfs_inode_type_t   child_type;   // child inode type
     vfs_fs_type_t      fs_type;      // File system type
     vfs_ctx_t        * ctx_ptr;      // local pointer on FS context
 …
                 child_cxy = cluster_random_select();
-                // define child inode type
-                if( dir ) child_type = INODE_TYPE_DIR;
-                else      child_type = INODE_TYPE_FILE;
                 // insert a new child dentry/inode couple in inode tree
                 error = vfs_add_child_in_parent( child_cxy,
-                                                 child_type,
                                                  fs_type,
                                                  parent_xp,
 …
                 if( parent_cxy == local_cxy )
+                {
                     error = vfs_fs_get_dentry( parent_ptr,
+                    error = vfs_fs_new_dentry( parent_ptr,
                                                name,
                                                child_xp );
 …
                 else
+                {
                     rpc_vfs_fs_get_dentry_client( parent_cxy,
+                    rpc_vfs_fs_new_dentry_client( parent_cxy,
                                                   parent_ptr,
                                                   name,
 …
 ////////////////////////////////////////////////////////////////////
 error_t vfs_add_child_in_parent( cxy_t              child_cxy,
-                                 vfs_inode_type_t   child_type,
                                  vfs_fs_type_t      fs_type,
                                  xptr_t             parent_inode_xp,
 …
+    {
         error = vfs_inode_create( fs_type,
-                                  child_type,
                                   attr,
                                   mode,
 …
         rpc_vfs_inode_create_client( child_cxy,
                                      fs_type,
-                                     child_type,
                                      attr,
                                      mode,
 …
 ////////////////////////////////////////////////
 error_t vfs_fs_get_dentry( vfs_inode_t * parent,
+error_t vfs_fs_new_dentry( vfs_inode_t * parent,
                            char        * name,
                            xptr_t        child_xp )
 …
     if( fs_type == FS_TYPE_FATFS )
+    {
         error = fatfs_get_dentry( parent , name , child_xp );
+        error = fatfs_new_dentry( parent , name , child_xp );
+    }
     else if( fs_type == FS_TYPE_RAMFS )
 …
     return error;
+} // end vfs_fs_get_dentry()
+} // end vfs_fs_new_dentry()
+///////////////////////////////////////////////////
+error_t vfs_fs_update_dentry( vfs_inode_t  * inode,
+                              vfs_dentry_t * dentry,
+                              uint32_t       size )
+{
+    error_t error = 0;
+// check arguments
+assert( (inode  != NULL) , "inode  pointer is NULL\n");
+assert( (dentry != NULL) , "dentry pointer is NULL\n");
+    // get parent inode FS type
+    vfs_fs_type_t fs_type = inode->ctx->type;
+    // call relevant FS function
+    if( fs_type == FS_TYPE_FATFS )
+    {
+        error = fatfs_update_dentry( inode , dentry , size );
+    }
+    else if( fs_type == FS_TYPE_RAMFS )
+    {
+        assert( false , "should not be called for RAMFS\n" );
+    }
+    else if( fs_type == FS_TYPE_DEVFS )
+    {
+        assert( false , "should not be called for DEVFS\n" );
+    }
+    else
+    {
+        assert( false , "undefined file system type\n" );
+    }
+    return error;
+} // end vfs_fs_update_dentry()
 ///////////////////////////////////////////////////

trunk/kernel/fs/vfs.h

-                      r614
+                      r623
 /******************************************************************************************
  * This structure define a VFS inode.
  * An inode has several children dentries (if it is a directory), an can have several
+ * An inode can have several children dentries (if it is a directory), an can have several
  * parents dentries (if it hass several aliases links):
  * - The "parents" field is the root of the xlist of parents dentries, and the "links"
 …
         remote_rwlock_t    size_lock;        /*! protect read/write to size                  */
         remote_rwlock_t    main_lock;        /*! protect inode tree traversal and modifs     */
-//  list_entry_t       list;             /*! member of set of inodes in same cluster     */
-//  list_entry_t       wait_root;        /*! root of threads waiting on this inode       */
         struct mapper_s  * mapper;           /*! associated file cache                       */
         void             * extend;           /*! fs_type_specific inode extension            */
 …
 /******************************************************************************************
  * This structure defines a directory entry.
+ Rpt* This structure defines a directory entry.
  * A dentry contains the name of a remote file/dir, an extended pointer on the
  * inode representing this file/dir, a local pointer on the inode representing
 …
  *****************************************************************************************/
 error_t vfs_inode_create( vfs_fs_type_t     fs_type,
-                          vfs_inode_type_t  inode_type,
                           uint32_t          attr,
                           uint32_t          rights,
 …
 /******************************************************************************************
+ * This function set the <size> of a file/dir to a remote inode,
+ * taking the remote_rwlock protecting <size> in WRITE_MODE.
+ * This function updates the "size" field of a remote inode identified by <inode_xp>.
+ * It takes the rwlock protecting the file size in WRITE_MODE, and set the "size" field
+ * when the current size is smaller than the requested <size> argument.
  *****************************************************************************************
  * @ inode_xp  : extended pointer on the remote inode.
  * @ size      : value to be written.
  *****************************************************************************************/
 void vfs_inode_set_size( xptr_t   inode_xp,
                          uint32_t size );
+ * @ size      : requested size value.
+ *****************************************************************************************/
+void vfs_inode_update_size( xptr_t   inode_xp,
+                            uint32_t size );
 /******************************************************************************************
 …
  * This function releases memory allocated to a local file descriptor.
  * It must be executed by a thread running in the cluster containing the inode,
+ * and the file refcount must be zero.
+ * If the client thread is not running in the owner cluster, it must use the
+ * rpc_vfs_file_destroy_client() function.
+ * and the file refcount must be zero. Use the RPC_VFS_FILE_DESTROY if required.
  ******************************************************************************************
  * @ file  : local pointer on file descriptor.
 …
 void vfs_file_count_up  ( xptr_t   file_xp );
 void vfs_file_count_down( xptr_t   file_xp );
+/******************************************************************************************
+ * This debug function copies the name of a the file identified by <file_xp>
+ * argument to a local buffer identified by the <name> argument.
+ * The local buffer size must be at least CONFIG_VFS_MAX_NAME_LENGTH.
+ *****************************************************************************************
+ * @ file_xp  : extended pointer on the remote inode.
+ * @ name     : local buffer pointer.
+ *****************************************************************************************/
+void vfs_file_get_name( xptr_t inode_xp,
+                        char * name );
 …
  * Only the distributed Inode Tree is modified: it does NOT modify the parent mapper,
  * and does NOT update the FS on IOC device.
+ * It set the inode type to the default INODE_TYPE_FILE value
  * It can be executed by any thread running in any cluster (can be different from both
  * the child cluster and the parent cluster).
 …
  ******************************************************************************************
  * @ child_inode_cxy  : [in]  target cluster for child inode.
- * @ child_inode_type : [in]  child inode type
  * @ fs_type          : [in]  child inode FS type.
  * @ parent_inode_xp  : [in]  extended pointer on parent inode.
 …
  *****************************************************************************************/
 error_t vfs_add_child_in_parent( cxy_t              child_inode_cxy,
-                                 vfs_inode_type_t   child_inode_type,
                                  vfs_fs_type_t      fs_type,
                                  xptr_t             parent_inode_xp,
 …
 /******************************************************************************************
  * This function close the - non-replicated - file descriptor identified by the <file_xp>
+ * and <file_id> arguments.
+ * 1) All entries in the fd_array copies are directly reset by the calling thread,
+ * and <file_id> arguments. The <file_id> is required to reset the fd_array[] slot.
+ * It can be called by a thread running in any cluster, and executes the following actions:
+ * 1) It access the block device to updates all dirty pages from the mapper associated
+ *    to the file, and removes these pages from the dirty list, using an RPC if required.
+ * 2) It updates the file size in all parent directory mapper(s), and update the modified
+ *    pages on the block device, using RPCs if required.
+ * 3) All entries in the fd_array copies are directly reset by the calling thread,
  *    using remote accesses.
  * 2) The memory allocated to file descriptor in cluster containing the inode is released.
  *    It requires a RPC if cluster containing the file descriptor is remote.
  ******************************************************************************************
  * @ file_xp     : extended pointer on the file descriptor in owner cluster.
  * @ file_id     : file descriptor index in fd_array.
+ * 4) The memory allocated to file descriptor in cluster containing the inode is released,
+ *    using an RPC if cluster containing the file descriptor is remote.
+ ******************************************************************************************
+ * @ file_xp     : extended pointer on the file descriptor.
+ * @ file_id     : file descriptor index in fd_array[].
  * @ returns 0 if success / -1 if error.
  *****************************************************************************************/
 …
 /******************************************************************************************
  * This function makes the I/O operation to move one page identified by the <page_xp>
  * argument to/from the IOC device from/to the mapper, as defined by <cmd_type>.
+ * argument to/from the IOC device from/to the mapper, as defined by the <cmd_type>.
  * Depending on the file system type, it calls the proper, FS specific function.
  * It is used in case of MISS on the mapper, or when a dirty page in the mapper must
 …
  * Finally, it synchronously updates the parent directory on IOC device.
+ *
+ * Depending on the file system type, it calls the relevant, FS specific function.
  * It must be executed by a thread running in the cluster containing the parent directory.
  * It can be the RPC_VFS_VS_REMOVE_DENTRY. This function does NOT take any lock.
+ * It can be the RPC_VFS_FS_REMOVE_DENTRY. This function does NOT take any lock.
  ******************************************************************************************
  * @ parent  : local pointer on parent (directory) inode.
 …
  * and updates both the child inode descriptor, identified by the <child_xp> argument,
  * and the associated dentry descriptor :
  * - It set the "size", and "extend" fields in inode descriptor.
+ * - It set the "size", "type", and "extend" fields in inode descriptor.
  * - It set the "extend" field in dentry descriptor.
  * It is called by the vfs_lookup() function in case of miss.
 …
  * Depending on the file system type, it calls the relevant, FS specific function.
  * It must be called by a thread running in the cluster containing the parent inode.
  * This function does NOT take any lock.
+ * It can be the RPC_VFS_FS_NEW_DENTRY. This function does NOT take any lock.
  ******************************************************************************************
  * @ parent    : local pointer on parent inode (directory).
  * @ name      : child name.
  * @ child_xp  : extended pointer on remote child inode (file or directory)
  * @ return 0 if success / return ENOENT if not found.
  *****************************************************************************************/
 error_t vfs_fs_get_dentry( vfs_inode_t * parent,
+ * @ return 0 if success / return -1 if dentry not found.
+ *****************************************************************************************/
+error_t vfs_fs_new_dentry( vfs_inode_t * parent,
                            char        * name,
                            xptr_t        child_xp );
+/******************************************************************************************
+ * This function scan the mapper of an an existing inode directory, identified by
+ * the <inode> argument, to find a directory entry identified by the <dentry> argument,
+ * and update the size for this directory entry in mapper, as defined by <size>.
+ * The searched "name" is defined in the <dentry> argument, that must be in the same
+ * cluster as the parent inode. It is called by the vfs_close() function.
+ *
+ * Depending on the file system type, it calls the relevant, FS specific function.
+ * It must be called by a thread running in the cluster containing the parent inode.
+ * It can be the RPC_VFS_FS_UPDATE_DENTRY. This function does NOT take any lock.
+ ******************************************************************************************
+ * @ parent    : local pointer on parent inode (directory).
+ * @ dentry    : local pointer on dentry.
+ * @ size      : new size value (bytes).
+ * @ return 0 if success / return ENOENT if not found.
+ *****************************************************************************************/
+error_t vfs_fs_update_dentry( vfs_inode_t  * inode,
+                              vfs_dentry_t * dentry,
+                              uint32_t       size );
 /******************************************************************************************

trunk/kernel/kern/kernel_init.c

-                      r619
+                      r623
+ *
  * Authors :  Mohamed Lamine Karaoui (2015)
  *            Alain Greiner  (2016,2017,2018)
+ *            Alain Greiner  (2016,2017,2018,2019)
+ *
  * Copyright (c) Sorbonne Universites
 …
 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;
 …
 // 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 );
 …
 // 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.
 …
 ///////////////////////////////////////////////////////////////////////////////////////////
 // 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).
 …
 ///////////////////////////////////////////////////////////////////////////////////////////
 // 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
 …
 ///////////////////////////////////////////////////////////////////////////////////////////
 // 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.
 …
     /////////////////////////////////////////////////////////////////////////////////
     // 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.
     /////////////////////////////////////////////////////////////////////////////////
 …
                                   &core_gid );
     // all CP0s initialize cluster identifier
+    // core[0] initialize cluster identifier
     if( core_lid == 0 ) local_cxy = info->cxy;
 …
 #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();
+    }
     /////////////////////////////////////////////////////////////////////////////////
 …
 #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 )
+    {
 …
 #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)
     /////////////////////////////////////////////////////////////////////////////////
 …
     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 );
 …
 #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.
 …
 #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
 …
     /////////////////////////////////////////////////////////////////////////////////
     // 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.
     /////////////////////////////////////////////////////////////////////////////////
 …
 #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 ) )
+    {
 …
             // 4. create VFS root inode in cluster 0
             error = vfs_inode_create( FS_TYPE_FATFS,                       // fs_type
-                                      INODE_TYPE_DIR,                      // inode_type
 ,                                   // attr
 ,                                   // rights
 …
+            }
             // 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 );
 …
 #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() );
 …
     /////////////////////////////////////////////////////////////////////////////////
     // 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.
     /////////////////////////////////////////////////////////////////////////////////
 …
 #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() );
 …
     /////////////////////////////////////////////////////////////////////////////////
     // 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.
 …
 #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).
     /////////////////////////////////////////////////////////////////////////////////
 …
 #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)
 …
 #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"
 …
 #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
 …
     /////////////////////////////////////////////////////////////////////////////////
 #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

-                      r583
+                      r623
     va_list    args;      // printf arguments
     uint32_t   ps;        // write pointer to the string buffer
+    uint32_t   ps;        // pointer to the string buffer
     ps = 0;
 …
     while ( *format != 0 )
+    {
         if (*format == '%')   // copy argument to string
+        {
 …
                 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 );
 …
                 for(i = 0; i < 10; i++)
+                {
                     buf[9 - i] = HexaTab[val % 10];
                     if (!(val /= 10)) break;
 …
                 break;
+            }
             case ('u'):             // decimal unsigned integer
+            case ('u'):             // up to 10 digits decimal unsigned integer
+            {
                 uint32_t val = va_arg( args, uint32_t );
 …
                 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;
 …
                 break;
+            }
             case ('X'):             // 32 bits hexadecimal on 8 characters
+            case ('X'):             // exactly 8 digits hexadecimal
+            {
                 uint32_t val = va_arg( args , uint32_t );
 …
             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 );
 …
                 break;
+            }
             case ('u'):             /* 32 bits decimal unsigned  */
+            case ('u'):             /* up to 10 digits unsigned decimal */
+            {
                 uint32_t val = va_arg( *args , uint32_t );
 …
                 break;
+            }
             case ('x'):             /* 32 bits hexadecimal unsigned */
+            case ('x'):             /* up to 8 digits hexadecimal */
+            {
                 uint32_t val = va_arg( *args , uint32_t );
 …
                 break;
+            }
             case ('X'):             /* 32 bits hexadecimal unsigned  on 10 char */
+            case ('X'):             /* exactly 8 digits hexadecimal */
+            {
                 uint32_t val = va_arg( *args , uint32_t );
 …
                 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++)
 …
                 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++)
 …
+}
+/////////////////////////////
+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

-                      r583
+                      r623
 ///////////////////////////////////////////////////////////////////////////////////
 // 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.
 ///////////////////////////////////////////////////////////////////////////////////
 …
 #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
  **********************************************************************************
 …
 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

-                      r619
+                      r623
 #include <hal_uspace.h>
 #include <hal_irqmask.h>
+#include <hal_vmm.h>
 #include <errno.h>
 #include <printk.h>
 …
+    }
+    // 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]
 …
         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;
+    }
 …
                 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;
+        }
 …
+///////////////////////////////////////////////
+void process_zero_create( process_t * process )
+////////////////////////////////////////////////
+void process_zero_create( process_t   * process,
+                          boot_info_t * info )
+{
     error_t error;
 …
     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

-                      r618
+                      r623
  * 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
 …
  *       - 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.
 …
 /*********************************************************************************************
  * 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 );
 /*********************************************************************************************
 …
  * 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

-                      r619
+                      r623
  * rpc.c - RPC operations implementation.
+ *
  * Author    Alain Greiner (2016,2017,2018)
+ * Author    Alain Greiner (2016,2017,2018,2019)
+ *
  * Copyright (c)  UPMC Sorbonne Universites
 …
     &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
 …
     &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
 …
     &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
 …
     "THREAD_USER_CREATE",        // 6
     "THREAD_KERNEL_CREATE",      // 7
     "undefined",                 // 8
+    "VFS_FS_UPDATE_DENTRY",      // 8
     "PROCESS_SIGACTION",         // 9
 …
     "KCM_ALLOC",                 // 22
     "KCM_FREE",                  // 23
     "undefined",                 // 24
+    "MAPPER_SYNC",               // 24
     "MAPPER_HANDLE_MISS",        // 25
     "VMM_DELETE_VSEG",           // 26
 …
 /////////////////////////////////////////////////////////////////////////////////////////
 // [7]      Marshaling functions attached to RPC_THREAD_KERNEL_CREATE (blocking)
+// [7]      Marshaling functions attached to RPC_THREAD_KERNEL_CREATE
 /////////////////////////////////////////////////////////////////////////////////////////
 …
 /////////////////////////////////////////////////////////////////////////////////////////
+// [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
+}
 /////////////////////////////////////////////////////////////////////////////////////////
 …
 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
 …
     // 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
 …
     // 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
 …
     uint32_t         fs_type;
-    uint32_t         inode_type;
     uint32_t         attr;
     uint32_t         rights;
 …
     // 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,
 …
     // 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
 …
 /////////////////////////////////////////////////////////
 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
 …
 //////////////////////////////////////////////
 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
 …
     // 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
 …
 /////////////////////////////////////////////////////////////////////////////////////////
+// [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

-                      r619
+                      r623
     RPC_THREAD_USER_CREATE        = 6,
     RPC_THREAD_KERNEL_CREATE      = 7,
     RPC_UNDEFINED_8               = 8,
+    RPC_VFS_FS_UPDATE_DENTRY      = 8,
     RPC_PROCESS_SIGACTION         = 9,
 …
     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,
 …
 /***********************************************************************************
+ * [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.
  ***********************************************************************************
 …
 void rpc_vfs_inode_create_client( cxy_t      cxy,
                                   uint32_t   fs_type,
-                                  uint32_t   inode_type,
                                   uint32_t   attr,
                                   uint32_t   rights,
 …
 /***********************************************************************************
  * [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
 …
  * @ 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,
 …
                                    error_t            * error );
 void rpc_vfs_fs_get_dentry_server( xptr_t xp );
+void rpc_vfs_fs_new_dentry_server( xptr_t xp );
 /***********************************************************************************
 …
 /***********************************************************************************
+ * [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

-                      r620
+                      r623
                                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 ) );
 …
     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()

trunk/kernel/kernel_config.h

-                      r620
+                      r623
 #define DEBUG_FATFS_FREE_CLUSTERS         0
 #define DEBUG_FATFS_GET_CLUSTER           0
-#define DEBUG_FATFS_GET_DENTRY            0
 #define DEBUG_FATFS_GET_USER_DIR          0
 #define DEBUG_FATFS_MOVE_PAGE             0
+#define DEBUG_FATFS_RELEASE_INODE         0
+#define DEBUG_FATFS_NEW_DENTRY            0
+#define DEBUG_FATFS_RELEASE_INODE         1
 #define DEBUG_FATFS_REMOVE_DENTRY         0
 #define DEBUG_FATFS_SYNC_FAT              0
 #define DEBUG_FATFS_SYNC_FSINFO           0
 #define DEBUG_FATFS_SYNC_INODE            0
+#define DEBUG_FATFS_UPDATE_DENTRY         0
 #define DEBUG_HAL_GPT_SET_PTE             0
 …
 #define DEBUG_MAPPER_MOVE_USER            0
 #define DEBUG_MAPPER_MOVE_KERNEL          0
+#define DEBUG_MAPPER_SYNC                 0
 #define DEBUG_MUTEX                       0
 …
 #define DEBUG_PROCESS_ZERO_CREATE         0
 #define DEBUG_QUEUELOCK_TYPE              0    // lock type (0 is undefined)
+#define DEBUG_QUEUELOCK_TYPE              0    // lock type (0 : undefined / 1000 : all types)
 #define DEBUG_RPC_CLIENT_GENERIC          0
 …
 #define DEBUG_RPC_VMM_DELETE_VSEG         0
 #define DEBUG_RWLOCK_TYPE                 0    // lock type (0 is undefined)
+#define DEBUG_RWLOCK_TYPE                 0    // lock type (0 : undefined / 1000 : all types)
 #define DEBUG_SCHED_HANDLE_SIGNALS        2
 …
 #define DEBUG_VFS_OPENDIR                 0
 #define DEBUG_VFS_STAT                    0
 #define DEBUG_VFS_UNLINK                  0
+#define DEBUG_VFS_UNLINK                  1
 #define DEBUG_VMM_CREATE_VSEG             0
 …
 #define DEBUG_VMM_MMAP_ALLOC              0
 #define DEBUG_VMM_PAGE_ALLOCATE           0
+#define DEBUG_VMM_RESIZE_VSEG             0
 #define DEBUG_VMM_SET_COW                 0
 #define DEBUG_VMM_UPDATE_PTE              0

trunk/kernel/libk/busylock.h

-                      r563
+                      r623
  * a shared object located in a given cluster, made by thread(s) running in same cluster.
  * It uses a busy waiting policy when the lock is taken by another thread, and should
  * be used to execute very short actions, such as basic allocators, or to protect
  * higher level synchronisation objects, such as queuelock or rwlock.
  * WARNING: a thread cannot yield when it is owning a busylock (local or remote).
+ * be used to execute very short actions, such as accessing basic allocators, or higher
+ * level synchronisation objects (barriers, queuelocks, or rwlocks).
+ * WARNING: a thread cannot yield when it is owning a busylock.
+ *
  * - To acquire the lock, we use a ticket policy to avoid starvation: the calling thread

trunk/kernel/libk/grdxt.h

r610	r623
132	132	* @ start_key : key starting value for the scan.
133	133	* @ found_key : [out] buffer for found key value.
134		* return pointer on first valid item if found / return NULL if not found.
	134	* @ return pointer on first valid item if found / return NULL if not found.
135	135	******************************************************************************************/
136	136	void * grdxt_get_first( grdxt_t * rt,

trunk/kernel/libk/queuelock.c

-                      r610
+                      r623
     busylock_acquire( &lock->lock );
+#if DEBUG_QUEUELOCK_TYPE
+uint32_t   lock_type = lock->lock.type;
+#endif
     // block and deschedule if lock already taken
     while( lock->taken )
 …
 #if DEBUG_QUEUELOCK_TYPE
+uint32_t   lock_type = lock->lock.type;
+if( DEBUG_QUEUELOCK_TYPE == lock_type )
+if( (DEBUG_QUEUELOCK_TYPE == lock_type) || (DEBUG_QUEUELOCK_TYPE == 1000) )
 printk("\n[%s ] thread[%x,%x] BLOCK on q_lock %s [%x,%x]\n",
 __FUNCTION__, this->process->pid, this->trdid,
 …
 #if DEBUG_QUEUELOCK_TYPE
 if( DEBUG_QUEUELOCK_TYPE == lock_type )
+if( (DEBUG_QUEUELOCK_TYPE == lock_type) || (DEBUG_QUEUELOCK_TYPE == 1000) )
 printk("\n[%s] thread[%x,%x] ACQUIRE q_lock %s [%x,%x]\n",
 __FUNCTION__, this->process->pid, this->trdid,
 …
 uint32_t   lock_type = lock->lock.type;
 thread_t * this      = CURRENT_THREAD;
 if( DEBUG_QUEUELOCK_TYPE == lock_type )
+if( (DEBUG_QUEUELOCK_TYPE == lock_type) || (DEBUG_QUEUELOCK_TYPE == 1000) )
 printk("\n[%s] thread[%x,%x] RELEASE q_lock %s [%x,%x]\n",
 __FUNCTION__, this->process->pid, this->trdid,
 …
 #if DEBUG_QUEUELOCK_TYPE
 if( DEBUG_QUEUELOCK_TYPE == lock_type )
+if( (DEBUG_QUEUELOCK_TYPE == lock_type) || (DEBUG_QUEUELOCK_TYPE == 1000) )
 printk("\n[%s] thread[%x,%x] UNBLOCK thread [%x,%x] / q_lock %s [%x,%x]\n",
 __FUNCTION__, this->process->pid, this->trdid, thread->process->pid, thread->trdid,

trunk/kernel/libk/remote_barrier.c

-                      r619
+                      r623
 }  // end generic_barrier_wait()
+/////////////////////////////////////////////////////
+void generic_barrier_display( xptr_t gen_barrier_xp )
+{
+    // get cluster and local pointer
+    generic_barrier_t * gen_barrier_ptr = GET_PTR( gen_barrier_xp );
+    cxy_t               gen_barrier_cxy = GET_CXY( gen_barrier_xp );
+    // get barrier type and extend pointer
+    bool_t  is_dqt = hal_remote_l32( XPTR( gen_barrier_cxy , &gen_barrier_ptr->is_dqt ) );
+    void  * extend = hal_remote_lpt( XPTR( gen_barrier_cxy , &gen_barrier_ptr->extend ) );
+    // buil extended pointer on the implementation specific barrier descriptor
+    xptr_t barrier_xp = XPTR( gen_barrier_cxy , extend );
+    // display barrier state
+    if( is_dqt ) dqt_barrier_display( barrier_xp );
+    else         simple_barrier_display( barrier_xp );
+}
 …
 }  // end simple_barrier_wait()
+/////////////////////////////////////////////////
+void simple_barrier_display( xptr_t  barrier_xp )
+{
+    // get cluster and local pointer on simple barrier
+    simple_barrier_t * barrier_ptr = GET_PTR( barrier_xp );
+    cxy_t              barrier_cxy = GET_CXY( barrier_xp );
+    // get barrier global parameters
+    uint32_t current  = hal_remote_l32( XPTR( barrier_cxy , &barrier_ptr->current ) );
+    uint32_t arity    = hal_remote_l32( XPTR( barrier_cxy , &barrier_ptr->arity   ) );
+    printk("\n***** simple barrier : %d arrived threads on %d *****\n",
+    current, arity );
+}   // end simple_barrier_display()
 …
 // check x_size and y_size arguments
 assert( (z <= 16) , "DQT dqth larger than (16*16)\n");
+assert( (z <= 16) , "DQT mesh size larger than (16*16)\n");
 // check RPC descriptor size
 …
 }  // end dqt_barrier_wait()
+////////////////////////////////////////////////////////////////////////////////////////////
+//          DQT static functions
+////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////
+// This recursive function decrements the distributed "count" variables,
+// traversing the DQT from bottom to root.
+// The last arrived thread reset the local node before returning.
+//////////////////////////////////////////////////////////////////////////////////////////
+static void dqt_barrier_increment( xptr_t  node_xp )
+{
+    uint32_t   expected;
+    uint32_t   sense;
+    uint32_t   arity;
+    thread_t * this = CURRENT_THREAD;
+    // get node cluster and local pointer
+    dqt_node_t * node_ptr = GET_PTR( node_xp );
+    cxy_t        node_cxy = GET_CXY( node_xp );
+    // build relevant extended pointers
+    xptr_t  arity_xp   = XPTR( node_cxy , &node_ptr->arity );
+    xptr_t  sense_xp   = XPTR( node_cxy , &node_ptr->sense );
+    xptr_t  current_xp = XPTR( node_cxy , &node_ptr->current );
+    xptr_t  lock_xp    = XPTR( node_cxy , &node_ptr->lock );
+    xptr_t  root_xp    = XPTR( node_cxy , &node_ptr->root );
+#if DEBUG_BARRIER_WAIT
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+uint32_t   level = hal_remote_l32( XPTR( node_cxy, &node_ptr->level ) );
+if( cycle > DEBUG_BARRIER_WAIT )
+printk("\n[%s] thread[%x,%x] increments DQT node(%d,%d,%d) / cycle %d\n",
+__FUNCTION__ , this->process->pid, this->trdid,
+HAL_X_FROM_CXY(node_cxy), HAL_Y_FROM_CXY(node_cxy), level );
+#endif
+    // get extended pointer on parent node
+    xptr_t  parent_xp  = hal_remote_l64( XPTR( node_cxy , &node_ptr->parent_xp ) );
+    // take busylock
+    remote_busylock_acquire( lock_xp );
+    // get sense and arity values from barrier descriptor
+    sense = hal_remote_l32( sense_xp );
+    arity = hal_remote_l32( arity_xp );
+    // compute expected value
+    expected = (sense == 0) ? 1 : 0;
+    // increment current number of arrived threads / get value before increment
+    uint32_t current = hal_remote_atomic_add( current_xp , 1 );
+    // last arrived thread reset the local node, makes the recursive call
+    // on parent node, and reactivates all waiting thread when returning.
+    // other threads block, register in queue, and deschedule.
+    if ( current == (arity - 1) )                        // last thread
+    {
+#if DEBUG_BARRIER_WAIT
+if( cycle > DEBUG_BARRIER_WAIT )
+printk("\n[%s] thread[%x,%x] reset DQT node(%d,%d,%d)\n",
+__FUNCTION__ , this->process->pid, this->trdid,
+HAL_X_FROM_CXY(node_cxy), HAL_Y_FROM_CXY(node_cxy), level );
+#endif
+        // reset the current node
+        hal_remote_s32( sense_xp   , expected );
+        hal_remote_s32( current_xp , 0 );
+        // release busylock protecting the current node
+        remote_busylock_release( lock_xp );
+        // recursive call on parent node when current node is not the root
+        if( parent_xp != XPTR_NULL) dqt_barrier_increment( parent_xp );
+        // unblock all waiting threads on this node
+        while( xlist_is_empty( root_xp ) == false )
+        {
+            // get pointers on first waiting thread
+            xptr_t     thread_xp  = XLIST_FIRST( root_xp , thread_t , wait_list );
+            cxy_t      thread_cxy = GET_CXY( thread_xp );
+            thread_t * thread_ptr = GET_PTR( thread_xp );
+#if (DEBUG_BARRIER_WAIT & 1)
+trdid_t     trdid   = hal_remote_l32( XPTR( thread_cxy , &thread_ptr->trdid ) );
+process_t * process = hal_remote_lpt( XPTR( thread_cxy , &thread_ptr->process ) );
+pid_t       pid     = hal_remote_l32( XPTR( thread_cxy , &process->pid ) );
+if( cycle > DEBUG_BARRIER_WAIT )
+printk("\n[%s] thread[%x,%x] unblock thread[%x,%x]\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, trdid );
+#endif
+            // remove waiting thread from queue
+            xlist_unlink( XPTR( thread_cxy , &thread_ptr->wait_list ) );
+            // unblock waiting thread
+            thread_unblock( thread_xp , THREAD_BLOCKED_USERSYNC );
+        }
+    }
+    else                                               // not the last thread
+    {
+        // get extended pointer on xlist entry from thread
+        xptr_t  entry_xp = XPTR( local_cxy , &this->wait_list );
+        // register calling thread in barrier waiting queue
+        xlist_add_last( root_xp , entry_xp );
+        // block calling thread
+        thread_block( XPTR( local_cxy , this ) , THREAD_BLOCKED_USERSYNC );
+        // release busylock protecting the remote_barrier
+        remote_busylock_release( lock_xp );
+#if DEBUG_BARRIER_WAIT
+if( cycle > DEBUG_BARRIER_WAIT )
+printk("\n[%s] thread[%x,%x] blocks on node(%d,%d,%d)\n",
+__FUNCTION__ , this->process->pid, this->trdid,
+HAL_X_FROM_CXY(node_cxy), HAL_Y_FROM_CXY(node_cxy), level );
+#endif
+        // deschedule
+        sched_yield("blocked on barrier");
+    }
+    return;
+} // end dqt_barrier_decrement()
+#if DEBUG_BARRIER_CREATE
+////////////////////////////////////////////////////////////////////////////////////////////
+// This debug function displays all DQT nodes in all clusters.
+////////////////////////////////////////////////////////////////////////////////////////////
+// @ barrier_xp   : extended pointer on DQT barrier descriptor.
+////////////////////////////////////////////////////////////////////////////////////////////
+static void dqt_barrier_display( xptr_t  barrier_xp )
+//////////////////////////////////////////////
+void dqt_barrier_display( xptr_t  barrier_xp )
+{
     // get cluster and local pointer on DQT barrier
 …
                      uint32_t level = hal_remote_l32( XPTR( node_cxy , &node_ptr->level       ));
                      uint32_t arity = hal_remote_l32( XPTR( node_cxy , &node_ptr->arity       ));
+                     uint32_t count = hal_remote_l32( XPTR( node_cxy , &node_ptr->current     ));
                      xptr_t   pa_xp = hal_remote_l32( XPTR( node_cxy , &node_ptr->parent_xp   ));
                      xptr_t   c0_xp = hal_remote_l32( XPTR( node_cxy , &node_ptr->child_xp[0] ));
 …
                      xptr_t   c3_xp = hal_remote_l32( XPTR( node_cxy , &node_ptr->child_xp[3] ));
                      printk("   . level %d : (%x,%x) / arity %d / P(%x,%x) / C0(%x,%x)"
+                     printk("   . level %d : (%x,%x) / %d on %d / P(%x,%x) / C0(%x,%x)"
                             " C1(%x,%x) / C2(%x,%x) / C3(%x,%x)\n",
                      level, node_cxy, node_ptr, arity,
+                     level, node_cxy, node_ptr, count, arity,
                      GET_CXY(pa_xp), GET_PTR(pa_xp),
                      GET_CXY(c0_xp), GET_PTR(c0_xp),
 …
 }   // end dqt_barrier_display()
+#endif
+//////////////////////////////////////////////////////////////////////////////////////////
+// This static (recursive) function is called by the dqt_barrier_wait() function.
+// It traverses the DQT from bottom to root, and decrements the "current" variables.
+// For each traversed node, it blocks and deschedules if it is not the last expected
+//  thread. The last arrived thread reset the local node before returning.
+//////////////////////////////////////////////////////////////////////////////////////////
+static void dqt_barrier_increment( xptr_t  node_xp )
+{
+    uint32_t   expected;
+    uint32_t   sense;
+    uint32_t   arity;
+    thread_t * this = CURRENT_THREAD;
+    // get node cluster and local pointer
+    dqt_node_t * node_ptr = GET_PTR( node_xp );
+    cxy_t        node_cxy = GET_CXY( node_xp );
+    // build relevant extended pointers
+    xptr_t  arity_xp   = XPTR( node_cxy , &node_ptr->arity );
+    xptr_t  sense_xp   = XPTR( node_cxy , &node_ptr->sense );
+    xptr_t  current_xp = XPTR( node_cxy , &node_ptr->current );
+    xptr_t  lock_xp    = XPTR( node_cxy , &node_ptr->lock );
+    xptr_t  root_xp    = XPTR( node_cxy , &node_ptr->root );
+#if DEBUG_BARRIER_WAIT
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+uint32_t   level = hal_remote_l32( XPTR( node_cxy, &node_ptr->level ) );
+if( cycle > DEBUG_BARRIER_WAIT )
+printk("\n[%s] thread[%x,%x] increments DQT node(%d,%d,%d) / cycle %d\n",
+__FUNCTION__ , this->process->pid, this->trdid,
+HAL_X_FROM_CXY(node_cxy), HAL_Y_FROM_CXY(node_cxy), level );
+#endif
+    // get extended pointer on parent node
+    xptr_t  parent_xp  = hal_remote_l64( XPTR( node_cxy , &node_ptr->parent_xp ) );
+    // take busylock
+    remote_busylock_acquire( lock_xp );
+    // get sense and arity values from barrier descriptor
+    sense = hal_remote_l32( sense_xp );
+    arity = hal_remote_l32( arity_xp );
+    // compute expected value
+    expected = (sense == 0) ? 1 : 0;
+    // increment current number of arrived threads / get value before increment
+    uint32_t current = hal_remote_atomic_add( current_xp , 1 );
+    // last arrived thread reset the local node, makes the recursive call
+    // on parent node, and reactivates all waiting thread when returning.
+    // other threads block, register in queue, and deschedule.
+    if ( current == (arity - 1) )                        // last thread
+    {
+#if DEBUG_BARRIER_WAIT
+if( cycle > DEBUG_BARRIER_WAIT )
+printk("\n[%s] thread[%x,%x] reset DQT node(%d,%d,%d)\n",
+__FUNCTION__ , this->process->pid, this->trdid,
+HAL_X_FROM_CXY(node_cxy), HAL_Y_FROM_CXY(node_cxy), level );
+#endif
+        // reset the current node
+        hal_remote_s32( sense_xp   , expected );
+        hal_remote_s32( current_xp , 0 );
+        // release busylock protecting the current node
+        remote_busylock_release( lock_xp );
+        // recursive call on parent node when current node is not the root
+        if( parent_xp != XPTR_NULL) dqt_barrier_increment( parent_xp );
+        // unblock all waiting threads on this node
+        while( xlist_is_empty( root_xp ) == false )
+        {
+            // get pointers on first waiting thread
+            xptr_t     thread_xp  = XLIST_FIRST( root_xp , thread_t , wait_list );
+            cxy_t      thread_cxy = GET_CXY( thread_xp );
+            thread_t * thread_ptr = GET_PTR( thread_xp );
+#if (DEBUG_BARRIER_WAIT & 1)
+trdid_t     trdid   = hal_remote_l32( XPTR( thread_cxy , &thread_ptr->trdid ) );
+process_t * process = hal_remote_lpt( XPTR( thread_cxy , &thread_ptr->process ) );
+pid_t       pid     = hal_remote_l32( XPTR( thread_cxy , &process->pid ) );
+if( cycle > DEBUG_BARRIER_WAIT )
+printk("\n[%s] thread[%x,%x] unblock thread[%x,%x]\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, trdid );
+#endif
+            // remove waiting thread from queue
+            xlist_unlink( XPTR( thread_cxy , &thread_ptr->wait_list ) );
+            // unblock waiting thread
+            thread_unblock( thread_xp , THREAD_BLOCKED_USERSYNC );
+        }
+    }
+    else                                               // not the last thread
+    {
+        // get extended pointer on xlist entry from thread
+        xptr_t  entry_xp = XPTR( local_cxy , &this->wait_list );
+        // register calling thread in barrier waiting queue
+        xlist_add_last( root_xp , entry_xp );
+        // block calling thread
+        thread_block( XPTR( local_cxy , this ) , THREAD_BLOCKED_USERSYNC );
+        // release busylock protecting the remote_barrier
+        remote_busylock_release( lock_xp );
+#if DEBUG_BARRIER_WAIT
+if( cycle > DEBUG_BARRIER_WAIT )
+printk("\n[%s] thread[%x,%x] blocks on node(%d,%d,%d)\n",
+__FUNCTION__ , this->process->pid, this->trdid,
+HAL_X_FROM_CXY(node_cxy), HAL_Y_FROM_CXY(node_cxy), level );
+#endif
+        // deschedule
+        sched_yield("blocked on barrier");
+    }
+    return;
+} // end dqt_barrier_decrement()

trunk/kernel/libk/remote_barrier.h

-                      r619
+                      r623
  * used by the kernel. ALMOS-MKH uses only the barrier virtual address as an identifier.
  * For each user barrier, ALMOS-MKH creates a kernel structure, dynamically allocated
  * by the "generic_barrier_create()" function, destroyed by the "remote_barrier_destroy()"
  * function, and used by the "generic_barrier_wait()" function.
+ * by the generic_barrier_create() function, destroyed by the generic_barrier_destroy()
+ * function, and used by the generic_barrier_wait() function.
+ *
  * Implementation note:
 …
  *    (x_size * ysize) mesh, including cluster (0,0), with nthreads per cluster, and called
  *    DQT : Distributed Quad Tree. This DQT implementation supposes a regular architecture,
+                     uint32_t arity = hal_remote_l32( XPTR( node_cxy , &node_ptr->arity       ));
  *    and a strong contraint on the threads placement: exactly "nthreads" threads per
  *    cluster in the (x_size * y_size) mesh.
 …
+/*****************************************************************************************
+ * This debug function uses remote accesses to display the current state of a generic
+ * barrier identified by the <gen_barrier_xp> argument.
+ * It calls the relevant function (simple or DQT) to display relevant information.
+ * It can be called by a thread running in any cluster.
+ *****************************************************************************************
+ * @ barrier_xp   : extended pointer on generic barrier descriptor.
+ ****************************************************************************************/
+void generic_barrier_display( xptr_t gen_barrier_xp );
 …
 void simple_barrier_wait( xptr_t   barrier_xp );
+/*****************************************************************************************
+ * This debug function uses remote accesses to display the current state of a simple
+ * barrier identified by the <barrier_xp> argument.
+ * It can be called by a thread running in any cluster.
+ *****************************************************************************************
+ * @ barrier_xp   : extended pointer on simple barrier descriptor.
+ ****************************************************************************************/
+void simple_barrier_display( xptr_t barrier_xp );
 …
 void dqt_barrier_wait( xptr_t   barrier_xp );
+/*****************************************************************************************
+ * This debug function uses remote accesses to display the current state of all
+ * ditributed nodes in a DQT barrier identified by the <barrier_xp> argument.
+ * It can be called by a thread running in any cluster.
+ *****************************************************************************************
+ * @ barrier_xp   : extended pointer on DQT barrier descriptor.
+ ****************************************************************************************/
+void dqt_barrier_display( xptr_t barrier_xp );
 #endif  /* _REMOTE_BARRIER_H_ */

trunk/kernel/libk/remote_queuelock.c

-                      r610
+                      r623
 #if DEBUG_QUEUELOCK_TYPE
 if( DEBUG_QUEUELOCK_TYPE == lock_type )
+if( (DEBUG_QUEUELOCK_TYPE == lock_type) || (DEBUG_QUEUELOCK_TYPE == 1000) )
 printk("\n[%s] thread[%x,%x] BLOCK on q_lock %s [%x,%x]\n",
 __FUNCTION__, this->process->pid, this->trdid,
 …
 #if DEBUG_QUEUELOCK_TYPE
 if( DEBUG_QUEUELOCK_TYPE == lock_type )
+if( (DEBUG_QUEUELOCK_TYPE == lock_type) || (DEBUG_QUEUELOCK_TYPE == 1000) )
 printk("\n[%s] thread[%x,%x] ACQUIRE q_lock %s [%x,%x]\n",
 __FUNCTION__, this->process->pid, this->trdid,
 …
 thread_t * this      = CURRENT_THREAD;
 uint32_t   lock_type = hal_remote_l32( XPTR( lock_cxy , &lock_ptr->lock.type ) );
 if( DEBUG_QUEUELOCK_TYPE == lock_type )
+if( (DEBUG_QUEUELOCK_TYPE == lock_type) || (DEBUG_QUEUELOCK_TYPE == 1000) )
 printk("\n[%s] thread[%x,%x] RELEASE q_lock %s (%x,%x)\n",
 __FUNCTION__, this->process->pid, this->trdid,
 …
 #if DEBUG_QUEUELOCK_TYPE
 if( DEBUG_QUEUELOCK_TYPE == lock_type )
+if( (DEBUG_QUEUELOCK_TYPE == lock_type) || (DEBUG_QUEUELOCK_TYPE == 1000) )
+{
     trdid_t     trdid   = hal_remote_l32( XPTR( thread_cxy , &thread_ptr->trdid ) );

trunk/kernel/libk/remote_rwlock.c

-                      r610
+                      r623
 #if DEBUG_RWLOCK_TYPE
 thread_t * this = CURRENT_THREAD;
 if( type == DEBUG_RWLOCK_TYPE )
+if( DEBUG_RWLOCK_TYPE == type )
 printk("\n[%s] thread[%x,%x] initialise lock %s [%x,%x]\n",
 __FUNCTION__, this->process->pid, this->trdid,
 …
 #if DEBUG_RWLOCK_TYPE
 if( lock_type == DEBUG_RWLOCK_TYPE )
+if( (DEBUG_RWLOCK_TYPE == lock_type) || (DEBUG_RWLOCK_TYPE == 1000) )
 printk("\n[%s] thread[%x,%x] READ BLOCK on rwlock %s [%x,%x] / taken %d / count %d\n",
 __FUNCTION__, this->process->pid, this->trdid,
 …
 #if DEBUG_RWLOCK_TYPE
 if( lock_type == DEBUG_RWLOCK_TYPE )
+if( (DEBUG_RWLOCK_TYPE == lock_type) || (DEBUG_RWLOCK_TYPE == 1000) )
 printk("\n[%s] thread[%x,%x] READ ACQUIRE rwlock %s [%x,%x] / taken = %d / count = %d\n",
 __FUNCTION__, this->process->pid, this->trdid,
 …
 #if DEBUG_RWLOCK_TYPE
 if( lock_type == DEBUG_RWLOCK_TYPE )
+if( (DEBUG_RWLOCK_TYPE == lock_type) || (DEBUG_RWLOCK_TYPE == 1000) )
 printk("\n[%s] thread[%x,%x] WRITE BLOCK on rwlock %s [%x,%x] / taken %d / count %d\n",
 __FUNCTION__, this->process->pid, this->trdid,
 …
 #if DEBUG_RWLOCK_TYPE
 if( lock_type == DEBUG_RWLOCK_TYPE )
+if( (DEBUG_RWLOCK_TYPE == lock_type) || (DEBUG_RWLOCK_TYPE == 1000) )
 printk("\n[%s] thread[%x,%x] WRITE ACQUIRE rwlock %s [%x,%x] / taken %d / count %d\n",
 __FUNCTION__, this->process->pid, this->trdid,
 …
 uint32_t   lock_type = hal_remote_l32( XPTR( lock_cxy , &lock_ptr->lock.type ) );
 xptr_t     taken_xp  = XPTR( lock_cxy , &lock_ptr->taken );
 if( lock_type == DEBUG_RWLOCK_TYPE )
+if( (DEBUG_RWLOCK_TYPE == lock_type) || (DEBUG_RWLOCK_TYPE == 1000) )
 printk("\n[%s] thread[%x,%x] READ RELEASE rwlock %s [%x,%x] / taken %d / count %d\n",
 __FUNCTION__, this->process->pid, this->trdid,
 …
 #if DEBUG_RWLOCK_TYPE
 if( lock_type == DEBUG_RWLOCK_TYPE )
+if( (DEBUG_RWLOCK_TYPE == lock_type) || (DEBUG_RWLOCK_TYPE == 1000) )
+{
     trdid_t     trdid     = hal_remote_l32( XPTR( thread_cxy , &thread_ptr->trdid ) );
 …
 #if DEBUG_RWLOCK_TYPE
 if( lock_type == DEBUG_RWLOCK_TYPE )
+if( (DEBUG_RWLOCK_TYPE == lock_type) || (DEBUG_RWLOCK_TYPE == 1000) )
+{
     trdid_t     trdid     = hal_remote_l32( XPTR( thread_cxy , &thread_ptr->trdid ) );
 …
 uint32_t   lock_type = hal_remote_l32( XPTR( lock_cxy , &lock_ptr->lock.type ) );
 xptr_t     count_xp  = XPTR( lock_cxy , &lock_ptr->count );
 if( lock_type == DEBUG_RWLOCK_TYPE )
+if( (DEBUG_RWLOCK_TYPE == lock_type) || (DEBUG_RWLOCK_TYPE == 1000) )
 printk("\n[%s] thread[%x,%x] WRITE RELEASE rwlock %s [%x,%x] / taken %d / count %d\n",
 __FUNCTION__, this->process->pid, this->trdid,
 …
 #if DEBUG_RWLOCK_TYPE
 if( lock_type == DEBUG_RWLOCK_TYPE )
+if( (DEBUG_RWLOCK_TYPE == lock_type) || (DEBUG_RWLOCK_TYPE == 1000) )
+{
     trdid_t     trdid     = hal_remote_l32( XPTR( thread_cxy , &thread_ptr->trdid ) );
 …
 #if DEBUG_RWLOCK_TYPE
 if( lock_type == DEBUG_RWLOCK_TYPE )
+if( (DEBUG_RWLOCK_TYPE == lock_type) || (DEBUG_RWLOCK_TYPE == 1000) )
+{
     trdid_t     trdid     = hal_remote_l32( XPTR( thread_cxy , &thread_ptr->trdid ) );

trunk/kernel/libk/rwlock.c

-                      r610
+                      r623
     busylock_acquire( &lock->lock );
+#if DEBUG_RWLOCK_TYPE
+uint32_t lock_type = lock->lock.type;
+#endif
     // block and deschedule if lock already taken
     while( lock->taken )
 …
 #if DEBUG_RWLOCK_TYPE
+uint32_t lock_type = lock->lock.type;
+if( DEBUG_RWLOCK_TYPE == lock_type )
+if( (DEBUG_RWLOCK_TYPE == lock_type) || (DEBUG_RWLOCK_TYPE == 1000) )
 printk("\n[%s] thread[%x,%x] READ BLOCK on rwlock %s [%x,%x] / taken %d / count %d\n",
 __FUNCTION__, this->process->pid, this->trdid,
 …
 #if DEBUG_RWLOCK_TYPE
 if( DEBUG_RWLOCK_TYPE == lock_type )
+if( (DEBUG_RWLOCK_TYPE == lock_type) || (DEBUG_RWLOCK_TYPE == 1000) )
 printk("\n[%s] thread[%x,%x] READ ACQUIRE rwlock %s [%x,%x] / taken %d / count %d\n",
 __FUNCTION__, this->process->pid, this->trdid,
 …
     busylock_acquire( &lock->lock );
+#if DEBUG_RWLOCK_TYPE
+uint32_t lock_type = lock->lock.type;
+#endif
     // block and deschedule if lock already taken or existing read access
     while( lock->taken || lock->count )
 …
 #if DEBUG_RWLOCK_TYPE
+uint32_t lock_type = lock->lock.type;
+if( DEBUG_RWLOCK_TYPE == lock_type )
+if( (DEBUG_RWLOCK_TYPE == lock_type) || (DEBUG_RWLOCK_TYPE == 1000) )
 printk("\n[%s] thread[%x,%x] WRITE BLOCK on rwlock %s [%x,%x] / taken %d / count %d\n",
 __FUNCTION__, this->process->pid, this->trdid,
 …
 #if DEBUG_RWLOCK_TYPE
 if( DEBUG_RWLOCK_TYPE == lock_type )
+if( (DEBUG_RWLOCK_TYPE == lock_type) || (DEBUG_RWLOCK_TYPE == 1000) )
 printk("\n[%s] thread[%x,%x] WRITE ACQUIRE rwlock %s [%x,%x] / taken %d / count %d\n",
 __FUNCTION__, this->process->pid, this->trdid,
 …
 thread_t * this = CURRENT_THREAD;
 uint32_t lock_type = lock->lock.type;
 if( DEBUG_RWLOCK_TYPE == lock_type )
+if( (DEBUG_RWLOCK_TYPE == lock_type) || (DEBUG_RWLOCK_TYPE == 1000) )
 printk("\n[%s] thread[%x,%x] READ RELEASE rwlock %s [%x,%x] / taken %d / count %d\n",
 __FUNCTION__, this->process->pid, this->trdid,
 …
 #if DEBUG_RWLOCK_TYPE
 if( DEBUG_RWLOCK_TYPE == lock_type )
+if( (DEBUG_RWLOCK_TYPE == lock_type) || (DEBUG_RWLOCK_TYPE == 1000) )
 printk("\n[%s] thread[%x,%x] UNBLOCK thread[%x,%x] / rwlock %s [%x,%x]\n",
 __FUNCTION__, this->process->pid, this->trdid, thread->process->pid, thread->trdid,
 …
 #if DEBUG_RWLOCK_TYPE
 if( DEBUG_RWLOCK_TYPE == lock_type )
+if( (DEBUG_RWLOCK_TYPE == lock_type) || (DEBUG_RWLOCK_TYPE == 1000) )
 printk("\n[%s] thread[%x,%x] UNBLOCK thread[%x,%x] / rwlock %s [%x,%x]\n",
 __FUNCTION__, this->process->pid, this->trdid, thread->process->pid, thread->trdid,
 …
 thread_t * this = CURRENT_THREAD;
 uint32_t lock_type = lock->lock.type;
 if( DEBUG_RWLOCK_TYPE == lock_type )
+if( (DEBUG_RWLOCK_TYPE == lock_type) || (DEBUG_RWLOCK_TYPE == 1000) )
 printk("\n[%s] thread[%x,%x] WRITE RELEASE rwlock %s [%x,%x] / taken %d / count %d\n",
 __FUNCTION__, this->process->pid, this->trdid,
 …
 #if DEBUG_RWLOCK_TYPE
 if( DEBUG_RWLOCK_TYPE == lock_type )
+if( (DEBUG_RWLOCK_TYPE == lock_type) || (DEBUG_RWLOCK_TYPE == 1000) )
 printk("\n[%s] thread[%x,%x] UNBLOCK thread[%x,%x] / rwlock %s [%x,%x]\n",
 __FUNCTION__, this->process->pid, this->trdid, thread->process->pid, thread->trdid,
 …
 #if DEBUG_RWLOCK_TYPE
 if( DEBUG_RWLOCK_TYPE == lock_type )
+if( (DEBUG_RWLOCK_TYPE == lock_type) || (DEBUG_RWLOCK_TYPE == 1000) )
 printk("\n[%s] thread[%x,%x] UNBLOCK thread[%x,%x] / rwlock %s [%x,%x]\n",
 __FUNCTION__, this->process->pid, this->trdid, thread->process->pid, thread->trdid,

trunk/kernel/libk/user_dir.h

r614	r623
86	86	* - the allocation of one or several physical pages in reference cluster to store
87	87	* all directory entries in an array of 64 bytes dirent structures,
88		* - the initialisation of this array from informations found in the ~~Inode Tree~~.
	88	* - the initialisation of this array from informations found in the directory mapper.
89	89	* - the creation of an ANON vseg containing this dirent array in reference process VMM,
90	90	* and the mapping of the relevant physical pages in this vseg.

trunk/kernel/mm/mapper.c

-                      r614
+                      r623
+ *
  * Authors   Mohamed Lamine Karaoui (2015)
  *           Alain Greiner (2016,2017,2018)
+ *           Alain Greiner (2016,2017,2018,2019)
+ *
  * Copyright (c)  UPMC Sorbonne Universites
 …
 vfs_inode_t * inode = mapper->inode;
 vfs_inode_get_name( XPTR( local_cxy , inode ) , name );
+// if( DEBUG_MAPPER_HANDLE_MISS < cycle )
+// if( (page_id == 1) && (cycle > 10000000) )
+if( DEBUG_MAPPER_HANDLE_MISS < cycle )
 printk("\n[%s] enter for page %d in <%s> / cycle %d",
 __FUNCTION__, page_id, name, cycle );
 …
 #if DEBUG_MAPPER_HANDLE_MISS
 cycle = (uint32_t)hal_get_cycles();
+// if( DEBUG_MAPPER_HANDLE_MISS < cycle )
+// if( (page_id == 1) && (cycle > 10000000) )
+if( DEBUG_MAPPER_HANDLE_MISS < cycle )
 printk("\n[%s] exit for page %d in <%s> / ppn %x / cycle %d",
 __FUNCTION__, page_id, name, ppm_page2ppn( *page_xp ), cycle );
 …
             ppm_page_do_dirty( page_xp );
             hal_copy_from_uspace( map_ptr , buf_ptr , page_count );
+putb(" in mapper_move_user()" , map_ptr , page_count );
+        }
 …
 }  // end mapper_remote_set_32()
+/////////////////////////////////////////
+error_t mapper_sync( mapper_t *  mapper )
+{
+    page_t   * page;                // local pointer on current page descriptor
+    xptr_t     page_xp;             // extended pointer on current page descriptor
+    grdxt_t  * rt;                  // pointer on radix_tree descriptor
+    uint32_t   start_key;           // start page index in mapper
+    uint32_t   found_key;           // current page index in mapper
+    error_t    error;
+#if DEBUG_MAPPER_SYNC
+thread_t * this  = CURRENT_THREAD;
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+char       name[CONFIG_VFS_MAX_NAME_LENGTH];
+vfs_inode_get_name( XPTR( local_cxy , mapper->inode ) , name );
+#endif
+    // get pointer on radix tree
+    rt        = &mapper->rt;
+    // initialise loop variable
+    start_key = 0;
+    // scan radix-tree until last page found
+    while( 1 )
+    {
+        // get page descriptor from radix tree
+        page = (page_t *)grdxt_get_first( rt , start_key , &found_key );
+        if( page == NULL ) break;
+assert( (page->index == found_key ), __FUNCTION__, "wrong page descriptor index" );
+assert( (page->order == 0),          __FUNCTION__, "mapper page order must be 0" );
+        // build extended pointer on page descriptor
+        page_xp = XPTR( local_cxy , page );
+        // synchronize page if dirty
+        if( (page->flags & PG_DIRTY) != 0 )
+        {
+#if DEBUG_MAPPER_SYNC
+if( cycle > DEBUG_MAPPER_SYNC )
+printk("\n[%s] thread[%x,%x] synchonise page %d of <%s> to device\n",
+__FUNCTION__, this->process->pid, this->trdid, page->index, name );
+#endif
+            // copy page to file system
+            error = vfs_fs_move_page( page_xp , IOC_WRITE );
+            if( error )
+            {
+                printk("\n[ERROR] in %s : cannot synchonize dirty page %d\n",
+                __FUNCTION__, page->index );
+                return -1;
+            }
+            // remove page from PPM dirty list
+            ppm_page_undo_dirty( page_xp );
+        }
+        else
+        {
+#if DEBUG_MAPPER_SYNC
+if( cycle > DEBUG_MAPPER_SYNC )
+printk("\n[%s] thread[%x,%x] skip page %d for <%s>\n",
+__FUNCTION__, this->process->pid, this->trdid, page->index, name );
+#endif
+        }
+        // update loop variable
+        start_key = page->index + 1;
+    }  // end while
+    return 0;
+}  // end mapper_sync()
 //////////////////////////////////////////////////

trunk/kernel/mm/mapper.h

-                      r614
+                      r623
+ *
  * Authors   Mohamed Lamine Karaoui (2015)
  *           Alain Greiner (2016,2017,2018)
+ *           Alain Greiner (2016,2017,2018,2019)
+ *
  * Copyright (c)  UPMC Sorbonne Universites
 …
  *   "readers", and only one "writer".
  * - A "reader" thread, calling the mapper_remote_get_page() function to get a page
  *   descriptor pointer from the page index in file, can be remote (running in any cluster).
+ *   descriptor pointer from the page index in file, can be running in any cluster.
  * - A "writer" thread, calling the mapper_handle_miss() function to handle a page miss
  *   must be local (running in the mapper cluster).
  * - The vfs_mapper_move_page() function access the file system to handle a mapper miss,
+ * - The vfs_fs_move_page() function access the file system to handle a mapper miss,
  *   or update a dirty page on device.
  * - The vfs_mapper_load_all() functions is used to load all pages of a directory
 …
+ *
  * TODO : the mapper being only used to implement the VFS cache(s), the mapper.c
  *        and mapper.h file should be trandfered to the vfs directory.
+ *        and mapper.h file should be trandfered to the fs directory.
  ******************************************************************************************/
 …
 /*******************************************************************************************
+ * This scans all pages present in the mapper identified by the <mapper> argument,
+ * and synchronize all pages maked as dirty" on disk.
+ * These pages are unmarked and removed from the local PPM dirty_list.
+ * This function must be called by a local thread running in same cluster as the mapper.
+ * A remote thread must call the RPC_MAPPER_SYNC function.
+ *******************************************************************************************
+ * @ mapper     : [in]  local pointer on local mapper.
+ * @ returns 0 if success / return -1 if error.
+ ******************************************************************************************/
+error_t mapper_sync( mapper_t *  mapper );
+/*******************************************************************************************
  * This debug function displays the content of a given page of a given mapper.
  * - the mapper is identified by the <mapper_xp> argument.

trunk/kernel/mm/page.h

r612	r623
41	41	#define PG_INIT 0x0001 // page descriptor has been initialised
42	42	#define PG_RESERVED 0x0002 // cannot be allocated by PPM
43		#define PG_FREE 0x0004 // page ~~can be~~ allocated by PPM
	43	#define PG_FREE 0x0004 // page not yet allocated by PPM
44	44	#define PG_DIRTY 0x0040 // page has been written
45	45	#define PG_COW 0x0080 // page is copy-on-write

trunk/kernel/mm/ppm.h

-                      r611
+                      r623
+ *
  * Authors  Ghassan Almaless (2008,2009,2010,2011,2012)
  *          Alain Greiner    (2016,2017,2018)
+ *          Alain Greiner    (2016,2017,2018,2019)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
  * This structure defines the Physical Pages Manager in a cluster.
  * In each cluster, the physical memory bank starts at local physical address 0 and
  * contains an integer number of pages, defined by the <pages_nr> field in the
+ * contains an integer number of small pages, defined by the <pages_nr> field in the
  * boot_info structure. It is split in three parts:
+ *
  * - the "kernel_code" section contains the kernel code, loaded by the boot-loader.
  *   It starts at PPN = 0 and the size is defined by the <pages_offset> field in the
  *   boot_info structure.
  * - the "pages_tbl" section contains the physical page descriptors array. It starts
  *   at PPN = pages_offset, and it contains one entry per small physical page in cluster.
+ *   It starts at local PPN = 0 and the size is defined by the <pages_offset> field
+ *   in the boot_info structure.
+ * - the local "pages_tbl" section contains the physical page descriptors array.
+ *   It starts at local PPN = pages_offset, and it contains one entry per small page.
  *   It is created and initialized by the hal_ppm_create() function.
  * - The "kernel_heap" section contains all physical pages that are are not in the
+ *   kernel_code and pages_tbl sections, and that have not been reserved by the
+ *   architecture specific bootloader. The reserved pages are defined in the boot_info
+ *   structure.
+ *   "kernel_code" and "pages_tbl" sections, and that have not been reserved.
+ *   The reserved pages are defined in the boot_info structure.
+ *
  * The main service provided by the PMM is the dynamic allocation of physical pages
 …
+ *
  * Another service is to register the dirty pages in a specific dirty_list, that is
  * also rooted in the PPM, in order to be able to save all dirty pages on disk.
+ * also rooted in the PPM, in order to be able to synchronize all dirty pages on disk.
  * This dirty list is protected by a specific remote_queuelock, because it can be
  * modified by a remote thread, but it contains only local pages.
 …
  *   . if page already dirty => do nothing
  *   . it page not dirty => set the PG_DIRTY flag and register page in PPM dirty list.
  * - it releases the busylock protcting the page flags.
+ * - it releases the busylock protecting the page flags.
  * - it releases the queuelock protecting the PPM dirty_list.
  *****************************************************************************************
 …
  *   . if page not dirty => do nothing
  *   . it page dirty => reset the PG_DIRTY flag and remove page from PPM dirty list.
  * - it releases the busylock protcting the page flags.
+ * - it releases the busylock protecting the page flags.
  * - it releases the queuelock protecting the PPM dirty_list.
  *****************************************************************************************

trunk/kernel/mm/vmm.c

-                      r621
+                      r623
+{
     error_t   error;
-    vseg_t  * vseg_kentry;
     vseg_t  * vseg_args;
     vseg_t  * vseg_envs;
 …
 (CONFIG_VMM_VSPACE_SIZE - CONFIG_VMM_STACK_BASE)) ,
 "STACK zone too small\n");
-    // register kentry vseg in VSL
-    base = CONFIG_VMM_KENTRY_BASE << CONFIG_PPM_PAGE_SHIFT;
-    size = CONFIG_VMM_KENTRY_SIZE << CONFIG_PPM_PAGE_SHIFT;
-    vseg_kentry = vmm_create_vseg( process,
-                                   VSEG_TYPE_CODE,
-                                   base,
-                                   size,
-,             // file_offset unused
-,             // file_size unused
-                                   XPTR_NULL,     // mapper_xp unused
-                                   local_cxy );
-    if( vseg_kentry == NULL )
+    {
-        printk("\n[ERROR] in %s : cannot register kentry vseg\n", __FUNCTION__ );
-        return -1;
+    }
-    vmm->kent_vpn_base = base;
     // register args vseg in VSL
 …
     if( error )
+    printk("\n[ERROR] in %s : cannot create GPT\n", __FUNCTION__ );
+    {
+        printk("\n[ERROR] in %s : cannot create GPT\n", __FUNCTION__ );
+        return -1;
+    }
     // initialize GPT lock
     remote_rwlock_init( XPTR( local_cxy , &vmm->gpt_lock ) , LOCK_VMM_GPT );
+    // architecture specic GPT initialisation
+    // (For TSAR, identity map the kentry_vseg)
+    error = hal_vmm_init( vmm );
+    if( error )
+    printk("\n[ERROR] in %s : cannot initialize GPT\n", __FUNCTION__ );
+    // update process VMM with kernel vsegs
+    error = hal_vmm_kernel_update( process );
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot update GPT for kernel vsegs\n", __FUNCTION__ );
+        return -1;
+    }
     // initialize STACK allocator
 …
+    }
+    // release physical memory allocated for vseg descriptor if no MMAP type
+    if( (type != VSEG_TYPE_ANON) && (type != VSEG_TYPE_FILE) && (type != VSEG_TYPE_REMOTE) )
+    // release physical memory allocated for vseg if no MMAP and no kernel type
+    if( (type != VSEG_TYPE_ANON) && (type != VSEG_TYPE_FILE) && (type != VSEG_TYPE_REMOTE) &&
+        (type != VSEG_TYPE_KCODE) && (type != VSEG_TYPE_KDATA) && (type != VSEG_TYPE_KDEV) )
+    {
         vseg_free( vseg );
 …
     child_vmm->vsegs_nr = 0;
     // create child GPT
+    // create the child GPT
     error = hal_gpt_create( &child_vmm->gpt );
 …
 #endif
+        // all parent vsegs - but STACK - must be copied in child VSL
+        if( type != VSEG_TYPE_STACK )
+        // all parent vsegs - but STACK and kernel vsegs - must be copied in child VSL
+        if( (type != VSEG_TYPE_STACK) && (type != VSEG_TYPE_KCODE) &&
+            (type != VSEG_TYPE_KDATA) && (type != VSEG_TYPE_KDEV) )
+        {
             // allocate memory for a new child vseg
 …
     remote_rwlock_rd_release( parent_lock_xp );
+    // initialize child GPT (architecture specic)
+    // => For TSAR, identity map the kentry_vseg
+    error = hal_vmm_init( child_vmm );
+    // update child VMM with kernel vsegs
+    error = hal_vmm_kernel_update( child_process );
     if( error )
+    {
         printk("\n[ERROR] in %s : cannot create GPT\n", __FUNCTION__ );
+        printk("\n[ERROR] in %s : cannot update child VMM\n", __FUNCTION__ );
         return -1;
+    }
 …
         base = vpn_base << CONFIG_PPM_PAGE_SHIFT;
+    }
     else    // VSEG_TYPE_DATA or VSEG_TYPE_CODE
+    else    // VSEG_TYPE_DATA, VSEG_TYPE_CODE or KERNEL vseg
+    {
         uint32_t vpn_min = base >> CONFIG_PPM_PAGE_SHIFT;
 …
     xptr_t      lock_xp;    // extended pointer on lock protecting forks counter
     uint32_t    forks;      // actual number of pendinf forks
+    uint32_t    type;       // vseg type
 #if DEBUG_VMM_DELETE_VSEG
 …
     process = cluster_get_local_process_from_pid( pid );
+    if( process == NULL ) return;
+    if( process == NULL )
+    {
+        printk("\n[ERRORR] in %s : cannot get local process descriptor\n",
+        __FUNCTION__ );
+        return;
+    }
     // get pointers on local process VMM an GPT
 …
     vseg = vmm_vseg_from_vaddr( vmm , vaddr );
+    if( vseg == NULL ) return;
+    // loop to invalidate all vseg PTEs in GPT
+    if( vseg == NULL )
+    {
+        printk("\n[ERRORR] in %s : cannot get vseg descriptor\n",
+        __FUNCTION__ );
+        return;
+    }
+    // get relevant vseg infos
+    type    = vseg->type;
     vpn_min = vseg->vpn_base;
     vpn_max = vpn_min + vseg->vpn_size;
+    // loop to invalidate all vseg PTEs in GPT
         for( vpn = vpn_min ; vpn < vpn_max ; vpn++ )
+    {
 …
 printk("- unmap vpn %x / ppn %x / vseg %s \n" , vpn , ppn, vseg_type_str(vseg->type) );
 #endif
-// check small page
-assert( (attr & GPT_SMALL) , "an user vseg must use small pages" );
             // unmap GPT entry in local GPT
             hal_gpt_reset_pte( gpt , vpn );
+            // handle pending forks counter if
+            // 1) not identity mapped
+            // 2) reference cluster
+            if( ((vseg->flags & VSEG_IDENT)  == 0) &&
+                (GET_CXY( process->ref_xp ) == local_cxy) )
+            // the allocated page is not released to KMEM for kernel vseg
+            if( (type != VSEG_TYPE_KCODE) &&
+                (type != VSEG_TYPE_KDATA) &&
+                (type != VSEG_TYPE_KDEV ) )
+            {
+// FIXME This code must be completely re-written, as the actual release must depend on
+// - the vseg type
+// - the reference cluster
+// - the page refcount and/or the forks counter
                 // get extended pointer on physical page descriptor
                 page_xp  = ppm_ppn2page( ppn );
 …
                 lock_xp  = XPTR( page_cxy , &page_ptr->lock );
+                // get the lock protecting the page
                 remote_busylock_acquire( lock_xp );
                 // get pending forks counter
                 forks = hal_remote_l32( forks_xp );
                 if( forks )  // decrement pending forks counter
+                {
 …
 #endif
+                }
+                // release the lock protecting the page
                 remote_busylock_release( lock_xp );
+            }
 …
     // return failure
     remote_rwlock_rd_release( lock_xp );
     return NULL;
 …
     vpn_t     vpn_max;
+#if DEBUG_VMM_RESIZE_VSEG
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+thread_t * this  = CURRENT_THREAD;
+if( DEBUG_VMM_RESIZE_VSEG < cycle )
+printk("\n[%s] thread[%x,%x] enter / process %x / base %x / size %d / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, process->pid, base, size, cycle );
+#endif
     // get pointer on process VMM
     vmm_t * vmm = &process->vmm;
 …
         vseg_t * vseg = vmm_vseg_from_vaddr( vmm , base );
         if( vseg == NULL)  return EINVAL;
     // get extended pointer on VSL lock
     xptr_t lock_xp = XPTR( local_cxy , &vmm->vsegs_lock );
     // get lock protecting VSL
+        remote_rwlock_wr_acquire( lock_xp );
+        if( vseg == NULL)
+    {
+        printk("\n[ERROR] in %s : vseg(%x,%d) not found\n",
+        __FUNCTION__, base , size );
+        return -1;
+    }
+    // resize depends on unmapped region base and size
         if( (vseg->min > addr_min) || (vseg->max < addr_max) )        // not included in vseg
+    {
+        printk("\n[ERROR] in %s : unmapped region[%x->%x[ not included in vseg[%x->%x[\n",
+        __FUNCTION__, addr_min, addr_max, vseg->min, vseg->max );
         error = -1;
+    }
         else if( (vseg->min == addr_min) && (vseg->max == addr_max) )  // vseg must be deleted
+    {
+#if( DEBUG_VMM_RESIZE_VSEG & 1 )
+if( DEBUG_VMM_RESIZE_VSEG < cycle )
+printk("\n[%s] unmapped region[%x->%x[ equal vseg[%x->%x[\n",
+__FUNCTION__, addr_min, addr_max, vseg->min, vseg->max );
+#endif
         vmm_delete_vseg( process->pid , vseg->min );
+#if( DEBUG_VMM_RESIZE_VSEG & 1 )
+if( DEBUG_VMM_RESIZE_VSEG < cycle )
+printk("\n[%s] thread[%x,%x] deleted vseg\n",
+__FUNCTION__, this->process->pid, this->trdid );
+#endif
         error = 0;
+    }
         else if( vseg->min == addr_min )                               // vseg must be resized
+    {
+        // update vseg base address
+#if( DEBUG_VMM_RESIZE_VSEG & 1 )
+if( DEBUG_VMM_RESIZE_VSEG < cycle )
+printk("\n[%s] unmapped region[%x->%x[ included in vseg[%x->%x[\n",
+__FUNCTION__, addr_min, addr_max, vseg->min, vseg->max );
+#endif
+        // update vseg min address
         vseg->min = addr_max;
 …
         vseg->vpn_base = vpn_min;
         vseg->vpn_size = vpn_max - vpn_min + 1;
+#if( DEBUG_VMM_RESIZE_VSEG & 1 )
+if( DEBUG_VMM_RESIZE_VSEG < cycle )
+printk("\n[%s] thread[%x,%x] changed vseg_min\n",
+__FUNCTION__, this->process->pid, this->trdid );
+#endif
         error = 0;
+    }
         else if( vseg->max == addr_max )                              // vseg must be resized
+    {
+#if( DEBUG_VMM_RESIZE_VSEG & 1 )
+if( DEBUG_VMM_RESIZE_VSEG < cycle )
+printk("\n[%s] unmapped region[%x->%x[ included in vseg[%x->%x[\n",
+__FUNCTION__, addr_min, addr_max, vseg->min, vseg->max );
+#endif
         // update vseg max address
         vseg->max = addr_min;
 …
         vseg->vpn_base = vpn_min;
         vseg->vpn_size = vpn_max - vpn_min + 1;
+#if( DEBUG_VMM_RESIZE_VSEG & 1 )
+if( DEBUG_VMM_RESIZE_VSEG < cycle )
+printk("\n[%s] thread[%x,%x] changed vseg_max\n",
+__FUNCTION__, this->process->pid, this->trdid );
+#endif
         error = 0;
+    }
     else                                                          // vseg cut in three regions
+    {
+#if( DEBUG_VMM_RESIZE_VSEG & 1 )
+if( DEBUG_VMM_RESIZE_VSEG < cycle )
+printk("\n[%s] unmapped region[%x->%x[ included in vseg[%x->%x[\n",
+__FUNCTION__, addr_min, addr_max, vseg->min, vseg->max );
+#endif
         // resize existing vseg
         vseg->max = addr_min;
 …
                                vseg->cxy );
+        if( new == NULL ) error = EINVAL;
+#if( DEBUG_VMM_RESIZE_VSEG & 1 )
+if( DEBUG_VMM_RESIZE_VSEG < cycle )
+printk("\n[%s] thread[%x,%x] replaced vseg by two smal vsegs\n",
+__FUNCTION__, this->process->pid, this->trdid );
+#endif
+        if( new == NULL ) error = -1;
         else              error = 0;
+    }
+    // release VMM lock
+        remote_rwlock_wr_release( lock_xp );
+#if DEBUG_VMM_RESIZE_VSEG
+if( DEBUG_VMM_RESIZE_VSEG < cycle )
+printk("\n[%s] thread[%x,%x] exit / process %x / base %x / size %d / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, process->pid, base, size, cycle );
+#endif
         return error;

trunk/kernel/mm/vmm.h

r614	r623
4	4	* Authors Ghassan Almaless (2008,2009,2010,2011, 2012)
5	5	* Mohamed Lamine Karaoui (2015)
6		* Alain Greiner (2016,2017,2018)
	6	* Alain Greiner (2016,2017,2018,2019)
7	7	*
8	8	* Copyright (c) UPMC Sorbonne Universites

trunk/kernel/mm/vseg.c

-                      r595
+                      r623
  * Authors   Ghassan Almaless (2008,2009,2010,2011, 2012)
  *           Mohamed Lamine Karaoui (2015)
  *           Alain Greiner (2016,2018,2019)
+ *           Alain Greiner (2016,2017,2018,2019)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
         else if( vseg_type == VSEG_TYPE_FILE   ) return "FILE";
         else if( vseg_type == VSEG_TYPE_REMOTE ) return "REMO";
+        else if( vseg_type == VSEG_TYPE_KCODE  ) return "KCOD";
+        else if( vseg_type == VSEG_TYPE_KDATA  ) return "KDAT";
+        else if( vseg_type == VSEG_TYPE_KDEV   ) return "KDEV";
     else                                     return "undefined";
+}
 …
                       VSEG_CACHE   ;
+    }
+    else if( type == VSEG_TYPE_KCODE )
+    {
+        vseg->flags = VSEG_EXEC    |
+                      VSEG_CACHE   |
+                      VSEG_PRIVATE ;
+    }
+    else if( type == VSEG_TYPE_KDATA )
+    {
+        vseg->flags = VSEG_CACHE   |
+                      VSEG_WRITE   ;
+    }
+    else if( type == VSEG_TYPE_KDEV )
+    {
+        vseg->flags = VSEG_WRITE   ;
+    }
     else
+    {
 …
     // initialize vseg with remote_read access
     vseg->type        =           hal_remote_l32 ( XPTR( cxy , &ptr->type        ) );
+    vseg->type        =           hal_remote_l32( XPTR( cxy , &ptr->type        ) );
     vseg->min         = (intptr_t)hal_remote_lpt( XPTR( cxy , &ptr->min         ) );
     vseg->max         = (intptr_t)hal_remote_lpt( XPTR( cxy , &ptr->max         ) );
     vseg->vpn_base    =           hal_remote_l32 ( XPTR( cxy , &ptr->vpn_base    ) );
     vseg->vpn_size    =           hal_remote_l32 ( XPTR( cxy , &ptr->vpn_size    ) );
     vseg->flags       =           hal_remote_l32 ( XPTR( cxy , &ptr->flags       ) );
     vseg->file_offset =           hal_remote_l32 ( XPTR( cxy , &ptr->file_offset ) );
     vseg->file_size   =           hal_remote_l32 ( XPTR( cxy , &ptr->file_size   ) );
+    vseg->vpn_base    =           hal_remote_l32( XPTR( cxy , &ptr->vpn_base    ) );
+    vseg->vpn_size    =           hal_remote_l32( XPTR( cxy , &ptr->vpn_size    ) );
+    vseg->flags       =           hal_remote_l32( XPTR( cxy , &ptr->flags       ) );
+    vseg->file_offset =           hal_remote_l32( XPTR( cxy , &ptr->file_offset ) );
+    vseg->file_size   =           hal_remote_l32( XPTR( cxy , &ptr->file_size   ) );
         vseg->mapper_xp   = (xptr_t)  hal_remote_l64( XPTR( cxy , &ptr->mapper_xp   ) );
     switch (vseg->type)
+    {
         case VSEG_TYPE_DATA:
+        case VSEG_TYPE_DATA:      // unused
+        {
             vseg->cxy = 0xffff;
             break;
+        }
         case VSEG_TYPE_CODE:
+        case VSEG_TYPE_CODE:      // always local
         case VSEG_TYPE_STACK:
+        case VSEG_TYPE_KCODE:
+        {
             vseg->cxy = local_cxy;
             break;
+        }
         case VSEG_TYPE_ANON:
+        case VSEG_TYPE_ANON:      // intrinsic
         case VSEG_TYPE_FILE:
         case VSEG_TYPE_REMOTE:
+        case VSEG_TYPE_KDEV:
+        case VSEG_TYPE_KDATA:
+        {
             vseg->cxy = (cxy_t) hal_remote_l32( XPTR(cxy, &ptr->cxy) );

trunk/kernel/mm/vseg.h

-                      r611
+                      r623
  * Authors   Ghassan Almaless (2008,2009,2010,2011, 2012)
  *           Mohamed Lamine Karaoui (2015)
  *           Alain Greiner (2016)
+ *           Alain Greiner (2016,2017,2018,2019)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
 /*******************************************************************************************
+ * This enum defines the vseg types for an user process.
+ * This enum defines the vseg types.
+ * Note : the KDATA and KDEV types are not used by the TSAR HAL, because the accesses
+ *        to kernel data or kernel devices are done through the DATA extension address
+ *        register, but these types are probably required by the I86 HAL [AG].
  ******************************************************************************************/
 typedef enum
+{
+    VSEG_TYPE_CODE   = 0,          /*! executable user code   / private / localized       */
+    VSEG_TYPE_DATA   = 1,          /*! initialized user data  / public  / distributed     */
+    VSEG_TYPE_STACK  = 2,          /*! execution user stack   / private / localized       */
+    VSEG_TYPE_ANON   = 3,          /*! anonymous mmap         / public  / localized       */
+    VSEG_TYPE_FILE   = 4,          /*! file mmap              / public  / localized       */
+    VSEG_TYPE_REMOTE = 5,          /*! remote mmap            / public  / localized       */
+    VSEG_TYPE_CODE   = 0,          /*! executable user code     / private / localized     */
+    VSEG_TYPE_DATA   = 1,          /*! initialized user data    / public  / distributed   */
+    VSEG_TYPE_STACK  = 2,          /*! execution user stack     / private / localized     */
+    VSEG_TYPE_ANON   = 3,          /*! anonymous mmap           / public  / localized     */
+    VSEG_TYPE_FILE   = 4,          /*! file mmap                / public  / localized     */
+    VSEG_TYPE_REMOTE = 5,          /*! remote mmap              / public  / localized     */
+    VSEG_TYPE_KCODE  = 6,          /*! executable kernel code   / private / localized     */
+    VSEG_TYPE_KDATA  = 7,          /*! initialized kernel data  / private / localized     */
+    VSEG_TYPE_KDEV   = 8,          /*! kernel peripheral device / public  / localized     */
+}
 vseg_type_t;
 …
 #define VSEG_PRIVATE  0x0010       /*! should not be accessed from another cluster        */
 #define VSEG_DISTRIB  0x0020       /*! physically distributed on all clusters             */
-#define VSEG_IDENT    0x0040       /*! identity mapping                                   */
 /*******************************************************************************************

trunk/kernel/syscalls/shared_include/shared_almos.h

r611	r623
53	53	DISPLAY_BUSYLOCKS = 8,
54	54	DISPLAY_MAPPER = 9,
	55	DISPLAY_BARRIER = 10,
55	56	}
56	57	display_type_t;

trunk/kernel/syscalls/shared_include/shared_mman.h

-                      r594
+                      r623
  * shred_mman.h - Shared structures & mnemonics used by the <mman.h> user library.
+ *
  * Author  Alain Greiner (2016,2017,2018)
+ * Author  Alain Greiner (2016,2017,2018,2019)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
 /*******************************************************************************************
  * These structure are used by the mmap() syscall().
+ * This structure is used by the mmap() syscall().
  ******************************************************************************************/

trunk/kernel/syscalls/sys_creat.c

r457	r623
2	2	* sys_creat.c - create a file
3	3	*
4		* Author Alain Greiner (2016,2017)
	4	* Author Alain Greiner (2016,2017,2017,2019)
5	5	*
6	6	* Copyright (c) UPMC Sorbonne Universites

trunk/kernel/syscalls/sys_display.c

-                      r619
+                      r623
 #include <string.h>
 #include <shared_syscalls.h>
+#include <remote_barrier.h>
 #include <vfs.h>
 #include <mapper.h>
 …
     else if( type == DISPLAY_BUSYLOCKS         ) return "BUSYLOCKS";
     else if( type == DISPLAY_MAPPER            ) return "MAPPER";
+    else if( type == DISPLAY_BARRIER           ) return "BARRIER";
     else                                         return "undefined";
+}
 …
 #endif
+    ////////////////////////////
+    if( type == DISPLAY_STRING )
+    switch( type )
+    {
+        char      kbuf[512];
+        uint32_t  length;
+        char    * string = (char *)arg0;
+        // check string in user space
+        error = vmm_get_vseg( process , (intptr_t)arg0 , &vseg );
+        if( error )
+        {
+        ////////////////////
+        case DISPLAY_STRING:
+        {
+            char      kbuf[512];
+            uint32_t  length;
+            char    * string = (char *)arg0;
+            // check string in user space
+            error = vmm_get_vseg( process , (intptr_t)arg0 , &vseg );
+            if( error )
+            {
 #if DEBUG_SYSCALLS_ERROR
 …
 __FUNCTION__ , (intptr_t)arg0 );
 #endif
+                this->errno = EINVAL;
+                return -1;
+            }
+            // ckeck string length
+            length = hal_strlen_from_uspace( string );
+            if( length >= 512 )
+            {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for STRING : string length %d too large\n",
+__FUNCTION__ , length );
+#endif
+                this->errno = EINVAL;
+                return -1;
+            }
+            // copy string to kernel space
+            hal_strcpy_from_uspace( kbuf , string , 512 );
+            // print message on TXT0 kernel terminal
+            printk("\n%s / cycle %d\n", kbuf, (uint32_t)hal_get_cycles() );
+            break;
+        }
+        /////////////////
+        case DISPLAY_VMM:
+        {
+            cxy_t cxy = (cxy_t)arg0;
+            pid_t pid = (pid_t)arg1;
+            // check cxy argument
+                if( cluster_is_undefined( cxy ) )
+            {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for VMM : process %x in cluster %x not found\n",
+__FUNCTION__ , pid , cxy );
+#endif
+                this->errno = EINVAL;
+                return -1;
+            }
+            // get extended pointer on process PID in cluster CXY
+            xptr_t process_xp = cluster_get_process_from_pid_in_cxy( cxy , pid );
+                if( process_xp == XPTR_NULL )
+            {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for VMM : process %x in cluster %x not found\n",
+__FUNCTION__ , pid , cxy );
+#endif
+                this->errno = EINVAL;
+                return -1;
+            }
+            // get local pointer on process
+            process_t * process = (process_t *)GET_PTR( process_xp );
+            // call kernel function
+            if( cxy == local_cxy )
+            {
+                    vmm_display( process , true );
+            }
+            else
+            {
+                rpc_vmm_display_client( cxy , process , true );
+            }
+            break;
+        }
+        ///////////////////
+        case DISPLAY_SCHED:
+        {
+            cxy_t cxy = (cxy_t)arg0;
+            lid_t lid = (lid_t)arg1;
+            // check cxy argument
+                if( cluster_is_undefined( cxy ) )
+            {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for SCHED : illegal cxy argument %x\n",
+__FUNCTION__ , cxy );
+#endif
+                this->errno = EINVAL;
+                return -1;
+            }
+            // check lid argument
+            if( lid >= LOCAL_CLUSTER->cores_nr )
+            {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for SCHED : illegal lid argument %x\n",
+__FUNCTION__ , lid );
+#endif
+                this->errno = EINVAL;
+                return -1;
+            }
+            if( cxy == local_cxy )
+            {
+                    sched_display( lid );
+            }
+            else
+            {
+                sched_remote_display( cxy , lid );
+            }
+            break;
+        }
+        ///////////////////////////////
+        case DISPLAY_CLUSTER_PROCESSES:
+        {
+            cxy_t  cxy   = (cxy_t)arg0;
+            bool_t owned = (bool_t)arg1;
+            // check cxy argument
+                if( cluster_is_undefined( cxy ) )
+            {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for CLUSTER_PROCESSES : illegal cxy argument %x\n",
+__FUNCTION__ , cxy );
+#endif
+                this->errno = EINVAL;
+                return -1;
+            }
+            cluster_processes_display( cxy , owned );
+            break;
+        }
+        /////////////////
+        case DISPLAY_VFS:
+        {
+            vfs_display( process->vfs_root_xp );
+            break;
+        }
+        ///////////////////
+        case DISPLAY_CHDEV:
+        {
+            chdev_dir_display();
+            break;
+        }
+        ///////////////////////////
+        case DISPLAY_TXT_PROCESSES:
+        {
+            uint32_t txt_id = (uint32_t)arg0;
+            // check argument
+                if( txt_id >= LOCAL_CLUSTER->nb_txt_channels )
+            {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for TXT_PROCESSES : illegal txt_id argument %d\n",
+__FUNCTION__ , txt_id );
+#endif
+                this->errno = EINVAL;
+                return -1;
+            }
+            process_txt_display( txt_id );
+            break;
+        }
+        //////////////////
+        case DISPLAY_DQDT:
+        {
+            dqdt_display();
+            break;
+        }
+        ///////////////////////
+        case DISPLAY_BUSYLOCKS:
+        {
+            pid_t   pid   = (pid_t)arg0;
+            trdid_t trdid = (trdid_t)arg1;
+            // get extended pointer on target thread
+            xptr_t thread_xp = thread_get_xptr( pid , trdid );
+            if( thread_xp == XPTR_NULL )
+            {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for BUSYLOCKS : thread[%x,%x] not found\n",
+__FUNCTION__ , pid, trdid );
+#endif
+                this->errno = EINVAL;
+                return -1;
+            }
+            thread_display_busylocks( thread_xp , __FUNCTION__ );
+            break;
+        }
+        ////////////////////
+        case DISPLAY_MAPPER:
+        {
+            xptr_t        root_inode_xp;
+            xptr_t        inode_xp;
+            cxy_t         inode_cxy;
+            vfs_inode_t * inode_ptr;
+            xptr_t        mapper_xp;
+            mapper_t    * mapper_ptr;
+            char          kbuf[CONFIG_VFS_MAX_PATH_LENGTH];
+            char     * path    = (char *)arg0;
+            uint32_t   page_id = (uint32_t)arg1;
+            uint32_t   nbytes  = (uint32_t)arg2;
+            // check pathname length
+            if( hal_strlen_from_uspace( path ) >= CONFIG_VFS_MAX_PATH_LENGTH )
+            {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for MAPPER : pathname too long\n",
+ __FUNCTION__ );
+#endif
+                this->errno = ENFILE;
+                return -1;
+            }
+            // copy pathname in kernel space
+            hal_strcpy_from_uspace( kbuf , path , CONFIG_VFS_MAX_PATH_LENGTH );
+            // compute root inode for pathname
+            if( kbuf[0] == '/' )                        // absolute path
+            {
+                // use extended pointer on VFS root inode
+                root_inode_xp = process->vfs_root_xp;
+            }
+            else                                        // relative path
+            {
+                // get cluster and local pointer on reference process
+                xptr_t      ref_xp  = process->ref_xp;
+                process_t * ref_ptr = (process_t *)GET_PTR( ref_xp );
+                cxy_t       ref_cxy = GET_CXY( ref_xp );
+                // get extended pointer on CWD inode
+                root_inode_xp = hal_remote_l64( XPTR( ref_cxy , &ref_ptr->cwd_xp ) );
+            }
+            // get extended pointer on target inode
+            error = vfs_lookup( root_inode_xp,
+                                kbuf,
+,
+                                &inode_xp,
+                                NULL );
+            if( error )
+                {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for MAPPER : cannot found inode <%s>\n",
+__FUNCTION__ , kbuf );
+#endif
+                        this->errno = ENFILE;
+                        return -1;
+                }
+            // get target inode cluster and local pointer
+            inode_cxy = GET_CXY( inode_xp );
+            inode_ptr = GET_PTR( inode_xp );
+            // get extended pointer on target mapper
+            mapper_ptr = hal_remote_lpt( XPTR( inode_cxy , &inode_ptr->mapper ) );
+            mapper_xp  = XPTR( inode_cxy , mapper_ptr );
+            // display mapper
+            error = mapper_display_page( mapper_xp , page_id , nbytes );
+            if( error )
+                {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for MAPPER : cannot display page %d\n",
+__FUNCTION__ , page_id );
+#endif
+                        this->errno = ENFILE;
+                        return -1;
+                }
+            break;
+        }
+        /////////////////////
+        case DISPLAY_BARRIER:
+        {
+            // get target process PID
+            pid_t pid = (pid_t)arg0;
+            // get pointers on owner process
+            xptr_t      process_xp  = cluster_get_reference_process_from_pid( pid );
+            process_t * process_ptr = GET_PTR( process_xp );
+            cxy_t       process_cxy = GET_CXY( process_xp );
+            if( process_xp == XPTR_NULL )
+            {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for BARRIER : process %x not found\n",
+__FUNCTION__ , pid );
+#endif
+                this->errno = EINVAL;
+                return -1;
+            }
+            // get extended pointer on root of list of barriers
+            xptr_t root_xp = XPTR( process_cxy , &process_ptr->barrier_root );
+            if( xlist_is_empty( root_xp ) )
+            {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for BARRIER : no registered barrier in process %x\n",
+__FUNCTION__ , pid );
+#endif
+                this->errno = EINVAL;
+                return -1;
+            }
+            // get extended pointer on first registered generic barrier descriptor
+            xptr_t gen_barrier_xp  = XLIST_FIRST( root_xp , generic_barrier_t , list );
+            // display barrier state
+            generic_barrier_display( gen_barrier_xp );
+            break;
+        }
+        ////////
+        default:
+        {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : undefined display type %d\n",
+        __FUNCTION__ , type );
+#endif
             this->errno = EINVAL;
             return -1;
+        }
+        // ckeck string length
+        length = hal_strlen_from_uspace( string );
+        if( length >= 512 )
+        {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for STRING : string length %d too large\n",
+__FUNCTION__ , length );
+#endif
+            this->errno = EINVAL;
+            return -1;
+        }
+        // copy string to kernel space
+        hal_strcpy_from_uspace( kbuf , string , 512 );
+        // print message on TXT0 kernel terminal
+        printk("\n%s / cycle %d\n", kbuf, (uint32_t)hal_get_cycles() );
+    }
+    //////////////////////////////
+    else if( type == DISPLAY_VMM )
+    {
+        cxy_t cxy = (cxy_t)arg0;
+        pid_t pid = (pid_t)arg1;
+        // check cxy argument
+            if( cluster_is_undefined( cxy ) )
+        {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for VMM : process %x in cluster %x not found\n",
+__FUNCTION__ , pid , cxy );
+#endif
+            this->errno = EINVAL;
+            return -1;
+        }
+        // get extended pointer on process PID in cluster CXY
+        xptr_t process_xp = cluster_get_process_from_pid_in_cxy( cxy , pid );
+            if( process_xp == XPTR_NULL )
+        {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for VMM : process %x in cluster %x not found\n",
+__FUNCTION__ , pid , cxy );
+#endif
+            this->errno = EINVAL;
+            return -1;
+        }
+        // get local pointer on process
+        process_t * process = (process_t *)GET_PTR( process_xp );
+        // call kernel function
+        if( cxy == local_cxy )
+        {
+                vmm_display( process , true );
+        }
+        else
+        {
+            rpc_vmm_display_client( cxy , process , true );
+        }
+    }
+    ////////////////////////////////
+    else if( type == DISPLAY_SCHED )
+    {
+        cxy_t cxy = (cxy_t)arg0;
+        lid_t lid = (lid_t)arg1;
+        // check cxy argument
+            if( cluster_is_undefined( cxy ) )
+        {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for SCHED : illegal cxy argument %x\n",
+__FUNCTION__ , cxy );
+#endif
+            this->errno = EINVAL;
+            return -1;
+        }
+        // check lid argument
+        if( lid >= LOCAL_CLUSTER->cores_nr )
+        {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for SCHED : illegal lid argument %x\n",
+__FUNCTION__ , lid );
+#endif
+            this->errno = EINVAL;
+            return -1;
+        }
+        if( cxy == local_cxy )
+        {
+                sched_display( lid );
+        }
+        else
+        {
+            sched_remote_display( cxy , lid );
+        }
+    }
+    ////////////////////////////////////////////
+    else if( type == DISPLAY_CLUSTER_PROCESSES )
+    {
+        cxy_t  cxy   = (cxy_t)arg0;
+        bool_t owned = (bool_t)arg1;
+        // check cxy argument
+            if( cluster_is_undefined( cxy ) )
+        {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for CLUSTER_PROCESSES : illegal cxy argument %x\n",
+__FUNCTION__ , cxy );
+#endif
+            this->errno = EINVAL;
+            return -1;
+        }
+        cluster_processes_display( cxy , owned );
+    }
+    //////////////////////////////
+    else if( type == DISPLAY_VFS )
+    {
+        vfs_display( process->vfs_root_xp );
+    }
+    ////////////////////////////////
+    else if( type == DISPLAY_CHDEV )
+    {
+        chdev_dir_display();
+    }
+    ////////////////////////////////////////
+    else if( type == DISPLAY_TXT_PROCESSES )
+    {
+        uint32_t txt_id = (uint32_t)arg0;
+        // check argument
+            if( txt_id >= LOCAL_CLUSTER->nb_txt_channels )
+        {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for TXT_PROCESSES : illegal txt_id argument %d\n",
+__FUNCTION__ , txt_id );
+#endif
+            this->errno = EINVAL;
+            return -1;
+        }
+        process_txt_display( txt_id );
+    }
+    ///////////////////////////////
+    else if( type == DISPLAY_DQDT )
+    {
+        dqdt_display();
+    }
+    ////////////////////////////////////
+    else if( type == DISPLAY_BUSYLOCKS )
+    {
+        pid_t   pid   = (pid_t)arg0;
+        trdid_t trdid = (trdid_t)arg1;
+        // get extended pointer on target thread
+        xptr_t thread_xp = thread_get_xptr( pid , trdid );
+        if( thread_xp == XPTR_NULL )
+        {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for BUSYLOCKS : thread[%x,%x] not found\n",
+__FUNCTION__ , pid, trdid );
+#endif
+            this->errno = EINVAL;
+            return -1;
+        }
+        thread_display_busylocks( thread_xp , __FUNCTION__ );
+    }
+    /////////////////////////////////
+    else if( type == DISPLAY_MAPPER )
+    {
+        xptr_t        root_inode_xp;
+        xptr_t        inode_xp;
+        cxy_t         inode_cxy;
+        vfs_inode_t * inode_ptr;
+        xptr_t        mapper_xp;
+        mapper_t    * mapper_ptr;
+        char          kbuf[CONFIG_VFS_MAX_PATH_LENGTH];
+        char     * path    = (char *)arg0;
+        uint32_t   page_id = (uint32_t)arg1;
+        uint32_t   nbytes  = (uint32_t)arg2;
+        // check pathname length
+        if( hal_strlen_from_uspace( path ) >= CONFIG_VFS_MAX_PATH_LENGTH )
+        {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for MAPPER : pathname too long\n",
+ __FUNCTION__ );
+#endif
+            this->errno = ENFILE;
+            return -1;
+        }
+        // copy pathname in kernel space
+        hal_strcpy_from_uspace( kbuf , path , CONFIG_VFS_MAX_PATH_LENGTH );
+        // compute root inode for pathname
+        if( kbuf[0] == '/' )                        // absolute path
+        {
+            // use extended pointer on VFS root inode
+            root_inode_xp = process->vfs_root_xp;
+        }
+        else                                        // relative path
+        {
+            // get cluster and local pointer on reference process
+            xptr_t      ref_xp  = process->ref_xp;
+            process_t * ref_ptr = (process_t *)GET_PTR( ref_xp );
+            cxy_t       ref_cxy = GET_CXY( ref_xp );
+            // use extended pointer on CWD inode
+            root_inode_xp = hal_remote_l64( XPTR( ref_cxy , &ref_ptr->cwd_xp ) );
+        }
+        // get extended pointer on target inode
+        error = vfs_lookup( root_inode_xp,
+                            kbuf,
+,
+                            &inode_xp,
+                            NULL );
+        if( error )
+            {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for MAPPER : cannot found inode <%s>\n",
+__FUNCTION__ , kbuf );
+#endif
+                    this->errno = ENFILE;
+                    return -1;
+            }
+        // get target inode cluster and local pointer
+        inode_cxy = GET_CXY( inode_xp );
+        inode_ptr = GET_PTR( inode_xp );
+        // get extended pointer on target mapper
+        mapper_ptr = hal_remote_lpt( XPTR( inode_cxy , &inode_ptr->mapper ) );
+        mapper_xp  = XPTR( inode_cxy , mapper_ptr );
+        // display mapper
+        error = mapper_display_page( mapper_xp , page_id , nbytes );
+        if( error )
+            {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for MAPPER : cannot display page %d\n",
+__FUNCTION__ , page_id );
+#endif
+                    this->errno = ENFILE;
+                    return -1;
+            }
+    }
+    ////
+    else
+    {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : undefined display type %d\n",
+        __FUNCTION__ , type );
+#endif
+        this->errno = EINVAL;
+        return -1;
+    }
+    }  // end switch on type
 #if (DEBUG_SYS_DISPLAY || CONFIG_INSTRUMENTATION_SYSCALLS)

trunk/kernel/syscalls/sys_mmap.c

-                      r611
+                      r623
 #if DEBUG_SYS_MMAP
+tm_start = hal_get_cycles();
+if ( DEBUG_SYS_MMAP < tm_start )
+if( DEBUG_SYS_MMAP < tm_start )
 printk("\n[%s] thread[%x,%x] enter / cycle %d\n",
 __FUNCTION__, process->pid, this->trdid, (uint32_t)tm_start );
 …
 #endif
+#if CONFIG_INSTRUMENTATION_SYSCALLS
+hal_atomic_add( &syscalls_cumul_cost[SYS_MMAP] , tm_end - tm_start );
+hal_atomic_add( &syscalls_occurences[SYS_MMAP] , 1 );
+#endif
 #if DEBUG_SYS_MMAP
 if ( DEBUG_SYS_MMAP < tm_start )
+if ( DEBUG_SYS_MMAP < tm_end )
 printk("\n[%s] thread[%x,%x] exit / %s / cxy %x / base %x / size %d / cycle %d\n",
 __FUNCTION__, process->pid, this->trdid,

trunk/kernel/syscalls/sys_munmap.c

-                      r506
+                      r623
 #include <hal_kernel_types.h>
 #include <hal_uspace.h>
+#include <hal_irqmask.h>
 #include <shared_syscalls.h>
 #include <errno.h>
 …
+{
     error_t       error;
+    vseg_t      * vseg;
+    reg_t         save_sr;      // required to enable IRQs
         thread_t    * this    = CURRENT_THREAD;
         process_t   * process = this->process;
+#if (DEBUG_SYS_MUNMAP || CONFIG_INSTRUMENTATION_SYSCALLS)
+uint64_t     tm_start = hal_get_cycles();
+#endif
 #if DEBUG_SYS_MUNMAP
-uint64_t tm_start;
-uint64_t tm_end;
-tm_start = hal_get_cycles();
 if( DEBUG_SYS_MUNMAP < tm_start )
 printk("\n[DBG] %s : thread %x enter / process %x / cycle %d\n"
+printk("\n[DBG] %s : thread %x enter / process %x / cycle %d\n",
 __FUNCTION__ , this, process->pid, (uint32_t)tm_start );
 #endif
+    // check user buffer is mapped
+    error = vmm_get_vseg( process , (intptr_t)vaddr, &vseg );
+    if( error )
+    {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : thread[%x,%x] / user buffer unmapped %x\n",
+__FUNCTION__ , process->pid, this->trdid, (intptr_t)vaddr );
+vmm_display( process , false );
+#endif
+                this->errno = EINVAL;
+                return -1;
+    }
+    // enable IRQs
+    hal_enable_irq( &save_sr );
     // call relevant kernel function
 …
+    }
+    // restore IRQs
+    hal_restore_irq( save_sr );
+#if (DEBUG_SYS_MUNMAP || CONFIG_INSTRUMENTATION_SYSCALLS)
+uint64_t     tm_end = hal_get_cycles();
+#endif
+#if CONFIG_INSTRUMENTATION_SYSCALLS
+hal_atomic_add( &syscalls_cumul_cost[SYS_MUNMAP] , tm_end - tm_start );
+hal_atomic_add( &syscalls_occurences[SYS_MUNMAP] , 1 );
+#endif
 #if DEBUG_SYS_MUNMAP
-tm_end = hal_get_cycles();
 if( DEBUG_SYS_MUNMAP < tm_start )
 printk("\n[DBG] %s : thread %x exit / process %x / cycle %d\n"
+printk("\n[DBG] %s : thread %x exit / process %x / cycle %d\n",
 __FUNCTION__ , this, process->pid, (uint32_t)tm_end );
 #endif

trunk/kernel/syscalls/sys_place_fork.c

r584	r623
2	2	* sys_get_core.c - get calling core cluster and local index.
3	3	*
4		* Author Alain Greiner (2016,2017)
	4	* Author Alain Greiner (2016,2017,2018,2019)
5	5	*
6	6	* Copyright (c) UPMC Sorbonne Universites

trunk/kernel/syscalls/sys_write.c

-                      r610
+                      r623
+        }
         // update size field in inode if required
         xptr_t   size_xp    = XPTR( file_cxy , &inode_ptr->size );
         uint32_t inode_size = hal_remote_l32( size_xp );
         if ( (file_offset + count) > inode_size )
+        {
             hal_remote_s32( size_xp , file_offset + count );
+        }
+        // update file size in inode descriptor
+        // only if (file_offset + count) > current_size
+        // note: the parent directory entry in mapper will
+        // be updated by the close syscall
+        xptr_t inode_xp = XPTR( file_cxy , inode_ptr );
+        vfs_inode_update_size( inode_xp , file_offset + count );
+    }
     else if( file_type == INODE_TYPE_DEV )  // write to TXT device

trunk/kernel/syscalls/syscalls.h

-                      r619
+                      r623
 /******************************************************************************************
  * [15] This function writes bytes to an open file identified by its file descriptor.
+ * The file can be a regular file or character oriented device.
+ * The file can be a regular file or character oriented device. For a regular file,
+ * the target inode "size" field is updated if (offset + count) is larger than the
+ * current "size" value. The size value registered in the mappers of the parent(s)
+ * directory are not modified and will be asynchronously updated when the file is closed.
  * IRQs are enabled during this system call.
  ******************************************************************************************
 …
 /******************************************************************************************
+ * [23] This function open a directory, that must exist in the file system, returning
+ * a DIR pointer on the dirent array in user space.
+ * [23] This function creates an user level directory descriptor (including the associated
+ * array of user level dirents), and intialise it from the kernel directory mapper, that
+ * contains all entries in this directory). The directory is identified by the <pathname>
+ * argument. If the corresponding inode is missing in the Inode Tree, the inode is created,
+ * but the directory must exist in the file system.
+ * It returns a DIR pointer <dirp> on the dirent array in user space.
  ******************************************************************************************
  * @ pathname   : [in]  pathname (can be relative or absolute).

trunk/libs/libalmosmkh/almosmkh.c

-                      r611
+                      r623
                              (reg_t)page_id,
                              (reg_t)nbytes );
+}
+///////////////////////////////////////
+int display_barrier( unsigned int pid )
+{
+    return hal_user_syscall( SYS_DISPLAY,
+                             DISPLAY_BARRIER,
+                             (reg_t)pid, 0, 0 );
+}

trunk/libs/libalmosmkh/almosmkh.h

-                      r611
+                      r623
                     unsigned int  nbytes);
+/***************************************************************************************
+ * This debug syscall displays on the kernel terminal TXT0
+ * the state of the barrier used by the process identified by the <pid> argument.
+ * It can be called by any thread running in any cluster.
+ ***************************************************************************************
+ * @ pid      : [in] process identifier.
+ * @ return 0 if success / return -1 if illegal arguments.
+ **************************************************************************************/
+int display_barrier( unsigned int pid );
 /*****************************************************************************************
 * This debug syscall is used to activate / desactivate the context switches trace

trunk/libs/mini-libc/mman.h

-                      r597
+                      r623
  * virtual space, as defined by the arguments.
  *****************************************************************************************
  * @ addr    : requested address in virtual space / unused : should be NULL.
+ * @ addr    : requested address in virtual space / unsupported : should be NULL.
  * @ length  : requested number of bytes.
  * @ prot    : access mode bit vector (PROT_EXEC / PROT_READ / PROT_WRITE)
  * @ flags   : bit_vector (MAP_FILE / MAP_ANON / MAPREMOTE / MAP_PRIVATE / MAP_SHARED)
+ * @ flags   : bit_vector (MAP_FILE / MAP_ANON / MAP_REMOTE / MAP_PRIVATE / MAP_SHARED)
  * @ fdid    : file descriptor index (if MAP_FILE).
  * @ offset  : offset in file (if MAP_FILE).

trunk/libs/mini-libc/stdio.c

-                      r610
+                      r623
 ////////////////////////////////////////////////////////////////////////////////////////
+// This user space array registers all FILE descriptors open by a given process
 FILE open_file_array[MAX_OPEN_FILE_PER_PROCESS];  // array of open files structures
 …
     if( mode != NULL )
+    {
         printf("\n[ERROR] in %s : the mode argument must be NULL\n", __FUNCTION__ );
+        printf("\n[%s] error : the mode argument must be NULL\n", __FUNCTION__ );
         return NULL;
+    }
 …
     if( fd < 0 )
+    {
         printf("\n[ERROR] in %s : file %s not found\n", __FUNCTION__ , pathname );
+        printf("\n[%s] error : file <%s> not found\n", __FUNCTION__ , pathname );
         return NULL;
+    }
     if( fd > MAX_OPEN_FILE_PER_PROCESS )
+    {
         printf("\n[ERROR] in %s : not enough space for file %s\n", __FUNCTION__ , pathname );
+        printf("\n[%s] error : not enough space for file <%s>\n", __FUNCTION__ , pathname );
         return NULL;
+    }
 …
     return &open_file_array[fd];
 }  // end fopen()
 …
     int fd = stream->fd;
     // remove stream from open_file_array[]
+    // remove stream from user open_file_array[]
     open_file_array[fd].key = 0;
+    return close( fd );
+    // close the kernel file descriptor
+    if( close( fd ) )
+    {
+        printf("\n[%s] error : cannot close file %d\n", __FUNCTION__ , fd );
+        return -1;
+    }
+    return 0;
 }  // end fclose()
 …
         // get file descriptor from file pointer
         fd = stream->fd;
+        // set terminating NUL
         string[count] = 0;
+printf("\n[%s] fd = %d for string :\n", __FUNCTION__, fd, string );
         return write( fd , &string , count );
+    }

trunk/libs/mini-libc/stdio.h

-                      r610
+                      r623
  ********************************************************************************************/
 typedef struct file_s
+typedef struct stream_s
+{
     int fd;
     int key;
+    int fd;          // index in both kernel fd_array[], and user open_file_array[]
+    int key;         // entry valid in open_file_array[] when (key == VALID_OPEN_FILE)
+}
 FILE;

trunk/params-hard.mk

-                      r620
+                      r623
 ARCH      = /users/alain/soc/tsar-trunk-svn-2013/platforms/tsar_generic_iob
 X_SIZE    = 2
 Y_SIZE    = 2
+X_SIZE    = 1
+Y_SIZE    = 1
 NB_PROCS  = 1
 NB_TTYS   = 3

trunk/user/init/init.c

-                      r588
+                      r623
 // and avoid the hard_config include [AG]
-// TODO introduce a communication channel between INIT and KSH
-// to allow KSH to signal INIT the exec completion.
 ////////////////
 int main( void )
 …
 #if DEBUG_PROCESS_INIT
 display_string("[INIT] process enters");
+display_string("[init] process enters");
 #endif
 …
+        {
             // INIT display error message
             snprintf( string , 64 , "[INIT ERROR] cannot fork child[%d] => suicide" , i );
+            snprintf( string , 64 , "[init ERROR] cannot fork child[%d] => suicide" , i );
             display_string( string );
 …
                 // CHILD[i] display error message
                 snprintf( string , 64 ,
                 "[INIT ERROR] CHILD[%d] cannot exec KSH / ret_exec = %d" , i , ret_exec );
+                "[init ERROR] CHILD[%d] cannot exec KSH / ret_exec = %d" , i , ret_exec );
                 display_string( string );
+            }
 …
+        {
             // INIT display CHILD[i] process PID
             snprintf( string , 64 , "[INIT] created KSH[%d] / pid = %x", i , ret_fork );
+            snprintf( string , 64 , "[init] created KSH[%d] / pid = %x", i , ret_fork );
             display_string( string );
 …
+        {
             // display string to report unexpected KSH process block
             snprintf( string , 64 , "[INIT] KSH process %x stopped => unblock it" , rcv_pid );
+            snprintf( string , 64 , "[init] KSH process %x stopped => unblock it" , rcv_pid );
             display_string( string );
 …
+        {
             // display string to report KSH process termination
             snprintf( string , 64 , "[INIT] KSH process %x terminated => recreate", rcv_pid );
+            snprintf( string , 64 , "[init] KSH process %x terminated => recreate", rcv_pid );
             display_string( string );
 …
+            {
                 // INIT display error message
                 snprintf( string , 64 , "[INIT ERROR] cannot fork child => suicide");
+                snprintf( string , 64 , "[init ERROR] cannot fork child => suicide");
                 display_string( string );
 …
+                {
                     // CHILD display error message on TXT0 terminal
                     snprintf( string , 64 , "[INIT ERROR] CHILD cannot exec KSH" );
+                    snprintf( string , 64 , "[init ERROR] CHILD cannot exec KSH" );
                     display_string( string );
+                }
 …
+            {
                 // INIT display new KSH process PID
                 snprintf( string , 64 , "[INIT] re-created KSH / pid = %x", ret_fork );
+                snprintf( string , 64 , "[init] re-created KSH / pid = %x", ret_fork );
                 display_string( string );
+            }

trunk/user/ksh/ksh.c

-                      r619
+                      r623
 #define DEBUG_INTER         0
 #define DEBUG_PARSE         0
 #define DEBUG_CMD_CAT       0
+#define DEBUG_CMD_CAT       1
 #define DEBUG_CMD_CP        0
 #define DEBUG_CMD_LOAD      0
 …
         if (argc != 2)
+    {
-        fd   = -1;
-        buf  = NULL;
-        size = 0;
                 printf("  usage: cat pathname\n");
+            goto cmd_cat_exit;
+        sem_post( &semaphore );
+            return;
+    }
 …
     if (fd < 0)
+    {
-        buf  = NULL;
-        size = 0;
             printf("  error: cannot open file <%s>\n", path);
+            goto cmd_cat_exit;
+        sem_post( &semaphore );
+            return;
+    }
 #if DEBUG_CMD_CAT
 snprintf( string , 64 , "[KSH] %s : file %s open", __FUNCTION__, path );
+snprintf( string , 64 , "[ksh] %s : file %s open", __FUNCTION__, path );
 display_string( string );
 #endif
 …
     if ( stat( path , &st ) == -1)
+    {
-        buf  = NULL;
-        size = 0;
             printf("  error: cannot stat <%s>\n", path);
+            goto cmd_cat_exit;
+            close(fd);
+        sem_post( &semaphore );
+            return;
+    }
         if ( S_ISDIR(st.st_mode) )
+    {
-        buf  = NULL;
-        size = 0;
             printf("  error: <%s> is a directory\n", path);
+            goto cmd_cat_exit;
+            close(fd);
+        sem_post( &semaphore );
+            return;
+    }
 …
 #if DEBUG_CMD_CAT
+snprintf( string , 64 , "[KSH] %s : get size = %d", __FUNCTION__, size );
+display_string( string );
+#endif
+    // MAP_FILE is default type when MAP_ANON and MAP_REMOTE are not specified
+snprintf( string , 64 , "[ksh] %s : size = %d", __FUNCTION__, size );
+display_string( string );
+#endif
+    if( size == 0 )
+    {
+            printf("  error: size = 0 for <%s>\n", path);
+            close(fd);
+        sem_post( &semaphore );
+            return;
+    }
+    // mapping type is MAP_FILE when MAP_ANON and MAP_REMOTE are not specified
     buf = mmap( NULL , size , PROT_READ|PROT_WRITE , MAP_PRIVATE , fd , 0 );
 …
+    {
             printf("  error: cannot map file <%s>\n", path );
+            goto cmd_cat_exit;
+            close(fd);
+        sem_post( &semaphore );
+            return;
+    }
 #if DEBUG_CMD_CAT
+snprintf( string , 64 , "[KSH] %s : map file %d to buffer %x", __FUNCTION__, fd , buf );
+display_string( string );
+display_vmm( 0 , getpid() );
+snprintf( string , 64 , "[ksh] %s : maped file %d to buffer %x", __FUNCTION__, fd , buf );
+display_string( string );
+// unsigned int pid = getpid();
+// unsigned int cxy = pid >> 16;
+// display_vmm( cxy , pid );
 #endif
 …
     write( 1 , buf , size );
+    // release semaphore to get next command
+    sem_post( &semaphore );
+    return;
+cmd_cat_exit:
+        if (buf != NULL) munmap(buf, size);
+        if (fd >= 0) close(fd);
+    // unmap te file
+    if( munmap( buf , size ) )
+    {
+            printf("  error: cannot unmap file <%s>\n", path );
+    }
+#if DEBUG_CMD_CAT
+snprintf( string , 64 , "[ksh] %s : unmaped file %d from buffer %x", __FUNCTION__, fd , buf );
+display_string( string );
+// display_vmm( cxy , pid );
+#endif
+    // close the file
+        if( close( fd ) )
+    {
+            printf("  error: cannot close file <%s>\n", path );
+    }
     // release semaphore to get next command
 …
 #if DEBUG_CMD_CP
 snprintf( string , 64 , "[KSH] %s : file %s open", __FUNCTION__, srcpath );
+snprintf( string , 64 , "[ksh] %s : file %s open", __FUNCTION__, srcpath );
 display_string( string );
 #endif
 …
 #if DEBUG_CMD_CP
 snprintf( string , 64 , "[KSH] %s : got stats for %s", __FUNCTION__, srcpath );
+snprintf( string , 64 , "[ksh] %s : got stats for %s", __FUNCTION__, srcpath );
 display_string( string );
 #endif
 …
 #if DEBUG_CMD_CP
 snprintf( string , 64 , "[KSH] %s : file %s open", __FUNCTION__, dstpath );
+snprintf( string , 64 , "[ksh] %s : file %s open", __FUNCTION__, dstpath );
 display_string( string );
 #endif
 …
 #if DEBUG_CMD_CP
 snprintf( string , 64 , "[KSH] %s : got stats for %s", __FUNCTION__, dstpath );
+snprintf( string , 64 , "[ksh] %s : got stats for %s", __FUNCTION__, dstpath );
 display_string( string );
 #endif
 …
 #if DEBUG_CMD_CP
 snprintf( string , 64 , "[KSH] %s : read %d bytes from %s", __FUNCTION__, len, srcpath );
+snprintf( string , 64 , "[ksh] %s : read %d bytes from %s", __FUNCTION__, len, srcpath );
 display_string( string );
 #endif
 …
 #if DEBUG_CMD_CP
 snprintf( string , 64 , "[KSH] %s : write %d bytes to %s", __FUNCTION__, len, dstpath );
+snprintf( string , 64 , "[ksh] %s : write %d bytes to %s", __FUNCTION__, len, dstpath );
 display_string( string );
 #endif
 …
                "         display  dqdt\n"
                "         display  locks    pid    trdid\n"
+               "         display  barrier  pid\n"
                "         display  mapper   path   page_id  nbytes\n");
+    }
 …
+            {
                 printf("  error: illegal arguments pid = %x / trdid = %x\n", pid, trdid );
+            }
+        }
+    }
+    /////////////////////////////////////////////////
+    else if( strcmp( argv[1] , "barrier" ) == 0 )
+    {
+        if( argc != 3 )
+        {
+                    printf("  usage: display barrier pid\n");
+            }
+        else
+        {
+                unsigned int pid   = atoi(argv[2]);
+            if( display_barrier( pid ) )
+            {
+                printf("  error: illegal arguments pid = %x\n", pid );
+            }
+        }
 …
 #if DEBUG_CMD_LOAD
 snprintf( string , 64 , "[KSH] %s : ksh_pid %x / path %s / bg %d / place %d (%x)\n",
+snprintf( string , 64 , "[ksh] %s : ksh_pid %x / path %s / bg %d / place %d (%x)\n",
 __FUNCTION__, ksh_pid, argv[1], background, placement, cxy );
 display_string( string );
 …
 #if DEBUG_CMD_LOAD
 snprintf( string , 64 , "[KSH] %s : child_pid %x after fork, before exec\n",
+snprintf( string , 64 , "[ksh] %s : child_pid %x after fork, before exec\n",
 __FUNCTION__ , getpid() );
 display_string( string );
 …
 #if DEBUG_CMD_LOAD
 snprintf( string , 64 , "[KSH] %s : child_pid %x after exec / ret_exec %x\n",
+snprintf( string , 64 , "[ksh] %s : child_pid %x after exec / ret_exec %x\n",
 __FUNCTION__ , getpid(), ret_exec );
 display_string( string );
 …
 #if DEBUG_CMD_LOAD
 snprintf( string , 64 , "[KSH] %s : ksh_pid %x after fork / ret_fork %x\n",
+snprintf( string , 64 , "[ksh] %s : ksh_pid %x after fork / ret_fork %x\n",
 __FUNCTION__, getpid(), ret_fork );
 display_string( string );
 …
 #if DEBUG_CMD_LS
 snprintf( string , 64 , "[KSH] %s : directory <%s> open / DIR %x\n",
+snprintf( string , 64 , "[ksh] %s : directory <%s> open / DIR %x\n",
 __FUNCTION__, pathname , dir );
 display_string( string );
 …
+            {
                     printf("  error : directory <%s> not found\n", pathname );
+            goto cmd_ls_exit;
+            sem_post( &semaphore );
+            return;
+            }
 …
 #if DEBUG_CMD_LS
 snprintf( string , 64 , "[KSH] %s : directory <%s> closed\n",
+snprintf( string , 64 , "[ksh] %s : directory <%s> closed\n",
 __FUNCTION__, pathname );
 display_string( string );
 …
+    }
-cmd_ls_exit:
     // release semaphore to get next command
 …
 #if DEBUG_CMD_PS
 snprintf( string , 64 , "\n[KSH] %s : call display_cluster_process()", __FUNCTION__ );
+snprintf( string , 64 , "\n[ksh] %s : call display_cluster_process()", __FUNCTION__ );
 display_string( string );
 #endif
 …
 #if DEBUG_PARSE
 char string[64];
 snprintf( string , 64 , "\n[KSH] %s : <%s>", __FUNCTION__ , buf );
+snprintf( string , 64 , "\n[ksh] %s : <%s>", __FUNCTION__ , buf );
 display_string( string );
 #endif
 …
 #if DEBUG_PARSE
 snprintf( string , 64 , "\n[KSH] %s : argc = %d for <%s>", __FUNCTION__ , argc , argv[0] );
+snprintf( string , 64 , "\n[ksh] %s : argc = %d for <%s>", __FUNCTION__ , argc , argv[0] );
 display_string( string );
 #endif
 …
 #if DEBUG_INTER
 unsigned int pid = getpid();
 snprintf( string , 64 , "\n[KSH] %s : request a new command", __FUNCTION__ );
+snprintf( string , 64 , "\n[ksh] %s : request a new command", __FUNCTION__ );
 display_string( string );
 #endif
 …
 #if DEBUG_INTER
 snprintf( string , 64 , "[KSH] %s : parse and execute <%s>", __FUNCTION__, cmd );
+snprintf( string , 64 , "[ksh] %s : parse and execute <%s>", __FUNCTION__, cmd );
 display_string( string );
 #endif
 …
 #if DEBUG_INTER
 snprintf( string , 64 , "\n[KSH] %s : complete <%s> command", __FUNCTION__, cmd );
+snprintf( string , 64 , "\n[ksh] %s : complete <%s> command", __FUNCTION__, cmd );
 display_string( string );
 #endif

trunk/user/sort/sort.c

-                      r619
+                      r623
 #include <hal_macros.h>
 #define ARRAY_LENGTH        256        // number of values
+#define ARRAY_LENGTH        1024       // number of items
 #define MAX_THREADS         1024       // 16 * 16 * 4
+#define USE_DQT_BARRIER     1
+#define DISPLAY_ARRAY       0
+#define INTERACTIVE_MODE    0
+#define USE_DQT_BARRIER     1          // use DQT barrier if non zero
+#define DISPLAY_ARRAY       0          // display items values before and after
+#define VERBOSE             0          // for debug
+#define INTERACTIVE_MODE    0          // for debug
+#define CHECK_RESULT        0          // for debug
+#define INSTRUMENTATION     1          // register computation times on file
 /////////////////////////////////////////////////////////////
 …
 ///////////////////////////////////
 static void merge( const int * src,
                    int       * dst,
                    int         length,
                    int         init_pos_src_a,
                    int         init_pos_src_b,
                    int         init_pos_dst )
+static void merge( const int * src,               // source array
+                   int       * dst,               // destination array
+                   int         length,            // number of items in a subset
+                   int         init_pos_src_a,    // index first item in src subset A
+                   int         init_pos_src_b,    // index first item in src subset B
+                   int         init_pos_dst )     // index first item in destination
+{
     int i;
 …
     unsigned int       lid;
     int         * src_array  = NULL;
     int         * dst_array  = NULL;
+    int              * src_array  = NULL;
+    int              * dst_array  = NULL;
     // get core coordinates an date
 …
     unsigned int  main_uid   = ptr->main_uid;
+#if DISPLAY_ARRAY
+unsigned int n;
+if( thread_uid == main_uid )
+{
+    printf("\n*** array before sort\n");
+    for( n=0; n<ARRAY_LENGTH; n++) printf("array[%d] = %d\n", n , array0[n] );
+}
+#endif
+    /////////////////////////////////
+    pthread_barrier_wait( &barrier );
+#if VERBOSE
+printf("\n[sort] thread[%d] exit barrier 0\n", thread_uid );
+#endif
     unsigned int  items      = ARRAY_LENGTH / threads;
     unsigned int  stages     = __builtin_ctz( threads ) + 1;
+    printf("\n[SORT] thread[%d] : start\n", thread_uid );
+#if VERBOSE
+printf("\n[sort] thread[%d] : start\n", thread_uid );
+#endif
     bubbleSort( array0, items, items * thread_uid );
+    printf("\n[SORT] thread[%d] : stage 0 completed\n", thread_uid );
+#if VERBOSE
+printf("\n[sort] thread[%d] : stage 0 completed\n", thread_uid );
+#endif
     /////////////////////////////////
     pthread_barrier_wait( &barrier );
+    printf("\n[SORT] thread[%d] exit barrier 0\n", thread_uid );
+    // the number of threads contributing to sort
+    // is divided by 2 at each next stage
+#if VERBOSE
+printf("\n[sort] thread[%d] exit barrier 0\n", thread_uid );
+#endif
+#if DISPLAY_ARRAY
+if( thread_uid == main_uid )
+{
+    printf("\n*** array after bubble sort\n");
+    for( n=0; n<ARRAY_LENGTH; n++) printf("array[%d] = %d\n", n , array0[n] );
+}
+#endif
+    // the number of threads contributing to sort is divided by 2
+    // and the number of items is multiplied by 2 at each next stage
     for ( i = 1 ; i < stages ; i++ )
+    {
+        pthread_barrier_wait( &barrier );
+        if((i % 2) == 1)               // odd stage
+        {
+            src_array = array0;
+            dst_array = array1;
+        }
+        else                           // even stage
+        {
+            src_array = array1;
+            dst_array = array0;
+        }
         if( (thread_uid & ((1<<i)-1)) == 0 )
+        {
+            printf("\n[SORT] thread[%d] : stage %d start\n", thread_uid , i );
+            if((i % 2) == 1)               // odd stage
+            {
+                src_array = array0;
+                dst_array = array1;
+            }
+            else                           // even stage
+            {
+                src_array = array1;
+                dst_array = array0;
+            }
+#if VERBOSE
+printf("\n[sort] thread[%d] : stage %d start\n", thread_uid , i );
+#endif
             merge( src_array,
                    dst_array,
                    items << i,
+                   items << (i-1),
                    items * thread_uid,
                    items * (thread_uid + (1 << (i-1))),
                    items * thread_uid );
+            printf("\n[SORT] thread[%d] : stage %d completed\n", thread_uid , i );
+#if VERBOSE
+printf("\n[sort] thread[%d] : stage %d completed\n", thread_uid , i );
+#endif
+        }
         /////////////////////////////////
         pthread_barrier_wait( &barrier );
+        printf("\n[SORT] thread[%d] exit barrier %d\n", thread_uid , i );
+    }
+#if VERBOSE
+printf("\n[sort] thread[%d] exit barrier %d\n", thread_uid , i );
+#endif
+#if DISPLAY_ARRAY
+if( thread_uid == main_uid )
+{
+    printf("\n*** array after merge %d\n", i );
+    for( n=0; n<ARRAY_LENGTH; n++) printf("array[%d] = %d\n", n , dst_array[n] );
+}
+#endif
+    }  // en for stages
     // all threads but the main thread exit
 …
     unsigned int           lid;                // core local index for a thread
     unsigned int           n;                  // index in array to sort
-    unsigned long long     cycle;              // current date for log
     pthread_t              trdid;              // kernel allocated thread index (unused)
     pthread_barrierattr_t  barrier_attr;       // barrier attributes
+    unsigned long long     start_cycle;
+    unsigned long long     seq_end_cycle;
+    unsigned long long     para_end_cycle;
+    /////////////////////////
+    get_cycle( &start_cycle );
     // compute number of threads (one thread per core)
     get_config( &x_size , &y_size , &ncores );
 …
          (total_threads != 512) && (total_threads != 1024) )
+    {
         printf("\n[SORT ERROR] number of cores must be power of 2\n");
+        printf("\n[sort error] number of cores must be power of 2\n");
         exit( 0 );
+    }
 …
     if ( ARRAY_LENGTH % total_threads)
+    {
         printf("\n[SORT ERROR] array size must be multiple of number of threads\n");
+        printf("\n[sort error] array size must be multiple of number of threads\n");
         exit( 0 );
+    }
     printf("\n\n[SORT] main starts on core[%x,%d] / %d threads / %d values / PID %x\n",
     main_cxy, main_lid, total_threads, ARRAY_LENGTH, getpid() );
+    printf("\n\n[sort] main starts / %d threads / %d items / pid %x / cycle %d\n",
+    total_threads, ARRAY_LENGTH, getpid(), (unsigned int)start_cycle );
     // initialize barrier
 …
     if( error )
+    {
         printf("\n[SORT ERROR] cannot initialise barrier\n" );
+        printf("\n[sort error] cannot initialise barrier\n" );
         exit( 0 );
+    }
+    printf("\n[SORT] main completes barrier init\n");
+#if VERBOSE
+printf("\n[sort] main completes barrier init\n");
+#endif
     // Array to sort initialization
 …
+    }
+#if DISPLAY_ARRAY
+printf("\n*** array before sort\n");
+for( n=0; n<ARRAY_LENGTH; n++) printf("array[%d] = %d\n", n , array0[n] );
+#endif
+    printf("\n[SORT] main completes array init\n");
+#if VERBOSE
+printf("\n[sort] main completes array init\n");
+#endif
     // launch other threads to execute sort() function
 …
                                          &arg[thread_uid] ) ) // sort arguments
+                    {
                         printf("\n[SORT ERROR] main cannot create thread %x \n", thread_uid );
+                        printf("\n[sort error] main cannot create thread %x \n", thread_uid );
                         exit( 0 );
+                    }
                     else
+                    {
+                        printf("\n[SORT] main created thread %x \n", thread_uid );
+#if VERBOSE
+printf("\n[sort] main created thread %x \n", thread_uid );
+#endif
+                    }
+                }
 …
+    }
+    get_cycle( &cycle );
+    printf("\n[SORT] main completes threads create at cycle %d\n", (unsigned int)cycle );
+    ///////////////////////////
+    get_cycle( &seq_end_cycle );
+#if VERBOSE
+printf("\n[sort] main completes sequencial init at cycle %d\n",
+(unsigned int)seq_end_cycle );
+#endif
 #if INTERACTIVE_MODE
 …
     sort( &arg[main_uid] );
+    ////////////////////////////
+    get_cycle( &para_end_cycle );
+    printf("\n[sort] main completes parallel sort at cycle %d\n",
+    (unsigned int)para_end_cycle );
+    // destroy barrier
+    pthread_barrier_destroy( &barrier );
 #if INTERACTIVE_MODE
 idbg();
 #endif
+    // destroy barrier
+    pthread_barrier_destroy( &barrier );
+#if INTERACTIVE_MODE
+idbg();
+#endif
+    // Check result
+    int    success = 1;
+    int*   res_array = ( (total_threads ==   2) ||
+                         (total_threads ==   8) ||
+                         (total_threads ==  32) ||
+                         (total_threads == 128) ||
+                         (total_threads == 512) ) ? array1 : array0;
+    for( n=0 ; n<(ARRAY_LENGTH-2) ; n++ )
+    {
+        if ( res_array[n] > res_array[n+1] )
+        {
+            printf("\n[SORT] array[%d] = %d > array[%d] = %d\n",
+            n , res_array[n] , n+1 , res_array[n+1] );
+            success = 0;
+            break;
+        }
+    }
+#if DISPLAY_ARRAY
+printf("\n*** array after sort\n");
+for( n=0; n<ARRAY_LENGTH; n++) printf("array[%d] = %d\n", n , res_array[n] );
+#endif
+    get_cycle( &cycle );
+    if ( success )
+    {
+        printf("\n[SORT] success at cycle %d\n", (unsigned int)cycle );
+    }
+    else
+    {
+        printf("\n[SORT] failure at cycle %d\n", (unsigned int)cycle );
+    }
+#if INTERACTIVE_MODE
+idbg();
+#if CHECK_RESULT
+int    success = 1;
+int*   res_array = ( (total_threads ==   2) ||
+                     (total_threads ==   8) ||
+                     (total_threads ==  32) ||
+                     (total_threads == 128) ||
+                     (total_threads == 512) ) ? array1 : array0;
+for( n=0 ; n<(ARRAY_LENGTH-2) ; n++ )
+{
+    if ( res_array[n] > res_array[n+1] )
+    {
+        printf("\n[sort] array[%d] = %d > array[%d] = %d\n",
+        n , res_array[n] , n+1 , res_array[n+1] );
+        success = 0;
+        break;
+    }
+}
+if ( success ) printf("\n[sort] success\n");
+else           printf("\n[sort] failure\n");
+#endif
+#if INSTRUMENTATION
+char   name[64];
+char   path[128];
+// build a file name from n_items / n_clusters / n_cores
+if( USE_DQT_BARRIER ) snprintf( name , 64 , "sort_dqt_%d_%d_%d",
+                      ARRAY_LENGTH, x_size * y_size, ncores );
+else                  snprintf( name , 64 , "sort_smp_%d_%d_%d",
+                      ARRAY_LENGTH, x_size * y_size, ncores );
+// build file pathname
+snprintf( path , 128 , "home/%s" , name );
+// compute results
+unsigned int sequencial = (unsigned int)(seq_end_cycle - start_cycle);
+unsigned int parallel   = (unsigned int)(para_end_cycle - seq_end_cycle);
+// display results on process terminal
+printf("\n----- %s -----\n"
+       " - sequencial : %d cycles\n"
+       " - parallel   : %d cycles\n",
+       name, sequencial, parallel );
+// open file
+FILE * stream = fopen( path , NULL );
+if( stream == NULL )
+{
+    printf("\n[sort error] cannot open instrumentation file <%s>\n", name );
+    exit(0);
+}
+// register results to file
+fprintf( stream , "\n----- %s -----\n"
+                  " - sequencial : %d cycles\n"
+                  " - parallel   : %d cycles\n",
+         name, sequencial, parallel );
+// close instrumentation file
+if( fclose( stream ) )
+{
+    printf("\n[sort error] cannot close instrumentation file <%s>\n", name );
+    exit(0);
+}
 #endif
 …
 }  // end main()
 /*

Context Navigation

Legend:

Download in other formats: