Changeset 457

trunk/Makefile

-                      r444
+                      r457
         $(MAKE) -C $(LIBC_PATH) clean
         $(MAKE) -C $(LIBPTHREAD_PATH) clean
+        $(MAKE) -C $(LIBSEMAPHORE_PATH) clean
         $(MAKE) -C $(LIBALMOSMKH_PATH) clean
         $(MAKE) -C user/init clean
 …
         $(MAKE) -C $(LIBALMOSMKH_PATH) headers
         $(MAKE) -C $(LIBPTHREAD_PATH) headers
+        $(MAKE) -C $(LIBSEMAPHORE_PATH) headers
         $(MAKE) -C $(LIBC_PATH)
         $(MAKE) -C $(LIBALMOSMKH_PATH)
         $(MAKE) -C $(LIBPTHREAD_PATH)
+        $(MAKE) -C $(LIBSEMAPHORE_PATH)
 #####################################################################
 …
         dd if=$@ of=$(DISK_IMAGE) seek=2 conv=notrunc
 #####################################################################
 # Rule to generate boot.elf and place it in sector #2 of virtual disk
+######################################################
+# Rule to generate HAL objects (depending on HAL_ARCH)
 build_hal:
         $(MAKE) -C $(HAL_ARCH)

trunk/boot/tsar_mips32/Makefile

-                      r439
+                      r457
                                                                 boot_utils.h      \
                                                                 boot_config.h     \
                                                                 $(HAL_ARCH)/core/hal_types.h        \
+                                                                $(HAL_ARCH)/core/hal_kernel_types.h        \
                                                                 ../../hard_config.h
         $(CC) $(BOOT_INCLUDE) $(CFLAGS) -c -o $@ $<
 …
                                                                 boot_utils.h      \
                                                                 boot_config.h     \
                                                                 $(HAL_ARCH)/core/hal_types.h        \
+                                                                $(HAL_ARCH)/core/hal_kernel_types.h        \
                                                                 ../../hard_config.h
         $(CC) $(BOOT_INCLUDE) $(CFLAGS) -c -o $@ $<
 …
                                                                 boot_utils.h      \
                                                                 boot_config.h     \
                                                                 $(HAL_ARCH)/core/hal_types.h        \
+                                                                $(HAL_ARCH)/core/hal_kernel_types.h        \
                                                                 ../../hard_config.h
         $(CC) $(BOOT_INCLUDE) $(CFLAGS) -c -o $@ $<
 …
                                                                 boot_utils.h      \
                                                                 boot_config.h     \
                                                                 $(HAL_ARCH)/core/hal_types.h        \
+                                                                $(HAL_ARCH)/core/hal_kernel_types.h        \
                                                                 ../../hard_config.h
         $(CC) $(BOOT_INCLUDE) $(CFLAGS) -c -o $@ $<
 …
                                                                 boot_utils.h      \
                                                                 boot_config.h     \
                                                                 $(HAL_ARCH)/core/hal_types.h        \
+                                                                $(HAL_ARCH)/core/hal_kernel_types.h        \
                                                                 ../../hard_config.h
         $(CC) $(BOOT_INCLUDE) $(CFLAGS) -c -o $@ $<
 …
                                                                 boot_utils.h       \
                                                                 boot_tty_driver.h  \
                                                                 $(HAL_ARCH)/core/hal_types.h         \
+                                                                $(HAL_ARCH)/core/hal_kernel_types.h         \
                                                                 ../../hard_config.h
         $(CC) $(BOOT_INCLUDE) $(CFLAGS) -c -o $@ $<
 …
                                                                 boot_mmc_driver.h  \
                                                                 boot_config.h      \
                                                                 $(HAL_ARCH)/core/hal_types.h         \
+                                                                $(HAL_ARCH)/core/hal_kernel_types.h         \
                                                                 ../../hard_config.h
         $(CC) $(BOOT_INCLUDE) $(CFLAGS) $(MACROS) -c -o $@ $<

trunk/boot/tsar_mips32/boot.c

r439	r457
70	70
71	71	#include <elf-types.h>
72		#include <hal_types.h>
	72	#include <hal_kernel_types.h>
73	73
74	74	#include <kernel_config.h>

trunk/boot/tsar_mips32/boot_bdv_driver.h

r439	r457
19	19	#define BOOT_BDV_DRIVER_H
20	20
21		#include <hal_types.h>
	21	#include <hal_kernel_types.h>
22	22
23	23	/****************************************************************************

trunk/boot/tsar_mips32/boot_fat32.h

r439	r457
318	318	****************************************************************************/
319	319
320		#include <hal_types.h>
	320	#include <hal_kernel_types.h>
321	321
322	322	typedef struct fat_desc_s

trunk/boot/tsar_mips32/boot_hba_driver.h

r439	r457
27	27	#define BOOT_HBA_DRIVER_H
28	28
29		#include <hal_types.h>
	29	#include <hal_kernel_types.h>
30	30
31	31	/****************************************************************************

trunk/boot/tsar_mips32/boot_mmc_driver.h

r439	r457
13	13	#define _GIET_MMC_DRIVERS_H_
14	14
15		#include <hal_types.h>
	15	#include <hal_kernel_types.h>
16	16
17	17	///////////////////////////////////////////////////////////////////////////////////

trunk/boot/tsar_mips32/boot_tty_driver.c

r439	r457
24	24	#include <boot_config.h>
25	25	#include <boot_tty_driver.h>
26		#include <hal_types.h>
	26	#include <hal_kernel_types.h>
27	27	#include <boot_utils.h>
28	28

trunk/boot/tsar_mips32/boot_tty_driver.h

r439	r457
33	33	#define BOOT_TTY_DRIVER_H
34	34
35		#include <hal_types.h>
	35	#include <hal_kernel_types.h>
36	36
37	37	/****************************************************************************

trunk/boot/tsar_mips32/boot_utils.c

r439	r457
25	25
26	26	#include <boot_tty_driver.h>
27		#include <hal_types.h>
	27	#include <hal_kernel_types.h>
28	28	#include <boot_utils.h>
29	29

trunk/boot/tsar_mips32/boot_utils.h

r439	r457
41	41	#define _BOOT_UTILS_H
42	42
43		#include <hal_types.h>
	43	#include <hal_kernel_types.h>
44	44	#include <hard_config.h>
45	45

trunk/hal/generic/hal_atomic.h

r408	r457
26	26
27	27	#include <kernel_config.h>
28		#include <hal_types.h>
	28	#include <hal_kernel_types.h>
29	29
30	30	//////////////////////////////////////////////////////////////////////////////////////////

trunk/hal/generic/hal_context.h

-                      r408
+                      r457
  * identified by the <thread> argument. The context is not initialised.
  ****************************************************************************************
+ * @ thread  : pointer on the thread descriptor.
  * @ return 0 if success / return -1 if failure.
  ***************************************************************************************/
 …
 /****************************************************************************************
+ * This function allocates memory for a CPU context, initialize it from scratch,
+ * and links it to the thread identified by the <thread> argument.
+ * This function initializes a CPU context from scratch.
  ****************************************************************************************
  * @ thread  : pointer on the thread descriptor.
- * @ return 0 if success / return -1 if failure.
  ***************************************************************************************/
 error_t hal_cpu_context_create( struct thread_s * thread );
+void hal_cpu_context_init( struct thread_s * thread );
 /****************************************************************************************
 …
 /****************************************************************************************
+ * This function is used to implement the exec() system call.
+ * 1) It initialize the relevant slots of the the calling thread CPU context.
+ * 2) It call the hal_do_cpu_restore() function to return to user mode and start
+ *    execution of the new process.
+ ****************************************************************************************
+ * @ thread  : pointer on the thread descriptor.
+ ***************************************************************************************/
+void hal_cpu_context_exec( struct thread_s * thread );
+/****************************************************************************************
  * This function display some slots of the CPU context.
- * - For the MIPS32 :
- *   . GPR : gp_28 , sp_29 , ra_31
- *   . CP0 : c0_sr , c0_th , c0_epc
- *   . CP2 : c2_ptpr , c2-mode
- * - For X86 TODO :
  ****************************************************************************************
  * @ thread_xp  : extended pointer on the thread descriptor.
 …
  ***************************************************************************************/
 error_t hal_fpu_context_alloc( struct thread_s * thread );
+/****************************************************************************************
+ * This function initializes a FPU context from scratch.
+ ****************************************************************************************
+ * @ thread  : pointer on the thread descriptor.
+ ***************************************************************************************/
+void hal_fpu_context_init( struct thread_s * thread );
 /****************************************************************************************

trunk/hal/generic/hal_exception.h

r455	r457
25	25	#define _HAL_EXCEPTION_H_
26	26
27		#include <hal_types.h>
	27	#include <hal_kernel_types.h>
28	28
29	29	//////////////////////////////////////////////////////////////////////////////////////////

trunk/hal/generic/hal_gpt.h

r432	r457
25	25	#define _GPT_H_
26	26
27		#include <hal_types.h>
	27	#include <hal_kernel_types.h>
28	28
29	29	/////////////////////////////////////////////////////////////////////////////////////////

trunk/hal/generic/hal_interrupt.h

r408	r457
25	25	#define _HAL_INTERRUPT_H_
26	26
27		#include <hal_types.h>
	27	#include <hal_kernel_types.h>
28	28
29	29	///////////////////////////////////////////////////////////////////////////////////////

trunk/hal/generic/hal_irqmask.h

r279	r457
26	26	#define _HAL_IRQMASK_H_
27	27
28		#include <hal_types.h>
	28	#include <hal_shared_types.h>
29	29
30	30

trunk/hal/generic/hal_ppm.h

r409	r457
26	26	#define _HAL_PPM_H_
27	27
28		#include <hal_types.h>
	28	#include <hal_kernel_types.h>
29	29	#include <boot_info.h>
30	30

trunk/hal/generic/hal_remote.h

r407	r457
26	26	#define _HAL_REMOTE_H_
27	27
28		#include <hal_types.h>
	28	#include <hal_kernel_types.h>
29	29
30	30	//////////////////////////////////////////////////////////////////////////////////////////

trunk/hal/generic/hal_special.h

-                      r408
+                      r457
 #define  _HAL_CPU_H_
+#include <hal_types.h>
+#include <hal_shared_types.h>
+#include <hal_kernel_types.h>
 /****  Forward declarations  ***/

trunk/hal/generic/hal_switch.h

-                      r408
+                      r457
 /*************************************************************************************
  * The hal_do_cpu_switch() function is an assembly level function, called by the
  * sched_yield() function, to make a CPU context switch.
  * The current thread CPU context is identified by the <ctx_current> pointer.
  * The new thread CPU context is identified by the <ctx_next> pointer.
+ * This assembly level function is called by the sched_yield() function,
+ * to make a CPU context switch.
+ * The current thread CPU context is identified by the <ctx_old> pointer.
+ * The new thread CPU context is identified by the <ctx_new> pointer.
  * The architecture specific hal_cpu_context_t structure used to store a CPU context
  * is defined in the architecture specific hal_context.c file.
 …
 /*************************************************************************************
+ * The hal_do_cpu_save() function is an assembly level function, called by the
+ * hal_cpu_context_save() functio to save the calling CPU register values to a
+ * CPU context identified by the <ctx> pointer.
+ * This assembly level function is called by the hal_cpu_context_fork() function.
+ * It save the calling CPU register values to a CPU context identified by <ctx>.
  * This function does NOT modify any register before saving values into context.
  * The architecture specific hal_cpu_context_t structure used to store a CPU context
 …
 void hal_do_cpu_save( void * ctx );
+/*************************************************************************************
+ * This assembly level function, is called by the hal_cpu_context_exec() function.
+ * It restore the calling CPU register values from a CPU context identified by <ctx>.
+ * The architecture specific hal_cpu_context_t structure used to store a CPU context
+ * is defined in the architecture specific hal_context.c file.
+ * When the restore is completed, it simply jumps to the address contained in ra_31.
+ * In ALMOS-MKH, ra_31 must contain a pointer on the eret() function, and c0_epc
+ * must contain the new main thread entry point.
+ *************************************************************************************
+ * @ ctx     : local pointer on CPU context.
+ ************************************************************************************/
+void hal_do_cpu_restore( void * ctx );
 #endif  /* _HAL_SWITCH_H_ */

trunk/hal/generic/hal_syscall.h

r408	r457
25	25	#define _HAL_KERNEL_SYSCALL_H_
26	26
27		#include <hal_types.h>
	27	#include <hal_kernel_types.h>
28	28
29	29	///////////////////////////////////////////////////////////////////////////////////////

trunk/hal/generic/hal_user.h

r445	r457
25	25	#define _HAL_USER_H_
26	26
27		#include <hal_types.h>
	27	#include <hal_shared_types.h>
28	28
29	29	//////////////////////////////////////////////////////////////////////////////////////////

trunk/hal/generic/hal_uspace.h

r407	r457
25	25	#define _HAL_USPACE_H_
26	26
27		#include <hal_types.h>
	27	#include <hal_kernel_types.h>
28	28
29	29	//////////////////////////////////////////////////////////////////////////////////////////

trunk/hal/generic/hal_vmm.h

r411	r457
25	25	#define _HAL_PPM_H_
26	26
27		#include <hal_types.h>
	27	#include <hal_kernel_types.h>
28	28	#include <boot_info.h>
29	29

trunk/hal/tsar_mips32/Makefile

-                      r444
+                      r457
                                 $(HAL_ARCH)/drivers/%.h      \
                                 $(KERNEL)/kernel_config.h    \
                                 $(HAL_ARCH)/core/hal_types.h
+                                $(HAL_ARCH)/core/hal_kernel_types.h
         $(CC) $(HAL_INCLUDE) $(CFLAGS)  -c -o $@ $<
 …
                                 $(HAL)/generic/%.h           \
                                 $(KERNEL)/kernel_config.h    \
                                 $(HAL_ARCH)/core/hal_types.h
+                                $(HAL_ARCH)/core/hal_kernel_types.h
         $(CC) $(HAL_INCLUDE) $(CFLAGS) -c -o $@ $<
 …
                                       $(HAL_ARCH)/core/hal_kentry.h \
                                       $(KERNEL)/kernel_config.h     \
                                       $(HAL_ARCH)/core/hal_types.h
+                                      $(HAL_ARCH)/core/hal_kernel_types.h
         $(CC) $(HAL_INCLUDE) $(CFLAGS) -c -o $@ $<

trunk/hal/tsar_mips32/core/hal_atomic.c

r62	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25
26	26	////////////////////////////////////

trunk/hal/tsar_mips32/core/hal_context.c

-                      r432
+                      r457
  */
 #include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <hal_switch.h>
 #include <memcpy.h>
 …
 }   // end hal_cpu_context_alloc()
 ///////////////////////////////////////////////////
 // The following context slots are initialised :
+/////////////////////////////////////////////////
+// The following context slots are initialised
 // GPR : a0_04 / sp_29 / ra_31
 // CP0 : c0_sr / c0_th / c0_epc
 // CP2 : c2_ptpr / c2_mode
+///////////////////////////////////////////////////
+error_t hal_cpu_context_create( thread_t * thread )
+{
+    // allocate memory for a CPU context
+    error_t error = hal_cpu_context_alloc( thread );
+    if( error ) return error;
+/////////////////////////////////////////////////
+void hal_cpu_context_init( thread_t * thread )
+{
     hal_cpu_context_t * context = (hal_cpu_context_t *)thread->cpu_context;
+    assert( (context != NULL ), __FUNCTION__, "CPU context not allocated" );
     // initialisation depends on thread type
 …
         context->c2_mode = 0x3;
+    }
+    return 0;
+}  // end hal_cpu_context_create()
+}  // end hal_cpu_context_init()
 ////////////////////////////////////////////
 …
         assert( (current == child_ptr) , __FUNCTION__ , "current = %x / child = %x\n");
+    }
 }  // end hal_cpu_context_fork()
+//////////////////////////////////////////////
+void hal_cpu_context_exec( thread_t * thread )
+{
+    // re_initialize CPU context
+    hal_cpu_context_init( thread );
+    // restore CPU registers ... and jump
+    hal_do_cpu_restore( (hal_cpu_context_t *)thread->cpu_context );
+} // end hal_cpu_context_exec()
 /////////////////////////////////////////////////
 …
 }   // end hal_fpu_context_alloc()
+//////////////////////////////////////////////
+void hal_fpu_context_init( thread_t * thread )
+{
+    hal_fpu_context_t * context = thread->fpu_context;
+    assert( (context != NULL) , __FUNCTION__ , "fpu context not allocated" );
+    memset( context , 0 , sizeof(hal_fpu_context_t) );
+}
 //////////////////////////////////////////

trunk/hal/tsar_mips32/core/hal_drivers.c

r407	r457
20	20	*/
21	21
22		#include <hal_types.h>
	22	#include <hal_kernel_types.h>
23	23	#include <chdev.h>
24	24	#include <hal_drivers.h>

trunk/hal/tsar_mips32/core/hal_exception.c

-                      r440
+                      r457
  */
 #include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <hal_irqmask.h>
 #include <hal_special.h>
 …
         core_t   * core = this->core;
     // enable FPU
+    // enable FPU (in core SR)
         hal_fpu_enable();
     // save FPU context in current owner thread if required
+    // save FPU register values in current owner thread if required
         if( core->fpu_owner != NULL )
+    {
         if( core->fpu_owner != this )
+            {
+            // save the FPU registers to current owner thread context
                     hal_fpu_context_save( XPTR( local_cxy , core->fpu_owner ) );
+            // restore FPU registers from requesting thread context
+                hal_fpu_context_restore( this->fpu_context );
+            // attach the FPU to the requesting thread
+                core->fpu_owner = this;
+        }
+        }
+    // attach the FPU to the requesting thread
+        hal_fpu_context_restore( this->fpu_context );
+        core->fpu_owner = this;
+    else
+    {
+        // restore FPU registers from requesting thread context
+            hal_fpu_context_restore( this->fpu_context );
+        // attach the FPU to the requesting thread
+            core->fpu_owner = this;
+    }
         return EXCP_NON_FATAL;
 …
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_HAL_EXCEPTIONS < cycle )
 printk("\n[DBG] %s : thread %x enter / is_ins %d / %s / vaddr %x / cycle %d\n",
 __FUNCTION__, this, is_ins, hal_mmu_exception_str(excp_code), bad_vaddr, cycle );
+printk("\n[DBG] %s : thread %x in process %x enter / is_ins %d / %s / vaddr %x / cycle %d\n",
+__FUNCTION__, this->trdid, process->pid, is_ins, hal_mmu_exception_str(excp_code), bad_vaddr, cycle);
 #endif
 …
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_HAL_EXCEPTIONS < cycle )
 printk("\n[DBG] %s : thread %x exit / page-fault handled for vaddr = %x\n",
 __FUNCTION__ , this , bad_vaddr );
+printk("\n[DBG] %s : thread %x in process %x exit / page-fault handled for vaddr = %x\n",
+__FUNCTION__, this->trdid, process->pid, bad_vaddr );
 #endif
 …
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_HAL_EXCEPTIONS < cycle )
 printk("\n[DBG] %s : thread %x exit / copy-on-write handled for vaddr = %x\n",
 __FUNCTION__ , this , bad_vaddr );
+printk("\n[DBG] %s : thread %x in process %x exit / copy-on-write handled for vaddr = %x\n",
+__FUNCTION__, this->trdid, process->pid, bad_vaddr );
 #endif
 …
+        {
             assert( false , __FUNCTION__ ,
+            "thread %x / core[%x,%d] / epc %x / vaddr %x / cycle %d\n",
+            this, local_cxy, this->core->lid, excPC, bad_vaddr, (uint32_t)hal_get_cycles() );
+            "thread %x in process %x / core[%x,%d] / epc %x / vaddr %x / cycle %d\n",
+            this->trdid, this->process->pid, local_cxy, this->core->lid,
+            excPC, bad_vaddr, (uint32_t)hal_get_cycles() );
             return EXCP_KERNEL_PANIC;
 …
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_HAL_EXCEPTIONS < cycle )
 printk("\n[DBG] %s : thread %x enter / core[%x,%d] / pid %x / epc %x / xcode %x / cycle %d\n",
 __FUNCTION__, this, local_cxy, this->core->lid, this->process->pid, excPC, excCode, cycle );
+printk("\n[DBG] %s : thread %x in process %x enter / core[%x,%d] / epc %x / xcode %x / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, local_cxy, this->core->lid, excPC, excCode, cycle );
 #endif
 …
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_HAL_EXCEPTIONS < cycle )
 printk("\n[DBG] %s : thread %x exit / core[%x,%d] / pid %x / epc %x / xcode %x / cycle %d\n",
 __FUNCTION__, this, local_cxy, this->core->lid, this->process->pid, excPC, excCode, cycle );
+printk("\n[DBG] %s : thread %x in process %x exit / core[%x,%d] / epc %x / xcode %x / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, local_cxy, this->core->lid, excPC, excCode, cycle );
 #endif

trunk/hal/tsar_mips32/core/hal_gpt.c

r445	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_gpt.h>
26	26	#include <hal_special.h>

trunk/hal/tsar_mips32/core/hal_interrupt.c

r435	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_special.h>
26	26	#include <kernel_config.h>

trunk/hal/tsar_mips32/core/hal_irqmask.c

-                      r285
+                      r457
  */
+#include <hal_types.h>
+#include <hal_kernel_types.h>
+#include <hal_shared_types.h>
 //////////////////////////////////////////

trunk/hal/tsar_mips32/core/hal_ppm.c

r443	r457
23	23
24	24	#include <kernel_config.h>
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <hal_ppm.h>
27	27	#include <hal_special.h>

trunk/hal/tsar_mips32/core/hal_remote.c

r313	r457
23	23	*/
24	24
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <hal_irqmask.h>
27	27

trunk/hal/tsar_mips32/core/hal_special.c

r425	r457
23	23
24	24
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <hal_special.h>
27	27	#include <core.h>

trunk/hal/tsar_mips32/core/hal_switch.S

-                      r408
+                      r457
     .global  hal_do_cpu_switch
     .global  hal_do_cpu_save
+    .global  hal_do_cpu_restore
     .set     noat
 …
         sw      $27,  33*4($26)           /* save c2_mode to slot 33 */
+    sync
     /* restore new thread context */
 …
         mtc2    $27,  $1                   /* restore c2_mode from slot 33 */
     mtc0        $26,  $12                  /* restore c0_sr from slot 34 */
-    sync
     jr      $31                        /* return to caller */
 …
     nop
+#---------------------------------------------------------------------------------
+# The hal_do_cpu_restore()function makes the following assumption:
+# - register $4 contains a pointer on the target thread context.
+#---------------------------------------------------------------------------------
+hal_do_cpu_restore:
+    move    $26,  $4                  /* $26 <= &context */
+    lw      $27,   0*4($26)
+    mtc0    $27,   $14                 /* restore C0_epc from slot 0 */
+    lw      $1,    1*4($26)
+    lw      $2,    2*4($26)
+    lw      $3,    3*4($26)
+    lw      $4,    4*4($26)
+    lw      $5,    5*4($26)
+    lw      $6,    6*4($26)
+    lw      $7,    7*4($26)
+    lw      $8,    8*4($26)
+    lw      $9,    9*4($26)
+    lw      $10,  10*4($26)
+    lw      $11,  11*4($26)
+    lw      $12,  12*4($26)
+    lw      $13,  13*4($26)
+    lw      $14,  14*4($26)
+    lw      $15,  15*4($26)
+        lw      $16,  16*4($26)
+        lw      $17,  17*4($26)
+    lw      $18,  18*4($26)
+    lw      $19,  19*4($26)
+    lw      $20,  20*4($26)
+    lw      $21,  21*4($26)
+    lw      $22,  22*4($26)
+    lw      $23,  23*4($26)
+    lw      $24,  24*4($26)
+    lw      $25,  25*4($26)
+    lw      $27,  26*4($26)
+    mthi    $27                        /* restore hi from slot 26 */
+    lw      $27,  27*4($26)
+    mtlo    $27                        /* restore lo from slot 27 */
+        lw      $28,  28*4($26)
+        lw      $29,  29*4($26)
+        lw      $30,  30*4($26)
+        lw      $31,  31*4($26)            /* restore ra from slot 31 */
+        lw      $27,  32*4($26)
+        mtc2    $27,  $0                   /* restore c2_ptpr from slot 32 */
+        lw      $27,  35*4($26)
+    mtc0        $27,  $4, 2                /* restore c0_th from slot 35 */
+        lw      $27,  33*4($26)
+        lw      $26,  34*4($26)
+        mtc2    $27,  $1                   /* restore c2_mode from slot 33 */
+    mtc0        $26,  $12                  /* restore c0_sr from slot 34 */
+    jr      $31                        /* return to caller */
+    nop
         .set reorder
     .set at

trunk/hal/tsar_mips32/core/hal_syscall.c

-                      r425
+                      r457
  */
 #include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <hal_syscall.h>
 #include <do_syscall.h>
 …
     enter_uzone = (uint32_t *)this->uzone_current;
-//printk("\n@@@ enter %s : thread = %x / enter_uzone = %x / EPC = %x\n",
-//__FUNCTION__ , this , enter_uzone , enter_uzone[UZ_EPC] );
     // get syscall arguments from uzone
         service_num = enter_uzone[UZ_V0];
 …
     exit_uzone = (uint32_t *)this->uzone_current;
-//printk("\n@@@ exit %s : thread = %x / exit_uzone = %x / EPC = %x\n",
-//__FUNCTION__ , this , exit_uzone , exit_uzone[UZ_EPC] );
     // set return value to uzone
         exit_uzone[UZ_V0] = retval;

trunk/hal/tsar_mips32/core/hal_uspace.c

r425	r457
25	25	#include <errno.h>
26	26	#include <vmm.h>
27		#include <hal_types.h>
	27	#include <hal_kernel_types.h>
28	28	#include <hal_uspace.h>
29	29	#include <hal_irqmask.h>

trunk/hal/tsar_mips32/core/hal_vmm.c

r411	r457
23	23
24	24	#include <kernel_config.h>
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <hal_vmm.h>
27	27	#include <hal_gpt.h>

trunk/hal/tsar_mips32/drivers/soclib_pic.c

-                      r451
+                      r457
 #endif
     // analyse status and handle up to 3 pending IRQ (one WTI, one HWI, one PTI)
+    // analyse status and handle up to 3 pending IRQs (one WTI, one HWI, one PTI)
     if( wti_status )          // pending WTI
 …
 #if DEBUG_HAL_IRQS
 if (DEBUG_HAL_IRQS < cycle )
 printk("\n[DBG] %s : core[%x,%d] received an IPI\n", __FUNCTION__ , local_cxy , core->lid );
+printk("\n[DBG] %s : core[%x,%d] handling IPI\n", __FUNCTION__ , local_cxy , core->lid );
 #endif
             // acknowledge IRQ (this require an XCU read)
 …
             // check RPC FIFO,  and activate or create a RPC thread
+            // condition is always true, but we must use the ack value
+            // condition is always true, but we use the ack value
+            // to avoid a GCC warning
             if( ack + 1 ) rpc_check();
+        }
 …
 #if DEBUG_HAL_IRQS
 if (DEBUG_HAL_IRQS < cycle )
 printk("\n[DBG] %s : core[%x,%d] received external WTI %d\n",
+printk("\n[DBG] %s : core[%x,%d] handling external WTI %d\n",
 __FUNCTION__ , local_cxy , core->lid , index );
 #endif
 …
 #if DEBUG_HAL_IRQS
 if (DEBUG_HAL_IRQS < cycle )
 printk("\n[DBG] %s : core[%x,%d] received HWI %d\n",
+printk("\n[DBG] %s : core[%x,%d] handling HWI %d\n",
 __FUNCTION__ , local_cxy , core->lid , index );
 #endif
 …
 #if DEBUG_HAL_IRQS
 if (DEBUG_HAL_IRQS < cycle )
 printk("\n[DBG] %s : core[%x,%d] received PTI %d\n",
+printk("\n[DBG] %s : core[%x,%d] handling PTI %d\n",
 __FUNCTION__ , core->lid , local_cxy , index );
 #endif
 …
         // execute all actions related to TICK event
+        // condition is always true, but we must use the ack value
+        // condition is always true, but we use the ack value
+        // to avoid a GCC warning
         if( ack + 1 ) core_clock( core );
+        }
 …
+{
     // calling core local index
     lid_t  lid = CURRENT_CORE->lid;
+    lid_t  lid = CURRENT_THREAD->core->lid;
     // get XCU segment base
 …
+{
     // calling core local index
     lid_t  lid = CURRENT_CORE->lid;
+    lid_t  lid = CURRENT_THREAD->core->lid;
     // get XCU segment base

trunk/hal/tsar_mips32/drivers/soclib_tty.c

-                      r451
+                      r457
     xptr_t       parent_main_xp;    // local pointer on parent process main thread
     // get TXT chdev channel, direction and server thread
+    // get TXT chdev channel, direction, server thread, and server core
     channel    = chdev->channel;
     is_rx      = chdev->is_rx;
 …
                 thread_unblock( XPTR( local_cxy , server ) , THREAD_BLOCKED_ISR );
+                // send IPI to core running server thread
+                dev_pic_send_ipi( local_cxy , server_lid );
+                // send IPI to core running server thread if required
+                if( server_lid != CURRENT_THREAD->core->lid )
+                {
+                    dev_pic_send_ipi( local_cxy , server_lid );
+                }
+            }
             else
 …
         thread_unblock( XPTR( local_cxy , server ) , THREAD_BLOCKED_ISR );
+        // send IPI to core running server thread
+        dev_pic_send_ipi( local_cxy , server_lid );
+        // send IPI to core running server thread if required
+        if( server_lid != CURRENT_THREAD->core->lid )
+        {
+            dev_pic_send_ipi( local_cxy , server_lid );
+        }
     }  // end TX

trunk/hal/tsar_mips32/drivers/soclib_tty.h

-                      r436
+                      r457
  * soclib_tty.c - soclib tty driver definition.
+ *
  * Author  Alain Greiner (2016)
+ * Author  Alain Greiner (2016,2017,2018)
+ *
  * Copyright (c)  UPMC Sorbonne Universites
 …
 /****************************************************************************************
  * This driver supports the vci_tty_tsar component.
  * It implements the generic TXT device API:
+ * Regarding read/write request, it implements the generic TXT device API:
  * - transfer one single character from TTY to command "buffer" if to_mem is non-zero.
  * - transfer "count" characters from command "buffer" to TTY if "to_mem is zero.
+ * It handles asynchronous control characters (^C / ^Z), that are translated to signals
+ * transmited to the TXT owner process (foreground process).
  ***************************************************************************************/
 …
 /****************************************************************************************
  * This ISR is executed to handle both the TTY_TX_IRQ and the TTY_RX_IRQ, even if
+ *   The RX_IRQ is activated as soon as the TTY_STATUS_RX_FULL bit is 1 in the
+ * there is two different channel devices for TX and RX transfers.
+ *
+ * As the <chdev> argument is a local pointer, this ISR is always executed by a core
+ * that is in the same cluster as the core running the DEV server thread.
+ *
+ * - The RX_IRQ is activated as soon as the TTY_STATUS_RX_FULL bit is 1 in the
  *   TTY_STATUS register, when the TTY_RX_IRQ_ENABLE is non zero, indicating that
  *   the TTY_READ buffer is full and can be read.
  *   The TX_IRQ is activated as soon as the TTY_STATUS_TX_FULL bit is 0 in the
+ * - The TX_IRQ is activated as soon as the TTY_STATUS_TX_FULL bit is 0 in the
  *   TTY_STATUS register, when the TTY_TX_IRQ_ENABLE is non zero, indicating that
  *   the TTY_WRITE buffer is empty, and can be written.
+ * WARNING : In ALMOS-MKH, the RX_IRQ is always enabled to catch the control signals,
+ *
+ * The RX_IRQ is always enabled to catch the control characters (^Z / ^C),
  * but the TX_IRQ is dynamically enabled by the TXT_WRITE command, and disabled when
  * the command is completed.
+ *
+ * 1) The ISR first read the TTY_STATUS to get the current state of the TTY_READ and
+ *   the TTY_WRITE buffers.
+ * For normal characters The ISR uses two private TTY_RX and TTY_TX software FIFOs
+ * (two FIFOs per channel) to communicates with the DEV server thread executing the
+ * soclib_tty_cmd() function.
+ * For an RX transfer, this ISR executes a while loop moving bytes until the source
+ * TTY_READ buffer is empty:
+ *   1) The ISR read one byte from the TTY_READ register and acknowledge the RX_IRQ.
+ *   2) if the byte is a ^Z character, it uses a multicast RPC to block all treads of
+ *      the TXT owner process, and transfer TXT ownership to another process of the group.
+ *   3) if the byte is a ^C character, it removes the process from the TXT group, and send
+ *      a multicast RPC to delete all threads of the TXT owner process.
+ *   4) if the byte is a normal character and the destination TTY_RX_FIFO is not full,
+ *      it writes the byte to this FIFO, unblock the TXT_RX server thread, and send an IPI
+ *      to this server thread (only if it is running on another core than the ISR).
+ *   5) It discards the byte if the TTY_RX_FIFO is full, with a warning message on TXT0.
+ *
+ * 2) It try to read the first command registered in the server thread queue associated
+ *    to the TTY channel
+ *
+ * 2) The ISR handles the RX when the TTY_READ buffer is full :
+ *   . it read the available character from the TTY_READ buffer, and this
+ *     acknowledges the RX_IRQ.
+ *   . if it is a control character ( ^C / ^D / ^Z ) it translate it to the proper
+ *     signal and execute the relevant sigaction for the foreground process.
+ *   . if it is a normal character, it try to get the first command registered in the
+ *     server thread queue. If it is a TXT_READ, it returns this character to the
+ *     command buffer in the client thread.
+ *
+ * 3) The ISR handles the TX when the TTY_WRITE buffer is empty and a TXT_WRITE
+ *   . it try to get it copies the
+ *     character to the command buffer, acknowledges the TTY_RX_IRQ, and unblock the
+ *     associated server thread.
+ *   . the control characters ^C / ^D / ^Z  are directly handled by the ISR and
+ *     translated to the foreground process.
+ * - the
+ the TXT_READ and TXT_WRITE commands.
+ * It gets the command arguments from the first client thread in the TXT chdev queue:
+ * - if TXT_READ, it transfers one byte from the TTY_READ_REG to the command buffer.
+ *   It simply returns for retry if TTY_READ_REG is empty.
+ * - if TXT_WRITE, it tries to transfer several bytes from the command buffer to the
+ *   TTY_WRITE_REG. If the TTY_WRITE_REG is full, it updates the "count" and "buffer"
+ *   command arguments and returns for retry.
+ * When the I/O operation is completed, it sets the status field in the command, unblocks
+ * the server thread, and unblocks the client thread.
+ * For a TX transfer, this ISR executes a while loop moving bytes until the source
+ * TTY_TX_FIFO is empty:
+ *   1) if the destination TTY_WRITE register is not full, it moves the byte from the
+ *      TTY_TX_FIFO to the TTY_WRITE register.
+ *   2) if the TTY_WRITE register is full, it polls (busy waiting) the TTY_STATUS register,
+ *      until the TTY_WRITE register is empty.
+ *   3) when the source TTY_TX_FIFO is empty, this ISR disable the TTY_TX_IRQ, unblock
+ *      the TXT_TX server thread, and send an IPI to this server thread (only if it is
+ *      running on another core than the ISR).
  ****************************************************************************************
  * @ chdev     : local pointer on TXT chdev descriptor.

trunk/hal/x86_64/Makefile

-                      r444
+                      r457
                                 drivers/%.h \
                                 $(KERNEL)/kernel_config.h             \
                                 core/hal_types.h
+                                core/hal_kernel_types.h
         $(CC) $(HAL_INCLUDE) $(CFLAGS)  -c -o $@ $<
 …
                                 $(HAL)/generic/%.h             \
                                 $(KERNEL)/kernel_config.h             \
                                 core/hal_types.h
+                                core/hal_kernel_types.h
         $(CC) $(HAL_INCLUDE) $(CFLAGS) -c -o $@ $<
 …
                                 core/hal_segmentation.h \
                                 $(KERNEL)/kernel_config.h              \
                                 core/hal_types.h
+                                core/hal_kernel_types.h
         $(CC) $(HAL_INCLUDE) $(CFLAGS) -c -o $@ $<
 …
                                 core/hal_segmentation.h \
                                 $(KERNEL)/kernel_config.h              \
                                 core/hal_types.h
+                                core/hal_kernel_types.h
         $(CC) $(HAL_INCLUDE) $(CFLAGS) -c -o $@ $<
 …
                                 core/hal_internal.h     \
                                 $(KERNEL)/kernel_config.h               \
                                 core/hal_types.h
+                                core/hal_kernel_types.h
         $(CC) $(HAL_INCLUDE) $(CFLAGS) -c -o $@ $<
 …
                                 core/hal_segmentation.h \
                                 $(KERNEL)/kernel_config.h              \
                                 core/hal_types.h
+                                core/hal_kernel_types.h
         $(CC) $(HAL_INCLUDE) $(CFLAGS) -c -o $@ $<
 …
                                 core/hal_boot.h        \
                                 $(KERNEL)/kernel_config.h              \
                                 core/hal_types.h
+                                core/hal_kernel_types.h
         $(CC) $(HAL_INCLUDE) $(CFLAGS) -c -o $@ $<
 …
                                 core/hal_acpi.h        \
                                 $(KERNEL)/kernel_config.h              \
                                 core/hal_types.h
+                                core/hal_kernel_types.h
         $(CC) $(HAL_INCLUDE) $(CFLAGS) -c -o $@ $<
 …
                                 core/hal_apic.h        \
                                 $(KERNEL)/kernel_config.h              \
                                 core/hal_types.h
+                                core/hal_kernel_types.h
         $(CC) $(HAL_INCLUDE) $(CFLAGS) -c -o $@ $<
 $(HAL_ARCH)/build/core/x86_printf.o:  core/x86_printf.c      \
                                 $(KERNEL)/kernel_config.h              \
                                 core/hal_types.h
+                                core/hal_kernel_types.h
         $(CC) $(HAL_INCLUDE) $(CFLAGS) -c -o $@ $<

trunk/hal/x86_64/core/hal_acpi.c

r348	r457
20	20	*/
21	21
22		#include <hal_types.h>
	22	#include <hal_kernel_types.h>
23	23	#include <hal_boot.h>
24	24	#include <hal_acpi.h>

trunk/hal/x86_64/core/hal_apic.c

r327	r457
20	20	*/
21	21
22		#include <hal_types.h>
	22	#include <hal_kernel_types.h>
23	23	#include <hal_boot.h>
24	24	#include <hal_register.h>

trunk/hal/x86_64/core/hal_atomic.c

r234	r457
20	20	*/
21	21
22		#include <hal_types.h>
	22	#include <hal_kernel_types.h>
23	23	#include <hal_internal.h>
24	24

trunk/hal/x86_64/core/hal_context.c

r368	r457
20	20	*/
21	21
22		#include <hal_types.h>
	22	#include <hal_kernel_types.h>
23	23	#include <memcpy.h>
24	24	#include <thread.h>

trunk/hal/x86_64/core/hal_drivers.c

r346	r457
20	20	*/
21	21
22		#include <hal_types.h>
	22	#include <hal_kernel_types.h>
23	23	#include <chdev.h>
24	24	#include <hal_drivers.h>

trunk/hal/x86_64/core/hal_exception.c

r403	r457
20	20	*/
21	21
22		#include <hal_types.h>
	22	#include <hal_kernel_types.h>
23	23	#include <hal_irqmask.h>
24	24	#include <hal_exception.h>

trunk/hal/x86_64/core/hal_gpt.c

r408	r457
20	20	*/
21	21
22		#include <hal_types.h>
	22	#include <hal_kernel_types.h>
23	23	#include <hal_boot.h> /* XXX */
24	24	#include <hal_gpt.h>

trunk/hal/x86_64/core/hal_init.c

r365	r457
20	20	*/
21	21
22		#include <hal_types.h>
	22	#include <hal_kernel_types.h>
23	23	#include <hal_boot.h>
24	24	#include <hal_multiboot.h>

trunk/hal/x86_64/core/hal_interrupt.c

r344	r457
20	20	*/
21	21
22		#include <hal_types.h>
	22	#include <hal_kernel_types.h>
23	23	#include <kernel_config.h>
24	24	#include <thread.h>

trunk/hal/x86_64/core/hal_irqmask.c

r370	r457
20	20	*/
21	21
22		#include <hal_types.h>
	22	#include <hal_kernel_types.h>
23	23	#include <hal_internal.h>
24	24	#include <hal_segmentation.h>

trunk/hal/x86_64/core/hal_ppm.c

r407	r457
21	21
22	22	#include <kernel_config.h>
23		#include <hal_types.h>
	23	#include <hal_kernel_types.h>
24	24	#include <hal_ppm.h>
25	25	#include <hal_special.h>

trunk/hal/x86_64/core/hal_remote.c

r314	r457
20	20	*/
21	21
22		#include <hal_types.h>
	22	#include <hal_kernel_types.h>
23	23	#include <hal_internal.h>
24	24

trunk/hal/x86_64/core/hal_special.c

r371	r457
20	20	*/
21	21
22		#include <hal_types.h>
	22	#include <hal_kernel_types.h>
23	23	#include <hal_apic.h>
24	24	#include <hal_special.h>

trunk/hal/x86_64/core/hal_syscall.c

r145	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_syscall.h>
26	26	#include <do_syscall.h>

trunk/hal/x86_64/core/hal_types.h

r407	r457
1	1	/*
2		* hal_types.h - common kernel types for x86_64
	2	* hal_kernel_types.h - common kernel types for x86_64
3	3	*
4	4	* Author Alain Greiner (2016)

trunk/hal/x86_64/core/hal_uspace.c

r407	r457
23	23	*/
24	24
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <hal_uspace.h>
27	27	#include <hal_irqmask.h>

trunk/hal/x86_64/core/x86_printf.c

r242	r457
20	20	*/
21	21
22		#include <hal_types.h>
	22	#include <hal_kernel_types.h>
23	23	#include <hal_boot.h>
24	24	#include <hal_internal.h>

trunk/hal/x86_64/drivers/ioc_ata.h

r215	r457
24	24
25	25	#include <chdev.h>
26		#include <hal_types.h>
	26	#include <hal_kernel_types.h>
27	27
28	28	void ioc_ata_init(chdev_t *chdev);

trunk/hal/x86_64/drivers/pic_apic.c

r404	r457
20	20	*/
21	21
22		#include <hal_types.h>
	22	#include <hal_kernel_types.h>
23	23	#include <chdev.h>
24	24	#include <pic_apic.h>

trunk/hal/x86_64/drivers/pic_apic.h

r280	r457
23	23	#define _PIC_APIC_H_
24	24
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26
27	27	void pic_apic_init(chdev_t *pic);

trunk/kernel/Makefile

-                      r444
+                      r457
               build/syscalls/sys_thread_wakeup.o   \
               build/syscalls/sys_trace.o           \
+              build/syscalls/sys_fg.o
+              build/syscalls/sys_fg.o              \
+              build/syscalls/sys_is_fg.o
 VFS_OBJS    = build/fs/vfs.o              \
 …
                         kern/%.h                      \
                         kernel_config.h               \
                         $(HAL_ARCH)/core/hal_types.h
+                        $(HAL_ARCH)/core/hal_kernel_types.h
         $(CC) $(KERNEL_INCLUDE) $(CFLAGS) -c -o $@ $<
 …
                         devices/%.h                   \
                         kernel_config.h               \
                         $(HAL_ARCH)/core/hal_types.h
+                        $(HAL_ARCH)/core/hal_kernel_types.h
         $(CC) $(KERNEL_INCLUDE) $(CFLAGS) -c -o $@ $<
 …
                         mm/%.h                        \
                         kernel_config.h               \
                         $(HAL_ARCH)/core/hal_types.h
+                        $(HAL_ARCH)/core/hal_kernel_types.h
         $(CC) $(KERNEL_INCLUDE) $(CFLAGS) -c -o $@ $<
 …
                         libk/%.h                      \
                         kernel_config.h               \
                         $(HAL_ARCH)/core/hal_types.h
+                        $(HAL_ARCH)/core/hal_kernel_types.h
         $(CC) $(KERNEL_INCLUDE) $(CFLAGS) -c -o $@ $<
 …
                         syscalls/syscalls.h           \
                         kernel_config.h               \
                         $(HAL_ARCH)/core/hal_types.h
+                        $(HAL_ARCH)/core/hal_kernel_types.h
         $(CC) $(KERNEL_INCLUDE) $(CFLAGS) -c -o $@ $<
 …
                         fs/%.h                        \
                         kernel_config.h               \
                         $(HAL_ARCH)/core/hal_types.h
+                        $(HAL_ARCH)/core/hal_kernel_types.h
         $(CC) $(KERNEL_INCLUDE) $(CFLAGS) -c -o $@ $<

trunk/kernel/devices/dev_dma.c

r437	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_special.h>
26	26	#include <chdev.h>

trunk/kernel/devices/dev_dma.h

r437	r457
26	26
27	27	#include <kernel_config.h>
28		#include <hal_types.h>
	28	#include <hal_kernel_types.h>
29	29	#include <spinlock.h>
30	30

trunk/kernel/devices/dev_fbf.c

r440	r457
23	23
24	24	#include <kernel_config.h>
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <hal_gpt.h>
27	27	#include <thread.h>

trunk/kernel/devices/dev_fbf.h

r188	r457
25	25	#define _DEV_FBF_H
26	26
27		#include <hal_types.h>
	27	#include <hal_kernel_types.h>
28	28
29	29	/** Forward declarations **/

trunk/kernel/devices/dev_iob.c

r422	r457
23	23
24	24	#include <kernel_config.h>
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <hal_special.h>
27	27	#include <remote_spinlock.h>

trunk/kernel/devices/dev_iob.h

r346	r457
26	26
27	27	#include <kernel_config.h>
28		#include <hal_types.h>
	28	#include <hal_kernel_types.h>
29	29	#include <spinlock.h>
30	30

trunk/kernel/devices/dev_ioc.c

r440	r457
23	23
24	24	#include <kernel_config.h>
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <hal_gpt.h>
27	27	#include <hal_drivers.h>

trunk/kernel/devices/dev_ioc.h

r437	r457
26	26
27	27	#include <kernel_config.h>
28		#include <hal_types.h>
	28	#include <hal_kernel_types.h>
29	29
30	30	/** Forward declarations **/

trunk/kernel/devices/dev_mmc.c

r440	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_special.h>
26	26	#include <hal_drivers.h>

trunk/kernel/devices/dev_mmc.h

r440	r457
26	26
27	27	#include <kernel_config.h>
28		#include <hal_types.h>
	28	#include <hal_kernel_types.h>
29	29	#include <spinlock.h>
30	30

trunk/kernel/devices/dev_nic.c

r438	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_special.h>
26	26	#include <printk.h>

trunk/kernel/devices/dev_nic.h

r437	r457
26	26
27	27	#include <kernel_config.h>
28		#include <hal_types.h>
	28	#include <hal_kernel_types.h>
29	29
30	30	/*****************************************************************************************

trunk/kernel/devices/dev_pic.c

-                      r438
+                      r457
  */
 #include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <hal_special.h>
 #include <chdev.h>
 …
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_DEV_PIC < cycle )
 printk("\n[DBG] %s : src_core[%x,%d] / dst_core[%x,%d] / cycle %d\n",
 __FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, cxy, lid, cycle );
+printk("\n[DBG] %s : thread %x in process %x / tgt_core[%x,%d] / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, cxy, lid, cycle );
 #endif

trunk/kernel/devices/dev_pic.h

r437	r457
26	26
27	27	#include <kernel_config.h>
28		#include <hal_types.h>
	28	#include <hal_kernel_types.h>
29	29
30	30	/*****************************************************************************************

trunk/kernel/devices/dev_txt.c

r438	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_special.h>
26	26	#include <hal_remote.h>

trunk/kernel/devices/dev_txt.h

r435	r457
26	26
27	27	#include <kernel_config.h>
28		#include <hal_types.h>
	28	#include <hal_kernel_types.h>
29	29	#include <xlist.h>
30	30	#include <remote_spinlock.h>

trunk/kernel/fs/devfs.c

-                      r438
+                      r457
  */
 #include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <hal_special.h>
 #include <hal_uspace.h>
 …
 #endif
     // creates DEVFS "dev" inode in cluster IO
     error = vfs_add_child_in_parent( LOCAL_CLUSTER->io_cxy,
+    // creates DEVFS "dev" inode in cluster 0
+    error = vfs_add_child_in_parent( 0,                // cxy
                                      INODE_TYPE_DIR,
                                      FS_TYPE_DEVFS,
 …
 #endif
     // create DEVFS "external" inode in cluster IO
     error = vfs_add_child_in_parent( LOCAL_CLUSTER->io_cxy,
+    // create DEVFS "external" inode in cluster 0
+    error = vfs_add_child_in_parent( 0,               // cxy
                                      INODE_TYPE_DIR,
                                      FS_TYPE_DEVFS,

trunk/kernel/fs/fatfs.c

r440	r457
23	23
24	24
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <hal_special.h>
27	27	#include <printk.h>

trunk/kernel/fs/fatfs.h

r407	r457
26	26	#define _FATFS_H_
27	27
28		#include <hal_types.h>
	28	#include <hal_kernel_types.h>
29	29	#include <rwlock.h>
30	30	#include <vfs.h>

trunk/kernel/fs/ramfs.c

r188	r457
24	24
25	25
26		#include <hal_types.h>
	26	#include <hal_kernel_types.h>
27	27	#include <hal_special.h>
28	28	#include <printk.h>

trunk/kernel/fs/vfs.c

r441	r457
25	25
26	26	#include <kernel_config.h>
27		#include <hal_types.h>
	27	#include <hal_kernel_types.h>
28	28	#include <hal_atomic.h>
29	29	#include <hal_special.h>

trunk/kernel/fs/vfs.h

r437	r457
27	27
28	28	#include <kernel_config.h>
29		#include <hal_types.h>
	29	#include <hal_kernel_types.h>
30	30	#include <hal_atomic.h>
31	31	#include <remote_rwlock.h>

trunk/kernel/kern/chdev.c

-                      r450
+                      r457
 #include <kernel_config.h>
 #include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <hal_special.h>
 #include <hal_remote.h>
 …
     xptr_t     server_xp;     // extended pointer on server thread
     core_t   * core_ptr;      // local pointer on core running the server thread
     uint32_t   lid;           // core running the server thread local index
+    uint32_t   server_lid;    // core running the server thread local index
     xptr_t     lock_xp;       // extended pointer on lock protecting the chdev queue
-    uint32_t   different;     // non zero if server thread core != client thread core
     uint32_t   save_sr;       // for critical section
 …
     // get server core local index
     lid = hal_remote_lw( XPTR( chdev_cxy , &core_ptr->lid ) );
+    server_lid = hal_remote_lw( XPTR( chdev_cxy , &core_ptr->lid ) );
 #if (DEBUG_CHDEV_CMD_RX || DEBUG_CHDEV_CMD_TX)
 …
 #endif
+#if (DEBUG_CHDEV_CMD_RX & 1)
+if( (is_rx) && (DEBUG_CHDEV_CMD_RX < rx_cycle) )
+printk("\n[DBG] in %s : client thread %x blocked\n", __FUNCTION__, this );
+#endif
     // unblock server thread if required
     if( hal_remote_lw( blocked_xp ) & THREAD_BLOCKED_IDLE )
 …
 #if (DEBUG_CHDEV_CMD_TX & 1)
 if( (is_rx == 0) && (DEBUG_CHDEV_CMD_TX < tx_cycle) )
+{
+printk("\n[DBG] in %s : server thread %x unblocked\n", __FUNCTION__, server_ptr );
+chdev_queue_display( chdev_xp );
+}
+printk("\n[DBG] in %s : TX server thread %x unblocked\n", __FUNCTION__, server_ptr );
+#endif
+#if (DEBUG_CHDEV_CMD_RX & 1)
+if( (is_rx) && (DEBUG_CHDEV_CMD_RX < rx_cycle) )
+printk("\n[DBG] in %s : RX server thread %x unblocked\n", __FUNCTION__, server_ptr );
 #endif
 …
 #if (DEBUG_CHDEV_CMD_TX & 1)
 if( (is_rx == 0)  && (DEBUG_CHDEV_CMD_TX < tx_cycle) )
+{
 printk("\n[DBG] in %s : thread %x registered write request in chdev\n", __FUNCTION__, this );
+chdev_queue_display( chdev_xp );
+}
+#endif
+#if (DEBUG_CHDEV_CMD_RX & 1)
+if( (is_rx)  && (DEBUG_CHDEV_CMD_RX < rx_cycle) )
+printk("\n[DBG] in %s : thread %x registered read request in chdev\n", __FUNCTION__, this );
 #endif
     // send IPI to core running the server thread when server != client
+    different = (lid != this->core->lid) || (local_cxy != chdev_cxy);
+    if( different )
+    {
+        dev_pic_send_ipi( chdev_cxy , lid );
+    if( (server_lid != this->core->lid) || (local_cxy != chdev_cxy) )
+    {
+        dev_pic_send_ipi( chdev_cxy , server_lid );
 #if (DEBUG_CHDEV_CMD_TX & 1)
 if( (is_rx == 0)  && (DEBUG_CHDEV_CMD_TX < tx_cycle) )
+printk("\n[DBG] in %s : client thread %x sent IPI to server thread %x\n",
+printk("\n[DBG] in %s : client thread %x sent IPI to TX server thread %x\n",
+__FUNCTION__, this, server_ptr );
+#endif
+#if (DEBUG_CHDEV_CMD_RX & 1)
+if( (is_rx)  && (DEBUG_CHDEV_CMD_RX < rx_cycle) )
+printk("\n[DBG] in %s : client thread %x sent IPI to RX server thread %x\n",
 __FUNCTION__, this, server_ptr );
 #endif

trunk/kernel/kern/chdev.h

r450	r457
26	26
27	27	#include <kernel_config.h>
28		#include <hal_types.h>
	28	#include <hal_kernel_types.h>
29	29	#include <xlist.h>
30	30	#include <remote_spinlock.h>

trunk/kernel/kern/cluster.c

-                      r456
+                      r457
 #if( DEBUG_CLUSTER_INIT & 1 )
 uint32_t cycle = (uint32_t)hal_get_cycles();
+cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_CLUSTER_INIT < cycle )
 printk("\n[DBG] %s : KHM initialized in cluster %x at cycle %d\n",
 …
 #if( DEBUG_CLUSTER_INIT & 1 )
 uint32_t cycle = (uint32_t)hal_get_cycles();
+cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_CLUSTER_INIT < cycle )
 printk("\n[DBG] %s : KCM initialized in cluster %x at cycle %d\n",

trunk/kernel/kern/cluster.h

r443	r457
28	28
29	29	#include <kernel_config.h>
30		#include <hal_types.h>
	30	#include <hal_kernel_types.h>
31	31	#include <bits.h>
32	32	#include <spinlock.h>

trunk/kernel/kern/core.c

r443	r457
24	24
25	25	#include <kernel_config.h>
26		#include <hal_types.h>
	26	#include <hal_kernel_types.h>
27	27	#include <hal_special.h>
28	28	#include <errno.h>

trunk/kernel/kern/core.h

-                      r443
+                      r457
 #include <kernel_config.h>
 #include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <list.h>
 #include <rpc.h>
 …
+}
 core_t;
-/****************************************************************************************
- * This macro returns a pointer on the calling core descriptor.
- ***************************************************************************************/
-#define CURRENT_CORE  (CURRENT_THREAD->core)
 /***************************************************************************************

trunk/kernel/kern/do_interrupt.c

r248	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <kernel_config.h>
26	26	#include <thread.h>

trunk/kernel/kern/do_interrupt.h

r16	r457
27	27	#define _DO_INTERRUPT_H_
28	28
29		#include <hal_types.h>
	29	#include <hal_kernel_types.h>
30	30	#include <thread.h>
31	31

trunk/kernel/kern/do_syscall.c

-                      r443
+                      r457
  */
 #include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <hal_irqmask.h>
 #include <do_syscall.h>
 …
     sys_trace,              // 47
     sys_fg,                 // 48
     sys_undefined,          // 49
+    sys_is_fg,              // 49
 };
 …
         else if( index == SYS_TRACE          ) return "TRACE";            // 47
         else if( index == SYS_FG             ) return "FG";               // 48
+        else if( index == SYS_IS_FG          ) return "IS_FG";            // 49
     else                                   return "undefined";

trunk/kernel/kern/do_syscall.h

r408	r457
27	27	#define _D0_SYSCALL_H_
28	28
29		#include <hal_types.h>
	29	#include <hal_kernel_types.h>
30	30	#include <thread.h>
31	31

trunk/kernel/kern/dqdt.c

r438	r457
23	23
24	24	#include <kernel_config.h>
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <hal_special.h>
27	27	#include <hal_atomic.h>

trunk/kernel/kern/dqdt.h

r438	r457
26	26
27	27	#include <kernel_config.h>
28		#include <hal_types.h>
	28	#include <hal_kernel_types.h>
29	29	#include <hal_atomic.h>
30	30

trunk/kernel/kern/kernel_init.c

-                      r443
+                      r457
 #include <kernel_config.h>
 #include <errno.h>
 #include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <hal_special.h>
 #include <hal_context.h>
 …
            "    /_/        \\_\\ |______| |_|    |_|   \\_____/  |______/        |_|    |_|  |_|  \\_\\ |_|   |_|  \n"
            "\n\n\t\t Advanced Locality Management Operating System / Multi Kernel Hybrid\n"
            "\n\n\t\t Version 0.0 / %d cluster(s) / %d core(s) per cluster / cycle %d\n\n",
            nclusters , ncores , hal_time_stamp() );
+           "\n\n\t\t %s / %d cluster(s) / %d core(s) per cluster\n\n",
+           CONFIG_ALMOS_VERSION , nclusters , ncores );
+}
 …
     reg_t        status;                    // running core status register
-    cxy_t        io_cxy = info->io_cxy;
-    assert( (io_cxy == ((info->x_size - 1)<<(info->y_width)) + (info->y_size - 1)) ,
-    __FUNCTION__ , "illegal IO cluter identifier\n" );
     /////////////////////////////////////////////////////////////////////////////////
     // STEP 0 : Each core get its core identifier from boot_info, and makes
 …
     thread->remote_locks = 0;
     // CP0 in I/O cluster initialises TXT0 chdev descriptor
     if( (core_lid == 0) && (core_cxy == io_cxy) ) txt0_device_init( info );
     /////////////////////////////////////////////////////////////////////////////////
     if( core_lid == 0 ) remote_barrier( XPTR( io_cxy , &global_barrier ),
+    // CP0 in cluster 0 initialises TXT0 chdev descriptor
+    if( (core_lid == 0) && (core_cxy == 0) ) txt0_device_init( info );
+    /////////////////////////////////////////////////////////////////////////////////
+    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ),
                                         (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
 …
     /////////////////////////////////////////////////////////////////////////////////
     if( core_lid == 0 ) remote_barrier( XPTR( io_cxy , &global_barrier ),
+    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ),
                                         (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
 …
     ////////////////////////////////////////////////////////////////////////////////
     if( core_lid == 0 ) remote_barrier( XPTR( io_cxy , &global_barrier ),
+    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ),
                                         (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
 …
     /////////////////////////////////////////////////////////////////////////////////
     if( core_lid == 0 ) remote_barrier( XPTR( io_cxy , &global_barrier ),
+    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ),
                                         (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
 …
     // all cores initialize the idle thread descriptor
+    error = thread_idle_init( thread,
+                              THREAD_IDLE,
+                              &thread_idle_func,
+                              NULL,
+                              core_lid );
+    if( error )
+    {
+        assert( false , __FUNCTION__ ,
+        "core[%x][%d] cannot initialize idle thread", local_cxy , core_lid );
+    }
+    thread_idle_init( thread,
+                      THREAD_IDLE,
+                      &thread_idle_func,
+                      NULL,
+                      core_lid );
     // all cores unblock idle thread, and register it in scheduler
 …
     /////////////////////////////////////////////////////////////////////////////////
     if( core_lid == 0 ) remote_barrier( XPTR( io_cxy , &global_barrier ),
+    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ),
                                         (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
 …
     /////////////////////////////////////////////////////////////////////////////////
     if( core_lid == 0 ) remote_barrier( XPTR( io_cxy , &global_barrier ),
+    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ),
                                         (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
 …
 #if DEBUG_KERNEL_INIT
 if( (core_lid ==  0) & (local_cxy == 0) )
 printk("\n[DBG] %s : exit barrier 5 : VFS_root = %l in cluster %x / cycle %d\n",
 __FUNCTION__, vfs_root_inode_xp , io_cxy , (uint32_t)hal_get_cycles());
+printk("\n[DBG] %s : exit barrier 5 : VFS_root = %l in cluster 0 / cycle %d\n",
+__FUNCTION__, vfs_root_inode_xp , (uint32_t)hal_get_cycles());
 #endif
 …
     /////////////////////////////////////////////////////////////////////////////////
     if( (core_lid ==  0) && (local_cxy == io_cxy) )
+    if( (core_lid ==  0) && (local_cxy == 0) )
+    {
         // create "dev" and "external" directories.
 …
     /////////////////////////////////////////////////////////////////////////////////
     if( core_lid == 0 ) remote_barrier( XPTR( io_cxy , &global_barrier ),
+    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ),
                                         (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
 …
 #if DEBUG_KERNEL_INIT
 if( (core_lid ==  0) & (local_cxy == 0) )
 printk("\n[DBG] %s : exit barrier 6 : dev_root = %l in cluster %x / cycle %d\n",
 __FUNCTION__, devfs_dev_inode_xp , io_cxy , (uint32_t)hal_get_cycles() );
+printk("\n[DBG] %s : exit barrier 6 : dev_root = %l in cluster 0 / cycle %d\n",
+__FUNCTION__, devfs_dev_inode_xp , (uint32_t)hal_get_cycles() );
 #endif
 …
     if( core_lid == 0 )
+    {
         // get extended pointer on "extend" field of VFS context for DEVFS in cluster IO
         xptr_t  extend_xp = XPTR( io_cxy , &fs_context[FS_TYPE_DEVFS].extend );
         // get pointer on DEVFS context in cluster IO
+        // get extended pointer on "extend" field of VFS context for DEVFS in cluster 0
+        xptr_t  extend_xp = XPTR( 0 , &fs_context[FS_TYPE_DEVFS].extend );
+        // get pointer on DEVFS context in cluster 0
         devfs_ctx_t * devfs_ctx = hal_remote_lpt( extend_xp );
+        devfs_dev_inode_xp      = hal_remote_lwd( XPTR( io_cxy ,
+                                                        &devfs_ctx->dev_inode_xp ) );
+        devfs_external_inode_xp = hal_remote_lwd( XPTR( io_cxy ,
+                                                        &devfs_ctx->external_inode_xp ) );
+        devfs_dev_inode_xp      = hal_remote_lwd( XPTR( 0 , &devfs_ctx->dev_inode_xp ) );
+        devfs_external_inode_xp = hal_remote_lwd( XPTR( 0 , &devfs_ctx->external_inode_xp ) );
         // populate DEVFS in all clusters
 …
     /////////////////////////////////////////////////////////////////////////////////
     if( core_lid == 0 ) remote_barrier( XPTR( io_cxy , &global_barrier ),
+    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ),
                                         (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
 …
     /////////////////////////////////////////////////////////////////////////////////
     if( (core_lid ==  0) && (local_cxy == 0) )
+    if( (core_lid == 0) && (local_cxy == 0) )
+    {
 …
     /////////////////////////////////////////////////////////////////////////////////
     if( core_lid == 0 ) remote_barrier( XPTR( io_cxy , &global_barrier ),
+    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ),
                                         (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
 …
     /////////////////////////////////////////////////////////////////////////////////
     if( (core_lid ==  0) && (local_cxy == io_cxy) )
+    if( (core_lid == 0) && (local_cxy == 0) )
+    {
         print_banner( (info->x_size * info->y_size) , info->cores_nr );

trunk/kernel/kern/printk.c

r446	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_irqmask.h>
26	26	#include <hal_special.h>

trunk/kernel/kern/printk.h

r437	r457
41	41	#define _PRINTK_H
42	42
43		#include <hal_types.h>
	43	#include <hal_kernel_types.h>
44	44	#include <stdarg.h>
45	45

trunk/kernel/kern/process.c

-                      r450
+                      r457
 #include <kernel_config.h>
 #include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <hal_remote.h>
 #include <hal_uspace.h>
 …
 void process_reference_init( process_t * process,
                              pid_t       pid,
+                             xptr_t      parent_xp,
+                             xptr_t      model_xp )
+                             xptr_t      parent_xp )
+{
     cxy_t       parent_cxy;
     process_t * parent_ptr;
-    cxy_t       model_cxy;
-    process_t * model_ptr;
     xptr_t      stdin_xp;
     xptr_t      stdout_xp;
 …
     chdev_t *   chdev_ptr;
     cxy_t       chdev_cxy;
-    pid_t       model_pid;
     pid_t       parent_pid;
-    // get model process cluster and local pointer
-    model_cxy = GET_CXY( model_xp );
-    model_ptr = GET_PTR( model_xp );
     // get parent process cluster and local pointer
 …
     parent_ptr = GET_PTR( parent_xp );
     // get model_pid and parent_pid
+    // get parent_pid
     parent_pid = hal_remote_lw( XPTR( parent_cxy , &parent_ptr->pid ) );
-    model_pid  = hal_remote_lw( XPTR( model_cxy  , &model_ptr->pid ) );
 #if DEBUG_PROCESS_REFERENCE_INIT
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_REFERENCE_INIT )
 printk("\n[DBG] %s : thread %x enter / pid = %x / ppid = %x / model_pid = %x / cycle %d\n",
 __FUNCTION__ , CURRENT_THREAD , pid , parent_pid , model_pid , cycle );
+printk("\n[DBG] %s : thread %x in process %x enter to initalialize process %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, parent_pid , pid , cycle );
 #endif
 …
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_REFERENCE_INIT )
 printk("\n[DBG] %s : thread %x / vmm empty for process %x / cycle %d\n",
 __FUNCTION__ , CURRENT_THREAD , pid , cycle );
+printk("\n[DBG] %s : thread %x in process %x / vmm empty for process %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, parent_pid , cycle );
 #endif
 …
     // define the stdin/stdout/stderr pseudo files <=> select a TXT terminal.
+    // - if INIT (pid == 1)         => link to kernel TXT[0]
+    // - if KSH[i] (model_pid == 1) => allocate a free TXT[i]
+    // - if USER process            => same terminal as model
+    if( (pid == 1) || (model_pid == 1)) // INIT or KSH process
+    {
+        if (pid == 1 )  txt_id = 0;                    // INIT
+        else            txt_id = process_txt_alloc();  // KSH[i]
+        // attach process to TXT[txt_id]
+    if( (pid == 1) || (parent_pid == 1)) // INIT or KSH process
+    {
+        // allocate a TXT channel
+        if( pid == 1 )  txt_id = 0;                     // INIT
+        else            txt_id = process_txt_alloc();   // KSH
+        // attach process to TXT
         process_txt_attach( process , txt_id );
+#if (DEBUG_PROCESS_REFERENCE_INIT & 1)
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_PROCESS_REFERENCE_INIT )
+printk("\n[DBG] %s : thread %x in process %x / process %x attached to TXT%d / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, parent_pid, pid, txt_id, cycle );
+#endif
         // build path to TXT_RX[i] and TXT_TX[i] chdevs
 …
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_REFERENCE_INIT )
 printk("\n[DBG] %s : thread %x / stdin open for process %x / cycle %d\n",
 __FUNCTION__ , CURRENT_THREAD , pid , cycle );
+printk("\n[DBG] %s : thread %x in process %x / stdin open for process %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, parent_pid, pid, cycle );
 #endif
 …
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_REFERENCE_INIT )
 printk("\n[DBG] %s : thread %x / stdout open for process %x / cycle %d\n",
 __FUNCTION__ , CURRENT_THREAD , pid , cycle );
+printk("\n[DBG] %s : thread %x in process %x / stdout open for process %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, parent_pid, pid, cycle );
 #endif
 …
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_REFERENCE_INIT )
 printk("\n[DBG] %s : thread %x / stderr open for process %x / cycle %d\n",
 __FUNCTION__ , CURRENT_THREAD , pid , cycle );
+printk("\n[DBG] %s : thread %x in process %x / stderr open for process %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, parent_pid, pid, cycle );
 #endif
 …
     else                                            // normal user process
+    {
         // get extended pointer on stdin pseudo file in model process
         file_xp = (xptr_t)hal_remote_lwd( XPTR( model_cxy , &model_ptr->fd_array.array[0] ) );
         // get extended pointer on model process TXT chdev
+        // get extended pointer on stdin pseudo file in parent process
+        file_xp = (xptr_t)hal_remote_lwd( XPTR( parent_cxy , &parent_ptr->fd_array.array[0] ) );
+        // get extended pointer on parent process TXT chdev
         chdev_xp = chdev_from_file( file_xp );
 …
         process_txt_attach( process , txt_id );
         // copy all open files from model process fd_array to this process
+        // copy all open files from parent process fd_array to this process
         process_fd_remote_copy( XPTR( local_cxy , &process->fd_array ),
                                 XPTR( model_cxy , &model_ptr->fd_array ) );
+                                XPTR( parent_cxy , &parent_ptr->fd_array ) );
+    }
     // initialize specific inodes root and cwd
     process->vfs_root_xp = (xptr_t)hal_remote_lwd( XPTR( model_cxy,
                                                          &model_ptr->vfs_root_xp ) );
     process->vfs_cwd_xp  = (xptr_t)hal_remote_lwd( XPTR( model_cxy,
                                                          &model_ptr->vfs_cwd_xp ) );
+    process->vfs_root_xp = (xptr_t)hal_remote_lwd( XPTR( parent_cxy,
+                                                         &parent_ptr->vfs_root_xp ) );
+    process->vfs_cwd_xp  = (xptr_t)hal_remote_lwd( XPTR( parent_cxy,
+                                                         &parent_ptr->vfs_cwd_xp ) );
     vfs_inode_remote_up( process->vfs_root_xp );
     vfs_inode_remote_up( process->vfs_cwd_xp );
 …
 ////////////////////////////////////////
 void process_sigaction( pid_t       pid,
                         uint32_t    action_type )
+                        uint32_t    type )
+{
     cxy_t              owner_cxy;         // owner cluster identifier
 …
     xptr_t             process_xp;        // extended pointer on process copy
     cxy_t              process_cxy;       // process copy cluster identifier
+    process_t        * process_ptr;       // local pointer on process copy
     reg_t              save_sr;           // for critical section
     rpc_desc_t         rpc;               // shared RPC descriptor
+    thread_t * client = CURRENT_THREAD;
+    thread_t         * client;            // pointer on client thread
+    xptr_t             client_xp;         // extended pointer on client thread
+    process_t        * local;             // pointer on process copy in local cluster
+    uint32_t           remote_nr;         // number of remote process copies
+    client    = CURRENT_THREAD;
+    client_xp = XPTR( local_cxy , client );
+    local     = NULL;
+    remote_nr = 0;
 #if DEBUG_PROCESS_SIGACTION
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_SIGACTION < cycle )
+printk("\n[DBG] %s : thread %x enter to %s process %x / cycle %d\n",
+__FUNCTION__ , client, process_action_str( action_type ) , pid , cycle );
+printk("\n[DBG] %s : thread %x in process %x enter to %s process %x / cycle %d\n",
+__FUNCTION__ , client->trdid, client->process->pid,
+process_action_str( type ) , pid , cycle );
 #endif
 …
     // check action type
     assert( ((action_type == DELETE_ALL_THREADS ) ||
              (action_type == BLOCK_ALL_THREADS )  ||
              (action_type == UNBLOCK_ALL_THREADS )), __FUNCTION__ , "illegal action type" );
+    assert( ((type == DELETE_ALL_THREADS ) ||
+             (type == BLOCK_ALL_THREADS )  ||
+             (type == UNBLOCK_ALL_THREADS )), __FUNCTION__ , "illegal action type" );
+    // allocate a - shared - RPC descriptor in client thread stack
+    // it can be shared because all parallel, non-blocking, server threads
+    // use the same input arguments, and use the shared RPC response field
+    // the client thread makes the following sequence:
+    // 1. mask interrupts
+    // 2. block itself
+    // 3. send RPC requests to all copies
+    // 4. unmask interrupts
+    // 5. deschedule
+    // The client thread send parallel RPCs to all remote clusters containing
+    // target process copies, wait all responses, and then handles directly the
+    // threads in local cluster, when required.
+    // The client thread allocates a - shared - RPC descriptor in the stack,
+    // because all parallel, non-blocking, server threads use the same input
+    // arguments, and use the shared RPC response field
     // mask IRQs
     hal_disable_irq( &save_sr);
     // client register blocking condition for itself
     thread_block( XPTR( local_cxy , client ) , THREAD_BLOCKED_RPC );
+    // client thread blocks itself
+    thread_block( client_xp , THREAD_BLOCKED_RPC );
     // take the lock protecting the copies
 …
     rpc.thread    = client;
     rpc.lid       = client->core->lid;
     rpc.args[0]   = action_type;
+    rpc.args[0]   = type;
     rpc.args[1]   = pid;
+    // send RPCs to all clusters containing process copiess
+    // scan list of process copies
+    // to send RPCs to remote copies
     XLIST_FOREACH( root_xp , iter_xp )
+    {
+        // atomically increment responses counter
+        hal_atomic_add( (void *)&rpc.responses , 1 );
+        // get extended pointers and cluster on process
         process_xp  = XLIST_ELEMENT( iter_xp , process_t , copies_list );
         process_cxy = GET_CXY( process_xp );
+        process_ptr = GET_PTR( process_xp );
+        if( process_cxy == local_cxy )    // process is local
+        {
+            local = process_ptr;
+        }
+        else                              // process is remote
+        {
+            // update number of remote process copies
+            remote_nr++;
+            // atomically increment responses counter
+            hal_atomic_add( (void *)&rpc.responses , 1 );
 #if DEBUG_PROCESS_SIGACTION
 if( DEBUG_PROCESS_SIGACTION < cycle )
+printk("\n[DBG] %s : send RPC to %s process %x in cluster %x\n",
+__FUNCTION__ , process_action_str( action_type ) , pid , process_cxy );
+#endif
+        // call RPC in target cluster
+        rpc_process_sigaction_client( process_cxy , &rpc );
+    }
+printk("\n[DBG] %s : thread %x in process %x handles remote process %x in cluster %x\n",
+__FUNCTION__, client->trdid, client->process->pid, pid , process_cxy );
+#endif
+            // call RPC in target cluster
+            rpc_process_sigaction_client( process_cxy , &rpc );
+        }
+    }  // end list of copies
     // release the lock protecting process copies
     remote_spinlock_unlock( lock_xp );
 …
     hal_restore_irq( save_sr);
+    // client thread deschedule : will be unblocked by the last RPC server thread
+    sched_yield("blocked on rpc_process_sigaction");
+    // - if there is remote process copies, the client thread deschedules,
+    //   (it will be unblocked by the last RPC server thread).
+    // - if there is no remote copies, the client thread unblock itself.
+    if( remote_nr )
+    {
+        sched_yield("blocked on rpc_process_sigaction");
+    }
+    else
+    {
+        thread_unblock( client_xp , THREAD_BLOCKED_RPC );
+    }
+    // handle the local process copy if required
+    if( local != NULL )
+    {
+#if DEBUG_PROCESS_SIGACTION
+if( DEBUG_PROCESS_SIGACTION < cycle )
+printk("\n[DBG] %s : thread %x in process %x handles local process %x in cluster %x\n",
+__FUNCTION__, client->trdid, client->process->pid, pid , local_cxy );
+#endif
+        if     (type == DELETE_ALL_THREADS  ) process_delete_threads ( local , client_xp );
+        else if(type == BLOCK_ALL_THREADS   ) process_block_threads  ( local , client_xp );
+        else if(type == UNBLOCK_ALL_THREADS ) process_unblock_threads( local );
+    }
 #if DEBUG_PROCESS_SIGACTION
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_SIGACTION < cycle )
+printk("\n[DBG] %s : thread %x exit after %s process %x in cluster %x / cycle %d\n",
+__FUNCTION__ , client, process_action_str( action_type ) , pid , local_cxy , cycle );
+printk("\n[DBG] %s : thread %x in process %x exit after %s process %x / cycle %d\n",
+__FUNCTION__, client->trdid, client->process->pid,
+process_action_str( type ), pid, cycle );
 #endif
 …
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_MAKE_FORK < cycle )
 printk("\n[DBG] %s : thread %x enter for process %x / cluster %x / cycle %d\n",
 __FUNCTION__, CURRENT_THREAD, parent_pid, local_cxy, cycle );
+printk("\n[DBG] %s : thread %x in process %x enter / cluster %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, local_cxy, cycle );
 #endif
 …
+    }
+#if DEBUG_PROCESS_MAKE_FORK
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_PROCESS_MAKE_FORK < cycle )
+printk("\n[DBG] %s : thread %x in process %x allocated process %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, new_pid, cycle );
+#endif
     // initializes child process descriptor from parent process descriptor
     process_reference_init( process,
                             new_pid,
-                            parent_process_xp,
                             parent_process_xp );
 …
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_MAKE_FORK < cycle )
+printk("\n[DBG] %s : thread %x created child_process %x / child_pid %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, process, new_pid, cycle );
+#endif
+printk("\n[DBG] %s : thread %x in process %x initialized child_process %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, new_pid, cycle );
+#endif
+    // give TXT ownership to child process
+    process_txt_set_ownership( XPTR( local_cxy , process ) );
     // copy VMM from parent descriptor to child descriptor
 …
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_MAKE_FORK < cycle )
+printk("\n[DBG] %s : thread %x copied VMM from parent %x to child %x / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , parent_pid, new_pid, cycle );
+#endif
+printk("\n[DBG] %s : thread %x in process %x copied VMM from parent %x to child %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid,
+parent_pid, new_pid, cycle );
+#endif
+    // parent process gives TXT ownership to child process if required
+    if( process_txt_is_owner(parent_process_xp) )
+    {
+        process_txt_set_ownership( XPTR( local_cxy , process ) );
+#if( DEBUG_PROCESS_MAKE_FORK & 1 )
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_PROCESS_MAKE_EXEC < cycle )
+printk("\n[DBG] %s : thread %x in process %x gives TXT from parent %x to child %x / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid,
+parent_pid, new_pid, cycle );
+#endif
+    }
     // update extended pointer on .elf file
 …
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_MAKE_FORK < cycle )
+printk("\n[DBG] %s : thread %x created child thread %x on core[%x,%d] / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD, thread, local_cxy, thread->core->lid, cycle );
+printk("\n[DBG] %s : thread %x in process %x created main thread %x on core[%x,%d] / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid,
+thread, local_cxy, thread->core->lid, cycle );
 #endif
 …
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_MAKE_FORK < cycle )
 printk("\n[DBG] %s : thread %x set COW in parent and child / cycle %d\n",
 __FUNCTION__ , CURRENT_THREAD, cycle );
+printk("\n[DBG] %s : thread %x in process %x set COW in parent and child / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, cycle );
 #endif
 …
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_MAKE_FORK < cycle )
 printk("\n[DBG] %s : thread %x exit / cycle %d\n",
 __FUNCTION__, CURRENT_THREAD, cycle );
+printk("\n[DBG] %s : thread %x in process %x exit / created process %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, new_pid, cycle );
 #endif
 …
 }   // end process_make_fork()
 /////////////////////////////////////////////////////
 error_t process_make_exec( exec_info_t  * exec_info )
+{
+    char           * path;                    // pathname to .elf file
+    pid_t            pid;                     // old_process PID, given to new_process
+    pid_t            temp_pid;                // temporary PID / given to old_process
+    process_t      * old_process;             // local pointer on old process
+    thread_t       * old_thread;              // local pointer on old thread
+    process_t      * new_process;             // local pointer on new process
+    thread_t       * new_thread;              // local pointer on new thread
+    xptr_t           parent_xp;               // extended pointer on parent process
+    process_t      * parent_ptr;              // local pointer on parent process
+    cxy_t            parent_cxy;              // parent process cluster identifier
+    xptr_t           children_lock_xp;        // extended pointer on children lock in parent
+    xptr_t           children_root_xp;        // extended pointer on children root in parent
+    xptr_t           children_nr_xp;          // extended pointer on children number in parent
+    thread_t       * parent_main_ptr;         // local pointer on parent main thread
+    xptr_t           parent_main_xp;          // extended pointer on parent main thread
+    pthread_attr_t   attr;                    // new thread attributes
+    lid_t            lid;                     // selected core local index
+    thread_t       * thread;                  // local pointer on this thread
+    process_t      * process;                 // local pointer on this process
+    pid_t            pid;                     // this process identifier
         error_t          error;                   // value returned by called functions
     // get old_thread, old_process & PID
     old_thread  = CURRENT_THREAD;
     old_process = old_thread->process;
     pid         = old_process->pid;
+        // get .elf pathname from exec_info
         path = exec_info->path;
     // this function must be executed by a thread running in owner cluster
+    assert( (CXY_FROM_PID( pid ) == local_cxy), __FUNCTION__,
+    "local_cluster must be owner_cluster\n" );
     assert( (LTID_FROM_TRDID( old_thread->trdid ) == 0) , __FUNCTION__,
     "must be called by the main thread\n" );
+    char           * path;                    // path to .elf file
+    xptr_t           file_xp;                 // extended pointer on .elf file descriptor
+    uint32_t         file_id;                 // file index in fd_array
+    uint32_t         args_nr;                 // number of main thread arguments
+    char          ** args_pointers;           // array of pointers on main thread arguments
+    // get thread, process & PID
+    thread  = CURRENT_THREAD;
+    process = thread->process;
+    pid     = process->pid;
+        // get relevant infos from exec_info
+        path          = exec_info->path;
+    args_nr       = exec_info->args_nr;
+    args_pointers = exec_info->args_pointers;
 #if DEBUG_PROCESS_MAKE_EXEC
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_MAKE_EXEC < cycle )
 printk("\n[DBG] %s : thread %x in process %x enters / path %s / cycle %d\n",
+__FUNCTION__, old_thread->trdid, pid, path, cycle );
+#endif
+    // get parent process pointers
+    parent_xp   = old_process->parent_xp;
+    parent_cxy  = GET_CXY( parent_xp );
+    parent_ptr  = GET_PTR( parent_xp );
+__FUNCTION__, thread->trdid, pid, path, cycle );
+#endif
+    // open the file identified by <path>
+    file_xp = XPTR_NULL;
+    file_id = -1;
+        error   = vfs_open( process,
+                            path,
+                            O_RDONLY,
+,
+                            &file_xp,
+                            &file_id );
+        if( error )
+        {
+                printk("\n[ERROR] in %s : failed to open file <%s>\n", __FUNCTION__ , path );
+                return -1;
+        }
 #if (DEBUG_PROCESS_MAKE_EXEC & 1)
 if( DEBUG_PROCESS_MAKE_EXEC < cycle )
+printk("\n[DBG] %s : thread %x in process %x get parent process %x in cluster %x\n",
+__FUNCTION__, old_thread->trdid, pid, parent_ptr, parent_cxy );
+#endif
+    // get extended pointers on parent children_root, children_lock and children_nr
+    children_root_xp = XPTR( parent_cxy , &parent_ptr->children_root );
+    children_lock_xp = XPTR( parent_cxy , &parent_ptr->children_lock );
+    children_nr_xp   = XPTR( parent_cxy , &parent_ptr->children_nr   );
+    // get pointers on the parent process main thread
+    parent_main_ptr = hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->th_tbl[0] ) );
+    parent_main_xp  = XPTR( parent_cxy , parent_main_ptr );
+     // allocate memory for new_process descriptor
+    new_process = process_alloc();
+    if( new_process == NULL )
+    {
+        printk("\n[ERROR] in %s : cannot allocate process for %s\n", __FUNCTION__ , path );
+printk("\n[DBG] %s : open file <%s>\n", __FUNCTION__, path );
+#endif
+    // delete all threads other than this main thread in all clusters
+    process_sigaction( pid , DELETE_ALL_THREADS );
+    // reset local process VMM
+    vmm_destroy( process );
+#if( DEBUG_PROCESS_MAKE_EXEC & 1 )
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_PROCESS_MAKE_EXEC < cycle )
+printk("\n[DBG] %s : thread %x in process %x / reset VMM / cycle %d\n",
+__FUNCTION__, thread->trdid, pid, cycle );
+#endif
+    // re-initialize the VMM (kentry/args/envs vsegs registration)
+    error = vmm_init( process );
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot initialise VMM for %s\n", __FUNCTION__ , path );
+        vfs_close( file_xp , file_id );
+        // FIXME restore old process VMM
         return -1;
+    }
+    // get a temporary PID for old_process
+    error = cluster_pid_alloc( old_process , &temp_pid );
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot get PID in cluster %x\n",
+        __FUNCTION__ , local_cxy );
+        process_free( new_process );
+        return -1;
+    }
+    // set temporary PID to old_process
+    old_process->pid = temp_pid;
+    // initialize new process descriptor
+    process_reference_init( new_process,
+                            pid,
+                            parent_xp,                          // parent_process_xp
+                            XPTR(local_cxy , old_process) );    // model_process
+    // give TXT ownership to new_process
+    process_txt_set_ownership( XPTR( local_cxy , new_process) );
 #if( DEBUG_PROCESS_MAKE_EXEC & 1 )
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_MAKE_EXEC < cycle )
 printk("\n[DBG] %s : thread %x in process %x created new process %x\n",
 __FUNCTION__ , old_thread->trdid, pid, new_process );
 #endif
     // register code & data vsegs as well as entry-point in new process VMM,
+printk("\n[DBG] %s : thread %x in process %x / kentry/args/envs vsegs registered / cycle %d\n",
+__FUNCTION__, thread->trdid, pid, cycle );
+#endif
+    // register code & data vsegs as well as entry-point in process VMM,
     // and register extended pointer on .elf file in process descriptor
+        error = elf_load_process( path , new_process );
+        error = elf_load_process( file_xp , process );
     if( error )
+        {
                 printk("\n[ERROR] in %s : failed to access <%s>\n", __FUNCTION__ , path );
+        process_txt_set_ownership( XPTR( local_cxy , old_process) );
+        process_txt_detach( XPTR( local_cxy , new_process) );
+        process_destroy( new_process );
+        old_process->pid = pid;
+        vfs_close( file_xp , file_id );
+        // FIXME restore old process VMM
         return -1;
+        }
 …
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_MAKE_EXEC < cycle )
+printk("\n[DBG] %s : thread %x registered code/data vsegs in new process %x / cycle %d\n",
+__FUNCTION__, old_thread , new_process->pid , cycle );
+#endif
+    // select a core in local cluster to execute the main thread
+    lid  = cluster_select_local_core();
+    // initialize pthread attributes for main thread
+    attr.attributes = PT_ATTR_DETACH | PT_ATTR_CLUSTER_DEFINED | PT_ATTR_CORE_DEFINED;
+    attr.cxy        = local_cxy;
+    attr.lid        = lid;
+    // create and initialize main thread in local cluster
+        error = thread_user_create( pid,
+                                (void *)new_process->vmm.entry_point,
+                                exec_info->args_pointers,
+                                &attr,
+                                &new_thread );
+        if( error )
+        {
+                printk("\n[ERROR] in %s : cannot create thread for %s\n", __FUNCTION__ , path );
+        process_txt_set_ownership( XPTR( local_cxy , old_process) );
+        process_txt_detach( XPTR( local_cxy , new_process) );
+        process_destroy( new_process );
+        old_process->pid = pid;
+printk("\n[DBG] %s : thread %x in process %x / code/data vsegs registered / cycle %d\n",
+__FUNCTION__, thread->trdid, pid, cycle );
+#endif
+    // update the existing main thread descriptor... and jump to user code
+    error = thread_user_exec( (void *)process->vmm.entry_point,
+                              args_nr,
+                              args_pointers );
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot reset main thread for %s\n", __FUNCTION__ , path );
+        vfs_close( file_xp , file_id );
+        // FIXME restore old process VMM
         return -1;
+        }
+    // check main thread LTID
+    assert( (LTID_FROM_TRDID(new_thread->trdid) == 0) , __FUNCTION__ ,
+    "main thread must have LTID == 0\n" );
+#if( DEBUG_PROCESS_MAKE_EXEC & 1 )
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_PROCESS_MAKE_EXEC < cycle )
+printk("\n[DBG] %s : thread %x created new_process main thread %x / cycle %d\n",
+__FUNCTION__ , old_thread , new_thread , cycle );
+#endif
+    // register new_process in parent children list
+    remote_spinlock_lock( children_lock_xp );
+        xlist_add_last( children_root_xp , XPTR( local_cxy , &new_process->children_list ) );
+        hal_remote_atomic_add( children_nr_xp , 1 );
+    remote_spinlock_unlock( children_lock_xp );
+    // activate new thread
+        thread_unblock( XPTR( local_cxy , new_thread ) , THREAD_BLOCKED_GLOBAL );
+    // detach old_process from TXT
+    process_txt_detach( XPTR( local_cxy , old_process ) );
+    // block old_thread
+    thread_block( XPTR( local_cxy , old_thread ) , THREAD_BLOCKED_GLOBAL );
+    // atomically update old_process termination state
+    hal_atomic_or( &old_process->term_state , PROCESS_TERM_EXIT );
+    // take the children lock and unblock the parent process main thread
+    remote_spinlock_lock( children_lock_xp );
+    thread_unblock( parent_main_xp , THREAD_BLOCKED_WAIT );
+    remote_spinlock_unlock( children_lock_xp );
+    hal_fence();
+#if DEBUG_PROCESS_MAKE_EXEC
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_PROCESS_MAKE_EXEC < cycle )
+printk("\n[DBG] %s : old thread %x blocked for delete / new thread %x activated / cycle %d\n",
+__FUNCTION__ , old_thread , new_thread , cycle );
+#endif
+    }
+    assert( false, __FUNCTION__, "we should not execute this code");
         return 0;
 }  // end process_make_exec()
 ///////////////////////////////////////////////
 …
     pthread_attr_t   attr;          // main thread attributes
     lid_t            lid;           // selected core local index for main thread
+    xptr_t           file_xp;       // extended pointer on .elf file descriptor
+    uint32_t         file_id;       // file index in fd_array
     error_t          error;
 …
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_INIT_CREATE < cycle )
+printk("\n[DBG] %s : thread %x enter / cycle %d\n", __FUNCTION__, CURRENT_THREAD, cycle );
+printk("\n[DBG] %s : thread %x in process %x enter / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, cycle );
 #endif
     // allocates memory for process descriptor from local cluster
         process = process_alloc();
+        if( process == NULL )
+    {
+                printk("\n[PANIC] in %s : no memory for process descriptor in cluster %x\n",
+                __FUNCTION__, local_cxy  );
+    }
+    assert( (process != NULL), __FUNCTION__,
+    "no memory for process descriptor in cluster %x\n", local_cxy  );
     // get PID from local cluster
     error = cluster_pid_alloc( process , &pid );
+    if( error )
+    {
+                printk("\n[PANIC] in %s : cannot allocate PID in cluster %x\n",
+                __FUNCTION__, local_cxy );
+        process_free( process );
+    }
+    // check allocated PID
+    assert( (pid == 1) , __FUNCTION__ , "process INIT must be first process in cluster 0\n" );
+    assert( (error == 0), __FUNCTION__,
+    "cannot allocate PID in cluster %x\n", local_cxy );
+    assert( (pid == 1) , __FUNCTION__,
+    "process INIT must be first process in cluster 0\n" );
     // initialize process descriptor / parent is local process_zero
     process_reference_init( process,
                             pid,
+                            XPTR( local_cxy , &process_zero ),     // parent
+                            XPTR( local_cxy , &process_zero ) );   // model
+                            XPTR( local_cxy , &process_zero ) );
+    // open the file identified by CONFIG_PROCESS_INIT_PATH
+    file_xp = XPTR_NULL;
+    file_id = -1;
+        error   = vfs_open( process,
+                            CONFIG_PROCESS_INIT_PATH,
+                            O_RDONLY,
+,
+                            &file_xp,
+                            &file_id );
+        assert( (error == 0), __FUNCTION__,
+    "failed to open file <%s>\n", CONFIG_PROCESS_INIT_PATH );
     // register "code" and "data" vsegs as well as entry-point
     // in process VMM, using information contained in the elf file.
+        if( elf_load_process( CONFIG_PROCESS_INIT_PATH , process ) )
+        {
+                printk("\n[PANIC] in %s : cannot access .elf file / path = %s\n",
+                __FUNCTION__, CONFIG_PROCESS_INIT_PATH );
+        process_destroy( process );
+        }
+        error = elf_load_process( file_xp , process );
+        assert( (error == 0), __FUNCTION__,
+    "cannot access .elf file <%s>\n", CONFIG_PROCESS_INIT_PATH );
     // get extended pointers on process_zero children_root, children_lock
 …
                                 &attr,
                                 &thread );
+        if( error )
+        {
+                printk("\n[PANIC] in %s : cannot create main thread / path = %s\n",
+                __FUNCTION__, CONFIG_PROCESS_INIT_PATH );
+        process_destroy( process );
+        }
+    // check main thread index
+    assert( (thread->trdid == 0) , __FUNCTION__ , "main thread must have index 0\n" );
+        assert( (error == 0), __FUNCTION__,
+    "cannot create main thread for <%s>\n", CONFIG_PROCESS_INIT_PATH );
+    assert( (thread->trdid == 0), __FUNCTION__,
+    "main thread must have index 0 for <%s>\n", CONFIG_PROCESS_INIT_PATH );
     // activate thread
 …
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_INIT_CREATE < cycle )
+printk("\n[DBG] %s : thread %x exit / cycle %d\n", __FUNCTION__, CURRENT_THREAD, cycle );
+printk("\n[DBG] %s : thread %x in process %x exit / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, cycle );
 #endif
 …
     xptr_t      lock_xp;      // extended pointer on list lock in chdev
-#if DEBUG_PROCESS_TXT
-uint32_t cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_PROCESS_TXT < cycle )
-printk("\n[DBG] %s : thread %x enter for process %x / txt_id = %d  / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, process->pid, txt_id, cycle );
-#endif
     // check process is in owner cluster
     assert( (CXY_FROM_PID( process->pid ) == local_cxy) , __FUNCTION__ ,
 …
 #if DEBUG_PROCESS_TXT
 cycle = (uint32_t)hal_get_cycles();
+uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_TXT < cycle )
+printk("\n[DBG] %s : thread %x exit for process %x / txt_id = %d / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, process->pid, txt_id , cycle );
+printk("\n[DBG] %s : thread %x in process %x attached process %x to TXT %d / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid,
+process->pid, txt_id , cycle );
 #endif
 …
     process_cxy = GET_CXY( process_xp );
     process_ptr = GET_PTR( process_xp );
+    // check process descriptor in owner cluster
     process_pid = hal_remote_lw( XPTR( process_cxy , &process_ptr->pid ) );
-    // check process descriptor in owner cluster
     assert( (CXY_FROM_PID( process_pid ) == process_cxy ) , __FUNCTION__ ,
     "process descriptor not in owner cluster" );
-#if DEBUG_PROCESS_TXT
-uint32_t cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_PROCESS_TXT < cycle )
-printk("\n[DBG] %s : thread %x enter for process %x / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, process_pid, cycle );
-#endif
     // release TXT ownership (does nothing if not TXT owner)
 …
 #if DEBUG_PROCESS_TXT
 cycle  = (uint32_t)hal_get_cycles();
+uint32_t cycle  = (uint32_t)hal_get_cycles();
 uint32_t txt_id = hal_remote_lw( XPTR( chdev_cxy , &chdev_ptr->channel ) );
 if( DEBUG_PROCESS_TXT < cycle )
+printk("\n[DBG] %s : thread %x exit / process %x detached from TXT %d / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, process_pid, txt_id, cycle );
+printk("\n[DBG] %s : thread %x in process %x detached process %x from TXT %d / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid,
+process_pid, txt_id, cycle );
 #endif
 …
     process_cxy = GET_CXY( process_xp );
     process_ptr = GET_PTR( process_xp );
-    // get process PID
     process_pid = hal_remote_lw( XPTR( process_cxy , &process_ptr->pid ) );
 …
     assert( (process_cxy == CXY_FROM_PID( process_pid )) , __FUNCTION__,
     "process descriptor not in owner cluster\n" );
-#if DEBUG_PROCESS_TXT
-uint32_t cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_PROCESS_TXT < cycle )
-printk("\n[DBG] %s : thread %x enter for process %x / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, process_pid, cycle );
-#endif
     // get extended pointer on stdin pseudo file
 …
 #if DEBUG_PROCESS_TXT
+cycle = (uint32_t)hal_get_cycles();
+uint32_t cycle  = (uint32_t)hal_get_cycles();
+uint32_t txt_id = hal_remote_lw( XPTR( txt_cxy , &txt_ptr->channel ) );
 if( DEBUG_PROCESS_TXT < cycle )
 printk("\n[DBG] %s : thread %x exit for process %x / cycle %d\n",
 __FUNCTION__, CURRENT_THREAD, process_pid, cycle );
+printk("\n[DBG] %s : thread %x in process %x give TXT %d to process %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, txt_id, process_pid, cycle );
 #endif
 …
     cxy_t       current_cxy;     // cluster for current process
+#if DEBUG_PROCESS_TXT
+uint32_t cycle;
+#endif
     // get pointers on process in owner cluster
     process_cxy = GET_CXY( process_xp );
     process_ptr = GET_PTR( process_xp );
-    // get process PID
     process_pid = hal_remote_lw( XPTR( process_cxy , &process_ptr->pid ) );
 …
     assert( (process_cxy == CXY_FROM_PID( process_pid )) , __FUNCTION__,
     "process descriptor not in owner cluster\n" );
-#if DEBUG_PROCESS_TXT
-uint32_t cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_PROCESS_TXT < cycle )
-printk("\n[DBG] %s : thread %x enter / process %x / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, process_pid, cycle );
-#endif
     // get extended pointer on stdin pseudo file
 …
     txt_id   = hal_remote_lw ( XPTR( txt_cxy , &txt_ptr->channel ) );
-#if( DEBUG_PROCESS_TXT & 1 )
-if( DEBUG_PROCESS_TXT < cycle )
-printk("\n[DBG] %s : file_ptr %x / txt_ptr %x / txt_id %d / owner_ptr = %x\n",
-__FUNCTION__, GET_PTR(file_xp), txt_ptr, txt_id, GET_PTR(owner_xp) );
-#endif
     // transfer ownership only if process is the TXT owner
     if( (owner_xp == process_xp) && (txt_id > 0) )
 …
         if( process_get_ppid( process_xp ) != 1 )           // process is not KSH
+        {
-#if( DEBUG_PROCESS_TXT & 1 )
-if( DEBUG_PROCESS_TXT < cycle )
-printk("\n[DBG] %s : process is not the KSH process => search the KSH\n", __FUNCTION__ );
-#endif
             // scan attached process list to find KSH process
             XLIST_FOREACH( root_xp , iter_xp )
 …
 #if DEBUG_PROCESS_TXT
+cycle = (uint32_t)hal_get_cycles();
+cycle   = (uint32_t)hal_get_cycles();
+uint32_t ksh_pid = hal_remote_lw( XPTR( current_cxy , &current_ptr->pid ) );
 if( DEBUG_PROCESS_TXT < cycle )
 printk("\n[DBG] %s : thread %x exit / process %x to KSH process %x / cycle %d\n",
 __FUNCTION__, CURRENT_THREAD, process_pid,
 hal_remote_lw( XPTR( current_cxy , &current_ptr->pid ) ), cycle );
+printk("\n[DBG] %s : thread %x in process %x release TXT %d to KSH %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, txt_id, ksh_pid, cycle );
+process_txt_display( txt_id );
 #endif
                      return;
 …
         else                                               // process is KSH
+        {
-#if( DEBUG_PROCESS_TXT & 1 )
-if( DEBUG_PROCESS_TXT < cycle )
-printk("\n[DBG] %s : process is the KSH process => search another\n", __FUNCTION__ );
-#endif
             // scan attached process list to find another process
             XLIST_FOREACH( root_xp , iter_xp )
 …
 #if DEBUG_PROCESS_TXT
+cycle = (uint32_t)hal_get_cycles();
+cycle   = (uint32_t)hal_get_cycles();
+uint32_t new_pid = hal_remote_lw( XPTR( current_cxy , &current_ptr->pid ) );
 if( DEBUG_PROCESS_TXT < cycle )
 printk("\n[DBG] %s : thread %x exit / KSH process %x to process %x / cycle %d\n",
 __FUNCTION__, CURRENT_THREAD, process_pid,
 hal_remote_lw( XPTR( current_cxy , &current_ptr->pid ) ), cycle );
+printk("\n[DBG] %s : thread %x in process %x release TXT %d to process %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, txt_id, new_pid, cycle );
+process_txt_display( txt_id );
 #endif
                      return;
 …
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_TXT < cycle )
+printk("\n[DBG] %s : thread %x exit / KSH process %x to nobody / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, process_pid, cycle );
+printk("\n[DBG] %s : thread %x in process %x release TXT %d to nobody / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, txt_id, cycle );
+process_txt_display( txt_id );
 #endif
             return;
 …
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_TXT < cycle )
+printk("\n[DBG] %s : thread %x exit / process %x is not TXT owner / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, process_pid, cycle );
+printk("\n[DBG] %s : thread %x in process %d does nothing (not TXT owner) / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, process_pid, cycle );
+process_txt_display( txt_id );
 #endif
 …
 }  // end process_txt_transfer_ownership()
+//////////////////////////////////////////////////
+uint32_t process_txt_is_owner( xptr_t process_xp )
+{
+    // get local pointer and cluster of process in owner cluster
+    cxy_t       process_cxy = GET_CXY( process_xp );
+    process_t * process_ptr = GET_PTR( process_xp );
+    // check owner cluster
+    pid_t process_pid = hal_remote_lw( XPTR( process_cxy , &process_ptr->pid ) );
+    assert( (process_cxy == CXY_FROM_PID( process_pid )) , __FUNCTION__,
+    "process descriptor not in owner cluster\n" );
+    // get extended pointer on stdin pseudo file
+    xptr_t file_xp = hal_remote_lwd( XPTR( process_cxy , &process_ptr->fd_array.array[0] ) );
+    // get pointers on TXT chdev
+    xptr_t    txt_xp  = chdev_from_file( file_xp );
+    cxy_t     txt_cxy = GET_CXY( txt_xp );
+    chdev_t * txt_ptr = GET_PTR( txt_xp );
+    // get extended pointer on TXT_RX owner process
+    xptr_t owner_xp = hal_remote_lwd( XPTR( txt_cxy , &txt_ptr->ext.txt.owner_xp ) );
+    return (process_xp == owner_xp);
+}   // end process_txt_is_owner()
 ////////////////////////////////////////////////
 …
     return (xptr_t)hal_remote_lwd( XPTR( txt_rx_cxy , &txt_rx_ptr->ext.txt.owner_xp ) );
+}
+}  // end process_txt_get_owner()
 ///////////////////////////////////////////

trunk/kernel/kern/process.h

-                      r450
+                      r457
 #include <kernel_config.h>
 #include <errno.h>
 #include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <list.h>
 #include <xlist.h>
 …
     uint32_t          term_state;       /*! termination status (flags & exit status)        */
-    bool_t            txt_owner;        /*! current TXT owner                               */
+}
 process_t;
 …
 /*********************************************************************************************
  * This function initializes a local, reference, user process descriptor from another process
+ * descriptor, defined by the <model_xp> argument. The <process> and <pid> arguments must
+ * be previously allocated by he caller. This function can be called by three functions:
+ * 1) process_init_create() : process is the reference INIT process / pid = 1 /
+ *    the parent and model process descriptors are both the kernel process_zero.
+ * 2) process_make_fork() : the model process descriptor is the (generally remote)
+ *    parent process.
+ * 3) process_make exec() : the model process is the local old_process, the new_process
+ *    parent is the same as the old_process parent.
+ * descriptor, defined by the <parent_xp> argument. The <process> and <pid> arguments must
+ * be previously allocated by the caller. This function can be called by two functions:
+ * 1) process_init_create() : process is the INIT process; parent is process-zero.
+ * 2) process_make_fork() : the parent process descriptor is generally remote.
  * The following fields are initialised :
  * - It set the pid / ppid / ref_xp / parent_xp / state fields.
  * - It initializes the VMM (register the kentry, args, envs vsegs in VSL)
  * - It initializes the FDT, defining the three pseudo files STDIN / STDOUT / STDERR.
+ *   . if INIT process     => link to kernel TXT[0].
+ *   . if KSH[i] process   => allocate a free TXT[i] and give TXT ownership.
+ *   . if USER process     => same TXT[i] as parent process and give TXT ownership.
  * - It set the root_xp, bin_xp, cwd_xp fields.
  * - It reset the children list as empty, but does NOT register it in parent children list.
 …
  * @ pid          : [in] process identifier.
  * @ parent_xp    : [in] extended pointer on parent process descriptor.
- * @ model_xp     : [in] extended pointer on model process descriptor.
  ********************************************************************************************/
 void process_reference_init( process_t * process,
                              pid_t       pid,
+                             xptr_t      parent_xp,
+                             xptr_t      model_xp );
+                             xptr_t      parent_xp );
 /*********************************************************************************************
 …
  * It is called only by the process_reference_init() function when creating a KSH process.
  * It makes a kernel panic if no free TXT terminal is found.
+ * The allocated TXT terminal is only released if the KSH process is deleted,
+ * which is a rare and abnormal event.
+ * The allocated TXT terminal is only released when the KSH process is deleted.
  *********************************************************************************************
  * @ return TXT terminal index if succes / kernel panic if no terminal found.
 …
 /*********************************************************************************************
  * This function gives to a process identified by the <owner_xp> argument, and attached
  * to terminal TXT[i] the exclusive ownership of the TXT_RX[i] terminal.
  * The process descriptor must be in the process owner cluster.
+ * This function gives the TXT ownership to a process identified by the <process_xp> argument.
+ * It can be called by a thread running in any cluster, but the <process_xp> must be the
+ * owner cluster process descriptor.
  *********************************************************************************************
  * @ owner_xp  : extended pointer on process descriptor in owner cluster.
  ********************************************************************************************/
 void process_txt_set_ownership( xptr_t owner_xp );
 /*********************************************************************************************
  * When the process dentified by the <owner_xp> argument has the exclusive ownership of
+void process_txt_set_ownership( xptr_t process_xp );
+/*********************************************************************************************
+ * When the process identified by the <owner_xp> argument has the exclusive ownership of
  * the TXT_RX terminal, this function transfer this ownership to another attached process.
  * The process descriptor must be the process owner.
 …
  * - If there is no other attached process, the TXT has no more defined owner.
  *********************************************************************************************
+ * @ owner_xp  : extended pointer on process descriptor in owner cluster.
+ ********************************************************************************************/
+void process_txt_transfer_ownership( xptr_t owner_xp );
+/*********************************************************************************************
+ * This function returns the TXT owner process (foreground process)
+ * for a given TXT terminal identified by its <channel> index.
+ *********************************************************************************************
+ * @ channel  : TXT terminal channel.
+ * @ return extentded pointer on TXT owner process in owner cluster.
+ * @ process_xp  : extended pointer on process descriptor in owner cluster.
+ ********************************************************************************************/
+void process_txt_transfer_ownership( xptr_t process_xp );
+/*********************************************************************************************
+ * This function returns true if the  process identified by the <process_xp> argument
+ * is the TXT owner. It can be called by a thread running in any cluster, but the
+ * process_xp must be the owner cluster process descriptor.
+ *********************************************************************************************
+ * @ return a non-zero value if target process is TXT owner.
+ ********************************************************************************************/
+uint32_t process_txt_is_owner( xptr_t process_xp );
+/*********************************************************************************************
+ * This function returns an extended ponter on the current TXT owner process,
+ * for the TXT terminal identified by the <channel> index.
+ *********************************************************************************************
+ * @ channel : TXT channel.
+ * @ return extended pointer on TXT owner process.
  ********************************************************************************************/
 xptr_t process_txt_get_owner( uint32_t channel );

trunk/kernel/kern/rpc.c

-                      r450
+                      r457
 #include <kernel_config.h>
 #include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <hal_atomic.h>
 #include <hal_remote.h>
 …
     volatile error_t   full;
     thread_t         * this;
-    cluster_t        * cluster;
-#if DEBUG_RPC_CLIENT_GENERIC
-uint32_t cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_RPC_CLIENT_GENERIC < cycle )
-printk("\n[DBG] %s : thread %x in cluster %x enter for rpc[%d] / rpc_ptr %x / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, local_cxy, rpc->index, rpc, cycle );
-#endif
     full            = 0;
     this            = CURRENT_THREAD;
-    cluster         = LOCAL_CLUSTER;
     client_core_lid = this->core->lid;
+#if DEBUG_RPC_CLIENT_GENERIC
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_RPC_CLIENT_GENERIC < cycle )
+printk("\n[DBG] %s : thread %x in process %x enter for rpc[%d] / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, rpc->index, cycle );
+#endif
     // select a server_core : use client core index if possible / core 0 otherwise
     if( client_core_lid < hal_remote_lw( XPTR( server_cxy , &cluster->cores_nr ) ) )
+    if( client_core_lid < hal_remote_lw( XPTR( server_cxy , &LOCAL_CLUSTER->cores_nr ) ) )
+    {
         server_core_lid = client_core_lid;
 …
     hal_fence();
+#if DEBUG_RPC_CLIENT_GENERIC
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_RPC_CLIENT_GENERIC < cycle )
+printk("\n[DBG] %s : thread %x in process %x / rpc[%d] / rpc_ptr %x / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, rpc->index, rpc, cycle );
+#endif
     // send IPI to the selected server core
         dev_pic_send_ipi( server_cxy , server_core_lid );
+   // send IPI to the selected server core
+   dev_pic_send_ipi( server_cxy , server_core_lid );
     // wait RPC completion before returning if blocking RPC
 …
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_CLIENT_GENERIC < cycle )
 printk("\n[DBG] %s : thread %x in cluster %x busy waiting / rpc[%d] / cycle %d\n",
 __FUNCTION__, CURRENT_THREAD, local_cxy, rpc->index , cycle );
+printk("\n[DBG] %s : thread %x in process %x busy waiting for rpc[%d] / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, rpc->index , cycle );
 #endif
 …
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_CLIENT_GENERIC < cycle )
 printk("\n[DBG] %s : thread %x in cluster %x resumes / rpc[%d] / cycle %d\n",
 __FUNCTION__, CURRENT_THREAD, local_cxy, rpc->index, cycle );
+printk("\n[DBG] %s : thread %x in process %x resumes for rpc[%d] / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, rpc->index, cycle );
 #endif
+        }
 …
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_CLIENT_GENERIC < cycle )
 printk("\n[DBG] %s : thread %x in cluster %x blocks & deschedules / rpc[%d] / cycle %d\n",
 __FUNCTION__, CURRENT_THREAD, local_cxy, rpc->index , cycle );
+printk("\n[DBG] %s : thread %x in process %x blocks & deschedules for rpc[%d] / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, rpc->index , cycle );
 #endif
             thread_block( XPTR( local_cxy , this ) , THREAD_BLOCKED_RPC );
 …
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_CLIENT_GENERIC < cycle )
 printk("\n[DBG] %s : thread %x in cluster %x resumes / rpcr[%d] / cycle %d\n",
 __FUNCTION__, CURRENT_THREAD, local_cxy, rpc->index, cycle );
+printk("\n[DBG] %s : thread %x in process %x resumes for rpc[%d] / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, rpc->index, cycle );
 #endif
+        }
 …
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_CLIENT_GENERIC < cycle )
 printk("\n[DBG] %s : non blocking rpc[%d] => thread %x return  / cycle %d\n",
 __FUNCTION__, rpc->index, CURRENT_THREAD, cycle );
+printk("\n[DBG] %s : thread %x in process %x returns for non blocking rpc[%d] / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, rpc->index, cycle );
 #endif
 …
     thread_t      * thread;
     uint32_t        sr_save;
+#if DEBUG_RPC_SERVER_GENERIC
+uint32_t cycle;
+#endif
     bool_t          found    = false;
 …
         remote_fifo_t * rpc_fifo = &LOCAL_CLUSTER->rpc_fifo[core->lid];
-#if DEBUG_RPC_SERVER_GENERIC
-uint32_t cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_RPC_SERVER_GENERIC < cycle )
-printk("\n[DBG] %s : thread %x interrupted in cluster %x / cycle %d\n",
-__FUNCTION__, this, local_cxy, cycle );
-#endif
     // interrupted thread not preemptable during RPC chek
         hal_disable_irq( &sr_save );
 …
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_SERVER_GENERIC < cycle )
 printk("\n[DBG] %s : RPC FIFO non empty in cluster %x / cycle %d\n",
 __FUNCTION__, local_cxy, cycle );
+printk("\n[DBG] %s : RPC FIFO non empty for core[%x,%d] / cycle %d\n",
+__FUNCTION__, local_cxy, core->lid, cycle );
 #endif
 …
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_SERVER_GENERIC < cycle )
 printk("\n[DBG] %s : create a new RPC thread %x in cluster %x / cycle %d\n",
 __FUNCTION__, thread, local_cxy, cycle );
+printk("\n[DBG] %s : new RPC thread %x created for core[%x,%d] / cycle %d\n",
+__FUNCTION__, thread, local_cxy, core->lid, cycle );
 #endif
+        }
 …
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_SERVER_GENERIC < cycle )
 printk("\n[DBG] %s : interrupted thread %x deschedules in cluster %x / cycle %d\n",
 __FUNCTION__, this, local_cxy, cycle );
+printk("\n[DBG] %s : interrupted thread %x deschedules on core[%x,%d] / cycle %d\n",
+__FUNCTION__, this, local_cxy, core->lid, cycle );
 #endif
 …
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_SERVER_GENERIC < cycle )
 printk("\n[DBG] %s : interrupted thread %x resumes in cluster %x / cycle %d\n",
 __FUNCTION__, this, local_cxy, cycle );
+printk("\n[DBG] %s : interrupted thread %x resumes on core[%x,%d] / cycle %d\n",
+__FUNCTION__, this, local_cxy, core->lid, cycle );
 #endif
 …
 #endif
                         // send IPI to client core
                             dev_pic_send_ipi( desc_cxy , client_core_lid );
+                            // dev_pic_send_ipi( desc_cxy , client_core_lid );
+                    }
+                        }
 …
 pid_t     pid    = rpc->args[1];
 if( DEBUG_RPC_PROCESS_SIGACTION < cycle )
 printk("\n[DBG] %s : enter to %s process %x in cluster %x / cycle %d\n",
+printk("\n[DBG] %s : enter to request %s of process %x in cluster %x / cycle %d\n",
 __FUNCTION__ , process_action_str( action ) , pid , cxy , cycle );
 #endif
 …
         // send an IPI to client core
         dev_pic_send_ipi( client_cxy , client_lid );
+        // dev_pic_send_ipi( client_cxy , client_lid );
+    }

trunk/kernel/kern/rpc.h

r450	r457
26	26
27	27	#include <kernel_config.h>
28		#include <hal_types.h>
	28	#include <hal_kernel_types.h>
29	29	#include <hal_atomic.h>
30	30	#include <bits.h>

trunk/kernel/kern/scheduler.c

r450	r457
23	23
24	24	#include <kernel_config.h>
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <hal_switch.h>
27	27	#include <hal_irqmask.h>

trunk/kernel/kern/scheduler.h

r450	r457
25	25	#define _SCHEDULER_H_
26	26
27		#include <hal_types.h>
	27	#include <hal_kernel_types.h>
28	28	#include <list.h>
29	29	#include <spinlock.h>

trunk/kernel/kern/signal.c

r409	r457
24	24	*/
25	25
26		#include <hal_types.h>
	26	#include <hal_kernel_types.h>
27	27	#include <printk.h>
28	28	#include <signal.h>

trunk/kernel/kern/signal.h

r435	r457
27	27	#define _SIGNAL_H_
28	28
29		#include <hal_types.h>
	29	#include <hal_kernel_types.h>
30	30
31	31

trunk/kernel/kern/thread.c

-                      r450
+                      r457
 #include <kernel_config.h>
 #include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <hal_context.h>
 #include <hal_irqmask.h>
 …
     thread->quantum         = 0;            // TODO
     thread->ticks_nr        = 0;            // TODO
     thread->time_last_check = 0;
+    thread->time_last_check = 0;            // TODO
         thread->core            = &local_cluster->core_tbl[core_lid];
         thread->process         = process;
 …
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_THREAD_USER_CREATE < cycle )
 printk("\n[DBG] %s : thread %x enter for process %x in cluster %x / cycle %d\n",
 __FUNCTION__, CURRENT_THREAD, pid , local_cxy , cycle );
+printk("\n[DBG] %s : thread %x in process %x enter in cluster %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, pid , local_cxy , cycle );
 #endif
 …
+    }
+#if( DEBUG_THREAD_USER_CREATE & 1)
+if( DEBUG_THREAD_USER_CREATE < cycle )
+printk("\n[DBG] %s : stack vseg created / vpn_base %x / %d pages\n",
+__FUNCTION__, vseg->vpn_base, vseg->vpn_size );
+#endif
     // allocate memory for thread descriptor
     thread = thread_alloc();
 …
 #if( DEBUG_THREAD_USER_CREATE & 1)
 if( DEBUG_THREAD_USER_CREATE < cycle )
 printk("\n[DBG] %s : thread descriptor %x allocated\n",
+printk("\n[DBG] %s : new thread descriptor %x allocated\n",
 __FUNCTION__, thread );
 #endif
 …
 #if( DEBUG_THREAD_USER_CREATE & 1)
 if( DEBUG_THREAD_USER_CREATE < cycle )
 printk("\n[DBG] %s : thread descriptor %x initialised / trdid = %x\n",
 __FUNCTION__, thread , thread->trdid );
+printk("\n[DBG] %s : new thread descriptor initialised / trdid %x\n",
+__FUNCTION__, thread->trdid );
 #endif
 …
     // allocate & initialize CPU context
         if( hal_cpu_context_create( thread ) )
+        if( hal_cpu_context_alloc( thread ) )
+    {
             printk("\n[ERROR] in %s : cannot create CPU context\n", __FUNCTION__ );
 …
         return ENOMEM;
+    }
+    // allocate  FPU context
+    hal_cpu_context_init( thread );
+    // allocate & initialize FPU context
     if( hal_fpu_context_alloc( thread ) )
+    {
 …
         return ENOMEM;
+    }
+    hal_fpu_context_init( thread );
+#if( DEBUG_THREAD_USER_CREATE & 1)
+if( DEBUG_THREAD_USER_CREATE < cycle )
+printk("\n[DBG] %s : CPU & FPU contexts created\n",
+__FUNCTION__, thread->trdid );
+vmm_display( process , true );
+#endif
 #if DEBUG_THREAD_USER_CREATE
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_THREAD_USER_CREATE < cycle )
 printk("\n[DBG] %s : thread %x exit / new_thread %x in process %x / core %d / cycle %d\n",
 __FUNCTION__, CURRENT_THREAD, thread->trdid , pid , core_lid, cycle );
+printk("\n[DBG] %s : thread %x in process %x exit / new_thread %x / core %d / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid , pid, thread->trdid, core_lid, cycle );
 #endif
 …
 }  // end thread_user_fork()
+////////////////////////////////////////////////
+error_t thread_user_exec( void     * entry_func,
+                          uint32_t   argc,
+                          char    ** argv )
+{
+    thread_t  * thread  = CURRENT_THREAD;
+    process_t * process = thread->process;
+#if DEBUG_THREAD_USER_EXEC
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_THREAD_USER_EXEC < cycle )
+printk("\n[DBG] %s : thread %x in process %x enter / cycle %d\n",
+__FUNCTION__, thread->trdid, process->pid, cycle );
+#endif
+        assert( (thread->type == THREAD_USER )          , __FUNCTION__, "bad type" );
+        assert( (thread->signature == THREAD_SIGNATURE) , __FUNCTION__, "bad signature" );
+        assert( (thread->local_locks == 0)              , __FUNCTION__, "bad local locks" );
+        assert( (thread->remote_locks == 0)             , __FUNCTION__, "bad remote locks" );
+        // re-initialize various thread descriptor fields
+    thread->quantum         = 0;            // TODO
+    thread->ticks_nr        = 0;            // TODO
+    thread->time_last_check = 0;            // TODO
+#if CONFIG_LOCKS_DEBUG
+    list_root_init( &thread->locks_root );
+    xlist_root_init( XPTR( local_cxy , &thread->xlocks_root ) );
+#endif
+    thread->entry_func      = entry_func;
+    thread->main_argc       = argc;
+    thread->main_argv       = argv;
+    // the main thread is always detached
+    thread->flags           = THREAD_FLAG_DETACHED;
+    thread->blocked         = 0;
+    thread->errno           = 0;
+    thread->fork_user       = 0;    // not inherited
+    thread->fork_cxy        = 0;    // not inherited
+    // reset thread info
+    memset( &thread->info , 0 , sizeof(thread_info_t) );
+    // initialize join_lock
+    remote_spinlock_init( XPTR( local_cxy , &thread->join_lock ) );
+    // allocate an user stack vseg for main thread
+    vseg_t * vseg = vmm_create_vseg( process,
+                                     VSEG_TYPE_STACK,
+,                 // size unused
+,                 // length unused
+,                 // file_offset unused
+,                 // file_size unused
+                                     XPTR_NULL,         // mapper_xp unused
+                                     local_cxy );
+    if( vseg == NULL )
+    {
+            printk("\n[ERROR] in %s : cannot create stack vseg for main thread\n", __FUNCTION__ );
+                return -1;
+    }
+    // update user stack in stack descriptor
+    thread->u_stack_base = vseg->min;
+    thread->u_stack_size = vseg->max - vseg->min;
+    // release FPU ownership if required
+    if( thread->core->fpu_owner == thread ) thread->core->fpu_owner = NULL;
+    // re-initialize  FPU context
+    hal_fpu_context_init( thread );
+#if DEBUG_THREAD_USER_EXEC
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_THREAD_USER_EXEC < cycle )
+printk("\n[DBG] %s : thread %x in process %x set CPU context & jump to user code / cycle %d\n",
+__FUNCTION__, thread->trdid, process->pid, cycle );
+vmm_display( process , true );
+#endif
+    // re-initialize CPU context... and jump to user code
+        hal_cpu_context_exec( thread );
+    assert( false, __FUNCTION__, "we should execute this code");
+    return 0;
+}  // end thread_user_exec()
 /////////////////////////////////////////////////////////
 error_t thread_kernel_create( thread_t     ** new_thread,
 …
+    {
         thread_release( thread );
+        return ENOMEM;
+    }
+    // allocate & initialize CPU context
+        error = hal_cpu_context_alloc( thread );
+    if( error )
+    {
+        thread_release( thread );
         return EINVAL;
+    }
+    // allocate & initialize CPU context
+        hal_cpu_context_create( thread );
+    hal_cpu_context_init( thread );
 #if DEBUG_THREAD_KERNEL_CREATE
 …
 } // end thread_kernel_create()
 /////////////////////////////////////////////////
 error_t thread_idle_init( thread_t      * thread,
                           thread_type_t   type,
                           void          * func,
                           void          * args,
                                           lid_t           core_lid )
+//////////////////////////////////////////////
+void thread_idle_init( thread_t      * thread,
+                       thread_type_t   type,
+                       void          * func,
+                       void          * args,
+                           lid_t           core_lid )
+{
     assert( (type == THREAD_IDLE) , __FUNCTION__ , "illegal thread type" );
     assert( (core_lid < LOCAL_CLUSTER->cores_nr) , __FUNCTION__ , "illegal core index" );
+    // initialize thread descriptor
     error_t  error = thread_init( thread,
                                   &process_zero,
 …
 , 0 );   // no user stack for a kernel thread
+    assert( (error == 0), __FUNCTION__, "cannot create thread idle" );
     // allocate & initialize CPU context if success
+    if( error == 0 ) hal_cpu_context_create( thread );
+    return error;
+    error = hal_cpu_context_alloc( thread );
+    assert( (error == 0), __FUNCTION__, "cannot allocate CPU context" );
+    hal_cpu_context_init( thread );
 }  // end thread_idle_init()
 …
 #if DEBUG_THREAD_BLOCK
+uint32_t cycle = (uint32_t)hal_get_cycles();
+uint32_t    cycle   = (uint32_t)hal_get_cycles();
+process_t * process = hal_remote_lpt( XPTR( cxy , &ptr->process ) );
 if( DEBUG_THREAD_BLOCK < cycle )
+printk("\n[DBG] %s : thread %x  in cxy %x blocked thread %x in cxy %x / cause %x / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , local_cxy , ptr , cxy , cause , cycle );
+printk("\n[DBG] %s : thread %x in process %x blocked thread %x in process %x / cause %x\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid,
+ptr->trdid, hal_remote_lw(XPTR( cxy , &process->pid )), cause );
 #endif
 …
 #if DEBUG_THREAD_BLOCK
+uint32_t cycle = (uint32_t)hal_get_cycles();
+uint32_t    cycle   = (uint32_t)hal_get_cycles();
+process_t * process = hal_remote_lpt( XPTR( cxy , &ptr->process ) );
 if( DEBUG_THREAD_BLOCK < cycle )
+printk("\n[DBG] %s : thread %x  in cxy %x unblocked thread %x in cxy %x / cause %x / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , local_cxy , ptr , cxy , cause , cycle );
+printk("\n[DBG] %s : thread %x in process %x unblocked thread %x in process %x / cause %x\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid,
+ptr->trdid, hal_remote_lw(XPTR( cxy , &process->pid )), cause );
 #endif

trunk/kernel/kern/thread.h

-                      r446
+                      r457
 #define _THREAD_H_
 #include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <shared_syscalls.h>
 #include <hal_special.h>
 …
     void              * entry_func;      /*! pointer on entry function                */
     void              * entry_args;      /*! pointer on entry function arguments      */
+    uint32_t            main_argc;       /*! main thread number of arguments          */
+    char             ** main_argv;       /*! main thread array of strings arguments   */
     uint32_t            flags;           /*! bit vector of flags                      */
 …
  * The CPU context is initialized from scratch.
  * It is registered in the local process descriptor specified by the <pid> argument.
+ * The THREAD_BLOCKED_GLOBAL bit is set => the thread must be activated to start.
+ * The THREAD_BLOCKED_GLOBAL bit is set => the thread must be activated by the caller
+ * to start at the next scheduling point.
  ***************************************************************************************
  * @ pid          : process identifier.
 …
 /***************************************************************************************
+ * This function is called by the process_make_exec() function to re-initialise the
+ * thread descriptor of the calling thread (that will become the new process main
+ * thread), and immediately jump to user code without returning to kentry!!!
+ * It must be called by the main thread of the calling process.
+ * - A new user stack vseg is created and initialised.
+ * - The kernel stack (currently in use) is not modified.
+ * - The function calls the hal_cpu_context_exec() to re-initialize the CPU context
+ *   an jump to user code.
+ ***************************************************************************************
+ * @ entry_func : main thread entry point.
+ * @ argc       : number of main thread arguments.
+ * @ argv       : array of pointers on stringarguments.
+ * @ returns 0 if success / returns ENOMEM if error.
+ **************************************************************************************/
+error_t thread_user_exec( void     * entry_func,
+                          uint32_t   argc,
+                          char    ** argv);
+/***************************************************************************************
  * This function allocates memory for a kernel thread descriptor in the local cluster,
  * and initializes it from arguments values.
 …
  * descriptor from arguments values.
  * The THREAD_BLOCKED_GLOBAL bit is set, and the thread must be activated to start.
+ * It returns a kernel panic if failure.
  ***************************************************************************************
  * @ thread   : pointer on existing thread descriptor.
 …
  * @ args     : function arguments.
  * @ core_lid : local core index.
+ * @ returns 0 if success / returns EINVAL if error
+ **************************************************************************************/
+error_t thread_idle_init( thread_t      * thread,
+                          thread_type_t   type,
+                          void          * func,
+                          void          * args,
+                          lid_t           core_lid );
+ **************************************************************************************/
+void thread_idle_init( thread_t      * thread,
+                       thread_type_t   type,
+                       void          * func,
+                       void          * args,
+                       lid_t           core_lid );
 /***************************************************************************************

trunk/kernel/kernel_config.h

-                      r450
+                      r457
 #define _ALMOS_CONFIG_H_
 #define CONFIG_ALMOS_VERSION                "Version 1.0 / March 2018"
+#define CONFIG_ALMOS_VERSION           "Version 1.0 / August 2018"
 ////////////////////////////////////////////////////////////////////////////////////////////
 …
 #define DEBUG_HAL_IOC_RX               0
 #define DEBUG_HAL_IOC_TX               0
 #define DEBUG_HAL_GPT
+#define DEBUG_HAL_GPT                  0
 #define DEBUG_KCM                      0
 …
 #define DEBUG_SCHED_HANDLE_SIGNALS     2
 #define DEBUG_SCHED_YIELD              2    // must be activated by the trace() syscall
+#define DEBUG_SCHED_YIELD              1    // must be activated by the trace() syscall
 #define DEBUG_SYSCALLS_ERROR           2
 #define DEBUG_SYS_DISPLAY              0
 #define DEBUG_SYS_EXEC                 1
 #define DEBUG_SYS_EXIT                 1
+#define DEBUG_SYS_EXEC                 0
+#define DEBUG_SYS_EXIT                 0
 #define DEBUG_SYS_FG                   0
 #define DEBUG_SYS_FORK                 0
 #define DEBUG_SYS_GET_CONFIG           0
 #define DEBUG_SYS_ISATTY               0
+#define DEBUG_SYS_IS_FG                0
 #define DEBUG_SYS_KILL                 0
 #define DEBUG_SYS_MMAP                 0
 …
 #define DEBUG_THREAD_USER_CREATE       0
 #define DEBUG_THREAD_USER_FORK         0
+#define DEBUG_THREAD_USER_EXEC         0
 #define DEBUG_THREAD_BLOCK             0

trunk/kernel/libk/barrier.c

r16	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_remote.h>
26	26	#include <hal_atomic.h>

trunk/kernel/libk/barrier.h

r423	r457
26	26
27	27	#include <kernel_config.h>
28		#include <hal_types.h>
	28	#include <hal_kernel_types.h>
29	29
30	30	/*****************************************************************************************

trunk/kernel/libk/bits.c

r351	r457
23	23	*/
24	24
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <bits.h>
27	27

trunk/kernel/libk/bits.h

r454	r457
27	27
28	28	#include <kernel_config.h>
29		#include <hal_types.h>
	29	#include <hal_kernel_types.h>
30	30
31	31	/*********************************************************************************************

trunk/kernel/libk/ctype.c

r1	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25
26	26	////////////////////

trunk/kernel/libk/elf.c

-                      r441
+                      r457
 #include <kernel_config.h>
 #include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <hal_special.h>
 #include <hal_uspace.h>
 …
 } // end elf_segments_register()
 ///////////////////////////////////////////////
 error_t elf_load_process( char      * pathname,
                           process_t * process)
+//////////////////////////////////////////////
+error_t elf_load_process( xptr_t      file_xp,
+                          process_t * process )
+{
         kmem_req_t   req;              // kmem request for program header
 …
         void       * segs_base;        // pointer on buffer for segment descriptors array
         uint32_t     segs_size;        // size of buffer for segment descriptors array
+        xptr_t       file_xp;          // extended pointer on created file descriptor
+        uint32_t     file_id;          // file descriptor index (unused)
+    char         name[CONFIG_VFS_MAX_NAME_LENGTH];
         error_t      error;
+    // get file name for error reporting and debug
+    cxy_t         file_cxy = GET_CXY( file_xp );
+    vfs_file_t  * file_ptr = GET_PTR( file_xp );
+    vfs_inode_t * inode    = hal_remote_lpt( XPTR( file_cxy , &file_ptr->inode ) );
+    vfs_inode_get_name( XPTR( file_cxy , inode ) , name );
 #if DEBUG_ELF_LOAD
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_ELF_LOAD < cycle )
+printk("\n[DBG] %s : thread %d enter for <%s> / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, pathname, cycle );
+#endif
+    // avoid GCC warning
+        file_xp = XPTR_NULL;
+        file_id = -1;
+        // open file
+        error = vfs_open( process,
+                          pathname,
+                          O_RDONLY,
+,
+                          &file_xp,
+                          &file_id );
+        if( error )
+        {
+                printk("\n[ERROR] in %s : failed to open file <%s>\n", __FUNCTION__ , pathname );
+                return -1;
+        }
+#if (DEBUG_ELF_LOAD & 1)
+if( DEBUG_ELF_LOAD < cycle )
+printk("\n[DBG] %s : open file <%s>\n", __FUNCTION__, pathname );
+uint32_t      cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_ELF_LOAD < cycle )
+printk("\n[DBG] %s : thread %d in process %x enter for <%s> / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, process->pid, name, cycle );
 #endif
 …
         if( error )
+        {
+                printk("\n[ERROR] in %s : cannot get header for <%s>\n", __FUNCTION__ , pathname );
+                vfs_close( file_xp , file_id );
+                printk("\n[ERROR] in %s : cannot get header for <%s>\n", __FUNCTION__ , name );
                 return -1;
+        }
 …
 #if (DEBUG_ELF_LOAD & 1)
 if( DEBUG_ELF_LOAD < cycle )
 printk("\n[DBG] %s : loaded elf header for <%s>\n", __FUNCTION__ , pathname );
+printk("\n[DBG] %s : loaded elf header for <%s>\n", __FUNCTION__ , name );
 #endif
 …
+        {
                 printk("\n[ERROR] in %s : no segments found\n", __FUNCTION__ );
-                vfs_close( file_xp , file_id );
                 return -1;
+        }
 …
+        {
                 printk("\n[ERROR] in %s : no memory for segment descriptors\n", __FUNCTION__ );
-                vfs_close( file_xp , file_id );
                 return -1;
+        }
 …
+        {
                 printk("\n[ERROR] in %s : cannot seek for descriptors array\n", __FUNCTION__ );
-                vfs_close( file_xp , file_id );
                 req.ptr = segs_base;
                 kmem_free( &req );
 …
 #if (DEBUG_ELF_LOAD & 1)
 if( DEBUG_ELF_LOAD < cycle )
 printk("\n[DBG] %s : segments array allocated for <%s>\n", __FUNCTION__ , pathname );
+printk("\n[DBG] %s : segments array allocated for <%s>\n", __FUNCTION__ , name );
 #endif
 …
+        {
                 printk("\n[ERROR] in %s : cannot read segments descriptors\n", __FUNCTION__ );
-                vfs_close( file_xp , file_id );
                 req.ptr = segs_base;
                 kmem_free( &req );
 …
 #if (DEBUG_ELF_LOAD & 1)
 if( DEBUG_ELF_LOAD < cycle )
 printk("\n[DBG] %s loaded segments descriptors for <%s>\n", __FUNCTION__ , pathname );
+printk("\n[DBG] %s loaded segments descriptors for <%s>\n", __FUNCTION__ , name );
 #endif
 …
         if( error )
+        {
-                vfs_close( file_xp , file_id );
                 req.ptr = segs_base;
                 kmem_free( &req );
 …
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_ELF_LOAD < cycle )
 printk("\n[DBG] %s : thread %d exit for <%s> / entry_point %x / cycle %d\n",
 __FUNCTION__, CURRENT_THREAD, pathname, header.e_entry, cycle );
+printk("\n[DBG] %s : thread %x in process %x exit for <%s> / entry_point %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, process->pid, name, header.e_entry, cycle );
 #endif

trunk/kernel/libk/elf.h

-                      r273
+                      r457
 #define _ELF_H_ 1
 #include <hal_types.h>
+#include <hal_kernel_types.h>
 /*
 …
 #define PF_MASKPROC     0xf0000000      /* Processor-specific */
 #if defined(HAL_32BIT)
+#if defined(HAL_ELF_32_BITS)
 #define Elf_Half  Elf32_Half
 #define Elf_Word  Elf32_Word
 …
 #define Elf_Phdr  Elf32_Phdr
 #define ELFCLASS  ELFCLASS32
 #elif defined (HAL_64BIT)
+#elif defined (HAL_ELF_64_BITS)
 #define Elf_Half  Elf64_Half
 #define Elf_Word  Elf64_Word
 …
 #define ELFCLASS  ELFCLASS64
 #else
 #error "Must define HAL_64BIT/HAL_32BIT"
+#error "Must define HAL_ELF_64_BITS / HAL_ELF_32_BITS"
 #endif
 /****************************************************************************************
+ * This function registers in VMM the CODE and DATA vsegs defined in the .elf file.
+ * This function registers in VMM of the process identified by the <process> argument
+ * the CODE and DATA vsegs defined in the .elf open file descriptor <file_xp>.
  * The segments are not loaded in memory.
  * It also registers the process entry point in VMM.
  ****************************************************************************************
  * @ pathname : local pointer on .elf file pathname (in kernel space).
+ * @ file_xp  : extended pointer on .elf file descriptor.
  * @ process  : local pointer on target process descriptor.
  ***************************************************************************************/
 error_t elf_load_process( char      * pathname,
+error_t elf_load_process( xptr_t      file_xp,
                           process_t * process);

trunk/kernel/libk/grdxt.c

r423	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_special.h>
26	26	#include <errno.h>

trunk/kernel/libk/grdxt.h

r406	r457
25	25	#define _GRDXT_H_
26	26
27		#include <hal_types.h>
	27	#include <hal_kernel_types.h>
28	28
29	29	/*******************************************************************************************

trunk/kernel/libk/htab.c

r423	r457
23	23
24	24	#include <kernel_config.h>
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <hal_special.h>
27	27	#include <htab.h>

trunk/kernel/libk/htab.h

r23	r457
26	26	#define _HTAB_H_
27	27
28		#include <hal_types.h>
	28	#include <hal_kernel_types.h>
29	29	#include <rwlock.h>
30	30	#include <list.h>

trunk/kernel/libk/list.h

r450	r457
27	27
28	28	#include <kernel_config.h>
29		#include <hal_types.h>
	29	#include <hal_kernel_types.h>
30	30
31	31	#ifndef NULL

trunk/kernel/libk/memcpy.c

r113	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <printk.h>
26	26

trunk/kernel/libk/memcpy.h

r113	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25
26	26

trunk/kernel/libk/readlock.c

r124	r457
23	23
24	24	#include <kernel_config.h>
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <hal_atomic.h>
27	27	#include <hal_special.h>

trunk/kernel/libk/readlock.h

r14	r457
26	26
27	27	#include <kernel_config.h>
28		#include <hal_types.h>
	28	#include <hal_kernel_types.h>
29	29
30	30	/*******************************************************************************************

trunk/kernel/libk/remote_barrier.c

r436	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_remote.h>
26	26	#include <hal_irqmask.h>

trunk/kernel/libk/remote_barrier.h

r23	r457
26	26
27	27	#include <kernel_config.h>
28		#include <hal_types.h>
	28	#include <hal_kernel_types.h>
29	29	#include <remote_spinlock.h>
30	30	#include <xlist.h>

trunk/kernel/libk/remote_condvar.c

r436	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_remote.h>
26	26	#include <hal_irqmask.h>

trunk/kernel/libk/remote_condvar.h

r23	r457
26	26
27	27	#include <kernel_config.h>
28		#include <hal_types.h>
	28	#include <hal_kernel_types.h>
29	29	#include <remote_spinlock.h>
30	30	#include <xlist.h>

trunk/kernel/libk/remote_fifo.c

r408	r457
23	23	*/
24	24
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <hal_irqmask.h>
27	27	#include <hal_remote.h>

trunk/kernel/libk/remote_fifo.h

r407	r457
27	27
28	28	#include <kernel_config.h>
29		#include <hal_types.h>
	29	#include <hal_kernel_types.h>
30	30	#include <printk.h>
31	31	#include <errno.h>

trunk/kernel/libk/remote_mutex.c

r436	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_remote.h>
26	26	#include <hal_special.h>

trunk/kernel/libk/remote_mutex.h

r23	r457
26	26
27	27	#include <kernel_config.h>
28		#include <hal_types.h>
	28	#include <hal_kernel_types.h>
29	29	#include <xlist.h>
30	30

trunk/kernel/libk/remote_rwlock.c

r438	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_remote.h>
26	26	#include <hal_irqmask.h>

trunk/kernel/libk/remote_rwlock.h

r438	r457
26	26
27	27	#include <kernel_config.h>
28		#include <hal_types.h>
	28	#include <hal_kernel_types.h>
29	29	#include <xlist.h>
30	30

trunk/kernel/libk/remote_sem.c

-                      r436
+                      r457
  */
 #include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <hal_remote.h>
 #include <thread.h>
 …
 ///////////////////////////////////////////
+error_t remote_sem_create( intptr_t  vaddr,
+                           uint32_t  value )
+{
+error_t remote_sem_create( intptr_t   vaddr,
+                           uint32_t   value,
+                           xptr_t     sem_xp_xp )
+{
+    remote_sem_t * sem_ptr;
     xptr_t         sem_xp;
-    remote_sem_t * sem_ptr;
     // get pointer on local process descriptor
 …
+    {
         rpc_kcm_alloc_client( ref_cxy , KMEM_SEM , &sem_xp );
         sem_ptr = (remote_sem_t *)GET_PTR( sem_xp );
+    }
     if( sem_xp == XPTR_NULL ) return ENOMEM;
+        sem_ptr = GET_PTR( sem_xp );
+    }
+    if( sem_xp == XPTR_NULL ) return -1;
     // initialise semaphore
     hal_remote_sw ( XPTR( ref_cxy , &sem_ptr->count ) , value );
         hal_remote_spt( XPTR( ref_cxy , &sem_ptr->ident ) , (void *)vaddr );
     remote_spinlock_init( XPTR( ref_cxy , &sem_ptr->lock ) );
         xlist_root_init( XPTR( ref_cxy , &sem_ptr->root ) );
 …
     xptr_t root_xp = XPTR( ref_cxy , &ref_ptr->sem_root );
     xptr_t xp_list = XPTR( ref_cxy , &sem_ptr->list );
     remote_spinlock_lock( XPTR( ref_cxy , &ref_ptr->sync_lock ) );
     xlist_add_first( root_xp , xp_list );
     remote_spinlock_unlock( XPTR( ref_cxy , &ref_ptr->sync_lock ) );
+    // write extended pointer on semaphore in calling thread buffer
+    hal_remote_swd( sem_xp_xp , sem_xp );
     return 0;
 }  // en remote_sem_init()
+}  // en remote_sem_create()
 ////////////////////////////////////////
 …
     // get reference process cluster and local pointer
     cxy_t       ref_cxy = GET_CXY( ref_xp );
     process_t * ref_ptr = (process_t *)GET_PTR( ref_xp );
+    process_t * ref_ptr = GET_PTR( ref_xp );
     // get semaphore cluster and local pointer
 …
     remote_spinlock_lock( XPTR( sem_cxy , &sem_ptr->lock ) );
     // get remote pointer on waiting queue
     xptr_t root_xp = (xptr_t)hal_remote_lwd( XPTR( sem_cxy , &sem_ptr->root ) );
+    // get remote pointer on waiting queue root
+    xptr_t root_xp = XPTR( sem_cxy , &sem_ptr->root );
     if( !xlist_is_empty( root_xp ) )   // user error
 …
 }  // end remote_sem_destroy()
 //////////////////////////////////
+/////////////////////////////////////
 void remote_sem_wait( xptr_t sem_xp )
+{
     // get semaphore cluster and local pointer
     cxy_t          sem_cxy = GET_CXY( sem_xp );
     remote_sem_t * sem_ptr = (remote_sem_t *)GET_PTR( sem_xp );
+    remote_sem_t * sem_ptr = GET_PTR( sem_xp );
     // get lock protecting semaphore
 …
         // register thread in waiting queue
         xptr_t root_xp   = (xptr_t)hal_remote_lwd( XPTR( sem_cxy , &sem_ptr->root ) );
         xptr_t thread_xp = XPTR( local_cxy , this );
                 xlist_add_last( root_xp , thread_xp );
+        xptr_t root_xp = XPTR( sem_cxy   , &sem_ptr->root );
+        xptr_t list_xp = XPTR( local_cxy , &this->wait_list );
+                xlist_add_last( root_xp , list_xp );
         // release lock
 …
     // get semaphore cluster and local pointer
     cxy_t          sem_cxy = GET_CXY( sem_xp );
     remote_sem_t * sem_ptr = (remote_sem_t *)GET_PTR( sem_xp );
+    remote_sem_t * sem_ptr = GET_PTR( sem_xp );
     // get lock protecting semaphore
         remote_spinlock_lock( XPTR( sem_cxy , &sem_ptr->lock ) );
+    // get semaphore current value
+    uint32_t count = hal_remote_lw( XPTR( sem_cxy , &sem_ptr->count ) );
     // get remote pointer on waiting queue root
     xptr_t root_xp = (xptr_t)hal_remote_lwd( XPTR( sem_cxy , &sem_ptr->root ) );
+    xptr_t root_xp = XPTR( sem_cxy , &sem_ptr->root );
         if( xlist_is_empty( root_xp ) )   // no waiting thread
+    {
-        // get semaphore current value
-        uint32_t count = hal_remote_lw( XPTR( sem_cxy , &sem_ptr->count ) );
         // increment semaphore value
         hal_remote_sw( XPTR( sem_cxy , &sem_ptr->count ) , count + 1 );
 …
         // get thread cluster and local poiner
         cxy_t      thread_cxy = GET_CXY( thread_xp );
         thread_t * thread_ptr = (thread_t *)GET_PTR( thread_xp );
         // remove the thread from the waiting queue, and unblock
+        thread_t * thread_ptr = GET_PTR( thread_xp );
+        // remove this thread from the waiting queue, and unblock it
         xlist_unlink( XPTR( thread_cxy , &thread_ptr->wait_list ) );
                 thread_unblock( thread_xp , THREAD_BLOCKED_SEM );
 …
     // get semaphore cluster and local pointer
     cxy_t          sem_cxy = GET_CXY( sem_xp );
     remote_sem_t * sem_ptr = (remote_sem_t *)GET_PTR( sem_xp );
+    remote_sem_t * sem_ptr = GET_PTR( sem_xp );
     *data = hal_remote_lw( XPTR( sem_cxy , &sem_ptr->count ) );

trunk/kernel/libk/remote_sem.h

-                      r23
+                      r457
 #define _SEMAPHORE_H_
 #include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <xlist.h>
 #include <remote_spinlock.h>
 …
  * This function implements the SEM_INIT operation.
  * It allocates memory for a remote semaphore in reference cluster, using a RPC if required,
+ * and initializes it, using remote accesses.
+ * and initializes it, using remote accesses from values defined by the <vaddr> and <value>
+ * arguments. It uses also a remote access to return the extended pointer on the semaphore
+ * in the buffer identified by the <buf_xp> argument.
  *********************************************************************************************
+ * @ vaddr    : semaphore virtual address, used as identifier.
+ * @ value    : semaphore initial value.
+ * @ returns 0 if success / returns ENOMEM if error.
+ * @ vaddr     : [in] semaphore virtual address, used as identifier.
+ * @ value     : [in] semaphore initial value.
+ * @ sem_xp_xp : [out] extended pointer on buffer to store extended pointer on semaphore.
+ * @ returns 0 if success / returns -1 if no memory.
  ********************************************************************************************/
 error_t remote_sem_create( intptr_t  vaddr,
+                           uint32_t  value );
+                           uint32_t  value,
+                           xptr_t    sem_xp_xp );
 /****************************yy***************************************************************
 …
  * reference cluster, using a RPC if required.
  *********************************************************************************************
  * @ sem_xp   : extended pointer on semaphore.
+ * @ sem_xp   : [in] extended pointer on semaphore.
  ********************************************************************************************/
 void remote_sem_destroy( xptr_t sem_xp );
 …
  *    waiting queue, block the thread, and yield.
  *********************************************************************************************
  * @ sem_xp   : extended pointer on semaphore.
+ * @ sem_xp   : [in] extended pointer on semaphore.
  ********************************************************************************************/
 void remote_sem_wait( xptr_t sem_xp );
 …
  * - If the waiting queue is not empty, it wakes up the first waiting thread.
  *********************************************************************************************
  * @ sem_xp   : extended pointer on semaphore.
+ * @ sem_xp   : [in] extended pointer on semaphore.
  ********************************************************************************************/
 void remote_sem_post( xptr_t sem_xp );
 …
  * It returns in the <data> buffer the semaphore current value.
  *********************************************************************************************
  * @ sem_xp   : extended pointer on semaphore.
  * @ data     : [out] returned value.
+ * @ sem_xp   : [in]  extended pointer on semaphore.
+ * @ data     : [out] local pointer on buffer for returned value.
  ********************************************************************************************/
 void remote_sem_get_value( xptr_t      sem_xp,

trunk/kernel/libk/remote_spinlock.c

r443	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_remote.h>
26	26	#include <hal_irqmask.h>

trunk/kernel/libk/remote_spinlock.h

r438	r457
26	26
27	27	#include <kernel_config.h>
28		#include <hal_types.h>
	28	#include <hal_kernel_types.h>
29	29	#include <xlist.h>
30	30

trunk/kernel/libk/rwlock.c

r438	r457
23	23
24	24	#include <kernel_config.h>
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <hal_atomic.h>
27	27	#include <hal_special.h>

trunk/kernel/libk/rwlock.h

r438	r457
26	26
27	27	#include <kernel_config.h>
28		#include <hal_types.h>
	28	#include <hal_kernel_types.h>
29	29	#include <list.h>
30	30

trunk/kernel/libk/spinlock.c

r438	r457
24	24
25	25	#include <kernel_config.h>
26		#include <hal_types.h>
	26	#include <hal_kernel_types.h>
27	27	#include <hal_atomic.h>
28	28	#include <hal_special.h>

trunk/kernel/libk/spinlock.h

r438	r457
26	26
27	27	#include <kernel_config.h>
28		#include <hal_types.h>
	28	#include <hal_kernel_types.h>
29	29	#include <list.h>
30	30

trunk/kernel/libk/string.c

r337	r457
23	23	*/
24	24
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <ctype.h>
27	27	#include <string.h>

trunk/kernel/libk/string.h

r323	r457
26	26	#define _STRING_H_
27	27
28		#include <hal_types.h>
	28	#include <hal_kernel_types.h>
29	29
30	30

trunk/kernel/libk/xhtab.c

r423	r457
23	23
24	24	#include <kernel_config.h>
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <hal_special.h>
27	27	#include <hal_remote.h>

trunk/kernel/libk/xhtab.h

r204	r457
26	26
27	27	#include <kernel_config.h>
28		#include <hal_types.h>
	28	#include <hal_kernel_types.h>
29	29	#include <remote_rwlock.h>
30	30	#include <xlist.h>

trunk/kernel/libk/xlist.h

r435	r457
26	26
27	27	#include <kernel_config.h>
28		#include <hal_types.h>
	28	#include <hal_kernel_types.h>
29	29	#include <hal_remote.h>
30	30

trunk/kernel/mm/kcm.c

r438	r457
24	24
25	25	#include <kernel_config.h>
26		#include <hal_types.h>
	26	#include <hal_kernel_types.h>
27	27	#include <hal_special.h>
28	28	#include <list.h>

trunk/kernel/mm/kcm.h

r437	r457
27	27
28	28	#include <list.h>
29		#include <hal_types.h>
	29	#include <hal_kernel_types.h>
30	30	#include <spinlock.h>
31	31	#include <page.h>

trunk/kernel/mm/khm.c

r315	r457
24	24
25	25	#include <kernel_config.h>
26		#include <hal_types.h>
	26	#include <hal_kernel_types.h>
27	27	#include <hal_special.h>
28	28	#include <spinlock.h>

trunk/kernel/mm/khm.h

r18	r457
28	28
29	29	#include <kernel_config.h>
30		#include <hal_types.h>
	30	#include <hal_kernel_types.h>
31	31	#include <spinlock.h>
32	32

trunk/kernel/mm/kmem.c

r438	r457
25	25
26	26	#include <kernel_config.h>
27		#include <hal_types.h>
	27	#include <hal_kernel_types.h>
28	28	#include <hal_special.h>
29	29	#include <printk.h>

trunk/kernel/mm/kmem.h

r188	r457
27	27	#define _KMEM_H_
28	28
29		#include <hal_types.h>
	29	#include <hal_kernel_types.h>
30	30	#include <kcm.h>
31	31

trunk/kernel/mm/mapper.c

r440	r457
24	24
25	25	#include <kernel_config.h>
26		#include <hal_types.h>
	26	#include <hal_kernel_types.h>
27	27	#include <hal_special.h>
28	28	#include <hal_uspace.h>

trunk/kernel/mm/mapper.h

r440	r457
26	26	#define _MAPPER_H_
27	27
28		#include <hal_types.h>
	28	#include <hal_kernel_types.h>
29	29	#include <hal_atomic.h>
30	30	#include <xlist.h>

trunk/kernel/mm/page.c

r436	r457
23	23	*/
24	24
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <hal_special.h>
27	27	#include <hal_atomic.h>

trunk/kernel/mm/page.h

r433	r457
27	27
28	28	#include <kernel_config.h>
29		#include <hal_types.h>
	29	#include <hal_kernel_types.h>
30	30	#include <spinlock.h>
31	31	#include <list.h>

trunk/kernel/mm/ppm.c

r438	r457
24	24
25	25	#include <kernel_config.h>
26		#include <hal_types.h>
	26	#include <hal_kernel_types.h>
27	27	#include <hal_special.h>
28	28	#include <printk.h>

trunk/kernel/mm/ppm.h

r433	r457
26	26	#define _PPM_H_
27	27
28		#include <hal_types.h>
	28	#include <hal_kernel_types.h>
29	29	#include <list.h>
30	30	#include <spinlock.h>

trunk/kernel/mm/vmm.c

-                      r443
+                      r457
 #include <kernel_config.h>
 #include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <hal_special.h>
 #include <hal_gpt.h>
 …
     vmm->stack_mgr.bitmap   = 0;
     vmm->stack_mgr.vpn_base = CONFIG_VMM_STACK_BASE;
+    spinlock_init( &vmm->stack_mgr.lock );
     // initialize MMAP allocator
 …
     vmm->mmap_mgr.vpn_size        = CONFIG_VMM_STACK_BASE - CONFIG_VMM_HEAP_BASE;
     vmm->mmap_mgr.first_free_vpn  = CONFIG_VMM_HEAP_BASE;
+    spinlock_init( &vmm->mmap_mgr.lock );
     uint32_t i;
     for( i = 0 ; i < 32 ; i++ ) list_root_init( &vmm->mmap_mgr.zombi_list[i] );
 …
     gpt_t * gpt = &vmm->gpt;
+    printk("\n***** VSL and GPT for process %x in cluster %x\n\n", process->pid , local_cxy );
+    printk("\n***** VSL and GPT(%x) for process %x in cluster %x\n\n",
+    process->vmm.gpt.ptr , process->pid , local_cxy );
     // get lock protecting the vseg list

trunk/kernel/mm/vmm.h

r440	r457
27	27	#define _VMM_H_
28	28
29		#include <hal_types.h>
	29	#include <hal_kernel_types.h>
30	30	#include <bits.h>
31	31	#include <list.h>

trunk/kernel/mm/vseg.c

-                      r453
+                      r457
  */
 #include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <hal_special.h>
 #include <hal_remote.h>
 …
     switch (vseg->type)
+    {
+        case VSEG_TYPE_DATA: {
+        case VSEG_TYPE_DATA:
+        {
             vseg->cxy = 0xffff;
             break;
+        }
         case VSEG_TYPE_CODE:
+        case VSEG_TYPE_STACK: {
+        case VSEG_TYPE_STACK:
+        {
             vseg->cxy = local_cxy;
             break;
 …
         case VSEG_TYPE_ANON:
         case VSEG_TYPE_FILE:
+        case VSEG_TYPE_REMOTE: {
+        case VSEG_TYPE_REMOTE:
+        {
             vseg->cxy = (cxy_t) hal_remote_lw( XPTR(cxy, &ptr->cxy) );
             break;
+        }
+        default: {
+        default:
+        {
             assert( false, __FUNCTION__, "Illegal vseg type" );
             break;

trunk/kernel/mm/vseg.h

r454	r457
27	27	#define _VSEG_H_
28	28
29		#include <hal_types.h>
	29	#include <hal_kernel_types.h>
30	30	#include <spinlock.h>
31	31	#include <vfs.h>

trunk/kernel/syscalls/shared_include/shared_pthread.h

-                      r445
+                      r457
  ******************************************************************************************/
-typedef unsigned int      sem_t;
 typedef unsigned int      pthread_cond_t;
 typedef unsigned int      pthread_condattr_t;
 …
     PT_ATTR_CORE_DEFINED    = 0x0004,  /*! user defined core index in cluster             */
 };
-/*******************************************************************************************
- * This enum defines the operation mnemonics for operations on POSIX unnamed semaphores.
- ******************************************************************************************/
-typedef enum
+{
-        SEM_INIT,
-        SEM_DESTROY,
-        SEM_GETVALUE,
-        SEM_WAIT,
-        SEM_POST,
+}
-sem_operation_t;
 /*******************************************************************************************

trunk/kernel/syscalls/shared_include/syscalls_numbers.h

r444	r457
62	62	SYS_TRACE = 47,
63	63	SYS_FG = 48,
64		SYS_~~UNDEFINED_49 = 49, ///~~
	64	SYS_IS_FG = 49,
65	65
66	66	SYSCALLS_NR = 50,

trunk/kernel/syscalls/sys_alarm.c

r23	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <thread.h>
26	26	#include <printk.h>

trunk/kernel/syscalls/sys_barrier.c

r440	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_special.h>
26	26	#include <errno.h>

trunk/kernel/syscalls/sys_chdir.c

r407	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_uspace.h>
26	26	#include <chdev.h>

trunk/kernel/syscalls/sys_chmod.c

r407	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_uspace.h>
26	26	#include <vfs.h>

trunk/kernel/syscalls/sys_close.c

r124	r457
23	23
24	24	#include <kernel_config.h>
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <hal_special.h>
27	27	#include <vfs.h>

trunk/kernel/syscalls/sys_closedir.c

r407	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <vfs.h>
26	26	#include <printk.h>

trunk/kernel/syscalls/sys_condvar.c

r440	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_special.h>
26	26	#include <errno.h>

trunk/kernel/syscalls/sys_creat.c

r407	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <vfs.h>
26	26	#include <syscalls.h>

trunk/kernel/syscalls/sys_display.c

r450	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_uspace.h>
26	26	#include <errno.h>

trunk/kernel/syscalls/sys_exec.c

-                      r441
+                      r457
 #include <kernel_config.h>
 #include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <hal_uspace.h>
 #include <errno.h>
 …
 // It build an exec_info_t structure containing all informations
 // required to initialize the new process descriptor and the associated thread.
 // It includes the process main() arguments, the environment variables,
+// It includes the new process main() arguments, the environment variables,
 // and the pathname to the new process .elf file.
 // It calls the process_exec_get_strings() functions to copy the main() arguments and
 // the environment variables from user buffers to the exec_info_t structure, allocate
 // and call the process_make_exec() function.
+// As it must destroy all parent process copies, and all parent threads in all clusters,
+// the process_make_exec() function must be executed in the parent owner cluster,
+// and this sys_exec() function uses a RPC to access the owner cluster if required.
+// As it must destroy all process copies, and all othert threads in all clusters,
+// the process_make_exec() function must be executed in the owner cluster.
 //
 // TODO : the args & envs arguments are not supported yet : both must be NULL  [AG]
 …
     "args not supported yet\n" );
-    // get owner cluster
     // check pathname length
     if( hal_strlen_from_uspace( pathname ) >= CONFIG_VFS_MAX_PATH_LENGTH )
 …
 #if DEBUG_SYS_EXEC
 uint64_t      tm_start;
-uint64_t      tm_end;
 tm_start = hal_get_cycles();
 if( DEBUG_SYS_EXEC < tm_start )
 printk("\n[DBG] %s : thread %x in process %x enter for path <%s> / cycle = %d\n",
 __FUNCTION__, this, pid, exec_info.path, (uint32_t)tm_start );
+__FUNCTION__, this->trdid, pid, exec_info.path, (uint32_t)tm_start );
 #endif
 …
 #if DEBUG_SYSCALLS_ERROR
 printk("\n[ERROR] in %s : thread %x in process %x cannot access args\n",
 __FUNCTION__ , this, pid );
+__FUNCTION__ , this->trdid, pid );
 #endif
             this->errno = EINVAL;
 …
 #if DEBUG_SYCALLS_ERROR
 printk("\n[ERROR] in %s : thread %x in process %x cannot access envs\n",
 __FUNCTION__ , this, pid );
+__FUNCTION__ , this->trdid, pid );
 #endif
             this->errno = EINVAL;
 …
 #if DEBUG_SYSCALLS_ERROR
 printk("\n[ERROR] in %s : thread %x in process %x cannot create process for <%s>\n",
 __FUNCTION__, this, pid, exec_info.path );
+__FUNCTION__, this->trdid, pid, exec_info.path );
 #endif
         this->errno = error;
 …
+    }
+#if DEBUG_SYS_EXEC
+tm_end = hal_get_cycles();
+if( DEBUG_SYS_EXEC < tm_end )
+printk("\n[DBG] %s : thread %x in process %x exit / cost = %d / cycle %d\n",
+__FUNCTION__, this, pid, (uint32_t)(tm_end - tm_start), (uint32_t)tm_end );
+#endif
+    // In case of success, this calling thread deschedules, causing suicide,
+    // because a new process descriptor and its associated main thread
+    // have been created by the process_make_exec() function, and the
+    // BLOCKED_GLOBAL & FLAG_REQ_DELETE bits have been set for the calling thread.
+    sched_yield( "old process suicide in sys_exec()" );
+    assert( false , __FUNCTION__, "we should not execute this code" );
     return 0;

trunk/kernel/syscalls/sys_exit.c

-                      r446
+                      r457
 #include <kernel_config.h>
 #include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <hal_irqmask.h>
 #include <errno.h>
 …
 tm_start = hal_get_cycles();
 if( DEBUG_SYS_EXIT < tm_start )
 printk("\n[DBG] %s : thread %x enter / process %x / status %x / cycle %d\n",
 __FUNCTION__ , this, pid , status , (uint32_t)tm_start );
+printk("\n[DBG] %s : thread %x in process %x enter / status %x / cycle %d\n",
+__FUNCTION__, this->trdid, process->pid , status , (uint32_t)tm_start );
 #endif
 …
 #if (DEBUG_SYS_EXIT & 1)
 if( DEBUG_SYS_EXIT < tm_start )
 printk("\n[DBG] %s : thread %x get owner process %x in cluster %x\n",
 __FUNCTION__ , this, owner_ptr, owner_cxy );
+printk("\n[DBG] %s : thread %x in process %x get owner process %x in cluster %x\n",
+__FUNCTION__, this->trdid, process->pid, owner_ptr, owner_cxy );
 #endif
     // get pointer on the process main thread
+    // get local pointer on the process main thread
     main_ptr  = hal_remote_lpt( XPTR( owner_cxy , &owner_ptr->th_tbl[0] ) );
 …
 #if (DEBUG_SYS_EXIT & 1)
 if( DEBUG_SYS_EXIT < tm_start )
 printk("\n[DBG] %s : thread %x get parent process %x in cluster %x\n",
 __FUNCTION__ , this, parent_ptr, parent_cxy );
+printk("\n[DBG] %s : thread %x in process %x get parent process %x in cluster %x\n",
+__FUNCTION__, this->trdid, process->pid, parent_ptr, parent_cxy );
 #endif
 …
 #if( DEBUG_SYS_EXIT & 1)
 if( tm_start > DEBUG_SYS_EXIT )
 printk("\n[DBG] %s : thread %x removed process %x from TXT list\n",
 __FUNCTION__ , this, pid );
+if( DEBUG_SYS_EXIT < tm_start )
+printk("\n[DBG] %s : thread %x in process %x detached process from TXT\n",
+__FUNCTION__, this->trdid, process->pid );
 #endif
 …
     // but the main thread and this calling thread
     hal_enable_irq( &save_sr );
     process_sigaction( pid , DELETE_ALL_THREADS );
+    process_sigaction( process->pid , DELETE_ALL_THREADS );
     hal_restore_irq( save_sr );
 #if( DEBUG_SYS_EXIT & 1)
 if( tm_start > DEBUG_SYS_EXIT )
 printk("\n[DBG] %s : thread %x deleted threads for process %x\n",
 __FUNCTION__ , this, pid );
+if( DEBUG_SYS_EXIT < tm_start )
+printk("\n[DBG] %s : thread %x in process %x deleted all threads but itself\n",
+__FUNCTION__, this->trdid, process->pid );
 #endif
 …
 #if( DEBUG_SYS_EXIT & 1)
 if( tm_start > DEBUG_SYS_EXIT )
 printk("\n[DBG] %s : calling thread %x marked iself for delete in process %x\n",
 __FUNCTION__ , this, pid );
+printk("\n[DBG] %s : thread %x in process %x marked iself for delete\n",
+__FUNCTION__, this->trdid, process->pid );
 #endif
         thread_delete( XPTR( local_cxy , this ) , pid , true );
 …
 #if( DEBUG_SYS_EXIT & 1)
 if( tm_start > DEBUG_SYS_EXIT )
 printk("\n[DBG] %s : thread %x blocked main thread for process %x\n",
 __FUNCTION__, this , pid );
+printk("\n[DBG] %s : thread %x in process %x blocked main thread\n",
+__FUNCTION__, this->trdid, process->pid );
 #endif
 …
 #if( DEBUG_SYS_EXIT & 1)
 if( tm_start > DEBUG_SYS_EXIT )
 printk("\n[DBG] %s : thread %x set exit status in process %x / term_state %x\n",
 __FUNCTION__ , this, pid, term_state );
+printk("\n[DBG] %s : thread %x in process %x set exit status %x in owner process\n",
+__FUNCTION__, this->trdid, process->pid, term_state );
 #endif
     // take the children lock and unblock the parent process main thread
+    // unblock the parent process main thread
     remote_spinlock_lock( children_lock_xp );
     thread_unblock( parent_main_xp , THREAD_BLOCKED_WAIT );
 …
 #if( DEBUG_SYS_EXIT & 1)
 if( tm_start > DEBUG_SYS_EXIT )
+printk("\n[DBG] %s : thread %x in cluster %x unblock parent main thread %x in cluster %x\n",
+__FUNCTION__ , this, local_cxy, parent_main_ptr, parent_cxy );
+printk("\n[DBG] %s : thread %x in process %x unblock parent main thread in process %x\n",
+__FUNCTION__ , this->trdid, process->pid,
+hal_remote_lw( XPTR( parent_cxy , &parent_ptr->pid) ) );
 #endif
 …
 tm_end = hal_get_cycles();
 if( DEBUG_SYS_EXIT < tm_end )
+printk("\n[DBG] %s : thread %x exit / process %x / status %x / cost = %d / cycle %d\n",
+__FUNCTION__, this, pid, status, (uint32_t)(tm_end - tm_start), (uint32_t)tm_end );
+printk("\n[DBG] %s : thread %x in process %x exit / status %x / cost = %d / cycle %d\n",
+__FUNCTION__, this->trdid, process->pid, status,
+(uint32_t)(tm_end - tm_start), (uint32_t)tm_end );
 #endif

trunk/kernel/syscalls/sys_fg.c

r446	r457
23	23
24	24	#include <kernel_config.h>
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <hal_irqmask.h>
27	27	#include <errno.h>

trunk/kernel/syscalls/sys_fork.c

-                      r440
+                      r457
 #include <kernel_config.h>
 #include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <hal_context.h>
 #include <hal_switch.h>
 …
 tm_start = hal_get_cycles();
 if( DEBUG_SYS_FORK < tm_start )
 printk("\n[DBG] %s : parent_thread %x enter / parent_pid %x / cycle =  %d\n",
 __FUNCTION__, parent_thread_ptr, parent_pid, (uint32_t)tm_start );
+printk("\n[DBG] %s : thread %x in process %x enter / cycle =  %d\n",
+__FUNCTION__, parent_thread_ptr->trdid, parent_pid, (uint32_t)tm_start );
 #endif
 …
 #if (DEBUG_SYS_FORK & 1 )
 if( DEBUG_SYS_FORK < tm_start )
 printk("\n[DBG] %s : parent_thread %x selected cluster %x\n",
 __FUNCTION__, parent_thread_ptr, child_cxy );
+printk("\n[DBG] %s : thread %x in process %x selected cluster %x\n",
+__FUNCTION__, parent_thread_ptr->trdid, parent_pid, child_cxy );
 #endif
 …
 tm_end = hal_get_cycles();
 if( DEBUG_SYS_FORK < tm_end )
 printk("\n[DBG] %s : parent_thread %x on cluster %x exit / cost = %d / cycle %d\n",
 __FUNCTION__, parent_thread_ptr, parent_cxy, (uint32_t)(tm_end - tm_start), (uint32_t)tm_end );
+printk("\n[DBG] %s : process %x exit / cost = %d / cycle %d\n",
+__FUNCTION__, parent_pid, (uint32_t)(tm_end - tm_start), (uint32_t)tm_end );
 #endif
         return child_pid;
+    }
 …
 tm_end = hal_get_cycles();
 if( DEBUG_SYS_FORK < tm_end )
 printk("\n[DBG] %s : child_thread %x on cluster %x exit / cost = %d / cycle %d\n",
 __FUNCTION__, child_thread_ptr, child_cxy, (uint32_t)(tm_end - tm_start), (uint32_t)tm_end );
+printk("\n[DBG] %s : process %x exit / cost = %d / cycle %d\n",
+__FUNCTION__, child_pid, (uint32_t)(tm_end - tm_start), (uint32_t)tm_end );
 #endif
         return 0;
+    }

trunk/kernel/syscalls/sys_get_config.c

r440	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_uspace.h>
26	26	#include <hal_special.h>

trunk/kernel/syscalls/sys_get_core.c

r440	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_uspace.h>
26	26	#include <hal_special.h>

trunk/kernel/syscalls/sys_get_cycle.c

r440	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_uspace.h>
26	26	#include <hal_special.h>

trunk/kernel/syscalls/sys_getcwd.c

r440	r457
23	23
24	24	#include <kernel_config.h>
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <hal_uspace.h>
27	27	#include <hal_special.h>

trunk/kernel/syscalls/sys_isatty.c

r438	r457
23	23
24	24	#include <kernel_config.h>
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <hal_uspace.h>
27	27	#include <hal_irqmask.h>

trunk/kernel/syscalls/sys_kill.c

r448	r457
23	23
24	24	#include <kernel_config.h>
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <hal_irqmask.h>
27	27	#include <errno.h>

trunk/kernel/syscalls/sys_lseek.c

r23	r457
22	22
23	23	#include <kernel_config.h>
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_uspace.h>
26	26	#include <errno.h>

trunk/kernel/syscalls/sys_mkdir.c

r407	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_uspace.h>
26	26	#include <vfs.h>

trunk/kernel/syscalls/sys_mkfifo.c

r407	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_uspace.h>
26	26	#include <printk.h>

trunk/kernel/syscalls/sys_mmap.c

r440	r457
23	23	*/
24	24
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <hal_uspace.h>
27	27	#include <hal_irqmask.h>

trunk/kernel/syscalls/sys_munmap.c

r438	r457
23	23	*/
24	24
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <hal_uspace.h>
27	27	#include <shared_syscalls.h>

trunk/kernel/syscalls/sys_mutex.c

r440	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_special.h>
26	26	#include <errno.h>

trunk/kernel/syscalls/sys_open.c

r407	r457
23	23
24	24	#include <kernel_config.h>
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <hal_uspace.h>
27	27	#include <errno.h>

trunk/kernel/syscalls/sys_opendir.c

r407	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <thread.h>
26	26	#include <process.h>

trunk/kernel/syscalls/sys_pipe.c

r407	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <vfs.h>
26	26	#include <process.h>

trunk/kernel/syscalls/sys_read.c

r450	r457
23	23
24	24	#include <kernel_config.h>
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <hal_uspace.h>
27	27	#include <hal_irqmask.h>

trunk/kernel/syscalls/sys_readdir.c

r407	r457
23	23
24	24	#include <kernel_config.h>
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <hal_uspace.h>
27	27	#include <errno.h>

trunk/kernel/syscalls/sys_rmdir.c

r407	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_uspace.h>
26	26	#include <printk.h>

trunk/kernel/syscalls/sys_sem.c

-                      r440
+                      r457
  */
 #include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <hal_uspace.h>
+#include <shared_semaphore.h>
 #include <errno.h>
 #include <thread.h>
 …
 #include <syscalls.h>
+#if DEBUG_SYS_SEM
+//////////////////////////////////////////////////
+static char * sys_sem_op_str( uint32_t operation )
+{
+        if     ( operation == SEM_INIT     ) return "INIT";
+        else if( operation == SEM_WAIT     ) return "WAIT";
+        else if( operation == SEM_POST     ) return "POST";
+        else if( operation == SEM_GETVALUE ) return "GETVALUE";
+        else if( operation == SEM_DESTROY  ) return "DESTROY";
+        else                                 return "undefined";
+}
+#endif
 //////////////////////////////////
+int sys_sem( void         * vaddr,        // semaphore virtual  address
+             uint32_t       operation,    // requested operation type
+             uint32_t     * value )       // pointer on in/out argument
+int sys_sem( void         * vaddr,            // semaphore virtual  address
+             uint32_t       operation,        // requested operation type
+             uint32_t       init_value,       // initial value
+             uint32_t     * current_value )   // pointer on current value buffer
+{
-        uint32_t         data;
         vseg_t         * vseg;
     error_t          error;
+    uint32_t         current;     // semaphore current value
+    xptr_t           sem_xp;      // extended pointer on semaphore
     thread_t       * this    = CURRENT_THREAD;
     process_t      * process = this->process;
+#if DEBUG_SYS_SEM
+uint64_t    tm_start;
+uint64_t    tm_end;
+tm_start = hal_get_cycles();
+if( DEBUG_SYS_SEM < tm_start )
+printk("\n[DBG] %s : thread %x in process %x enter for %s / cycle %d\n",
+__FUNCTION__, this->trdid, process->pid, sys_sem_op_str( operation ), (uint32_t)tm_start );
+#endif
     // check vaddr in user vspace
 …
 #if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : unmapped semaphore %x / thread %x / process %x\n",
+__FUNCTION__ , (intptr_t)vaddr, this->trdid, process->pid );
+vmm_display( process , false );
+#endif
+        this->errno = EINVAL;
+        return -1;
+    }
+    // check value in user vspace
+        error = vmm_get_vseg( process , (intptr_t)value , &vseg );
+        if( error )
+    {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : unmapped value %x / thread %x / process %x\n",
+printk("\n[ERROR] in %s : unmapped semaphore pointer %x / thread %x in process %x\n",
 __FUNCTION__ , (intptr_t)vaddr, this->trdid, process->pid );
 vmm_display( process , false );
 …
             case SEM_INIT:
+        {
+            // get argument
+                    hal_copy_from_uspace( &data , value , sizeof(uint32_t) );
+            // call init function
+            error = remote_sem_create( (intptr_t)vaddr , data );
+            // call relevant kernel function to initialize semaphore
+            error = remote_sem_create( (intptr_t)vaddr ,
+                                       init_value,
+                                       XPTR( local_cxy , &sem_xp ) );
             if ( error )
+            {
+                printk("\n[ERROR] in %s : cannot create semaphore = %x\n",
+                       __FUNCTION__ , (intptr_t)value );
+                this->errno = error;
+                return -1;
+            }
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : cannot create semaphore / thread %x in process %x\n",
+__FUNCTION__, this->trdid, process->pid );
+#endif
+                this->errno = ENOMEM;
+                return -1;
+            }
             break;
+        }
 …
         case SEM_GETVALUE:
+        {
+            // get extended pointer on remote semaphore
+            xptr_t sem_xp = remote_sem_from_vaddr( (intptr_t)vaddr );
+            if( sem_xp == XPTR_NULL )     // user error
+            {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : semaphore %x not registered / thread %x / process %x\n",
+__FUNCTION__ , (intptr_t)value, this->trdid, process->pid );
+#endif
+                this->errno = EINVAL;
+                return -1;
+            }
+            else                          // success
+            {
+                // get semaphore current value
+                        remote_sem_get_value( sem_xp , &data );
+            // check current_value buffer in user vspace
+                error = vmm_get_vseg( process , (intptr_t)current_value , &vseg );
+            if( error )
+            {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : unmapped buffer for current value %x / thread %x in process %x\n",
+__FUNCTION__ , (intptr_t)current_value, this->trdid, process->pid );
+vmm_display( process , false );
+#endif
+                this->errno = EINVAL;
+                return -1;
+            }
+            // get extended pointer on remote semaphore
+            sem_xp = remote_sem_from_vaddr( (intptr_t)vaddr );
+            // check semaphore registered
+            if( sem_xp == XPTR_NULL )
+            {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : semaphore %x not registered / thread %x in process %x\n",
+__FUNCTION__ , (intptr_t)vaddr, this->trdid, process->pid );
+#endif
+                this->errno = EINVAL;
+                return -1;
+            }
+            // call relevant kernel function to get semaphore current value
+                    remote_sem_get_value( sem_xp , &current );
                 // return value to user
                 hal_copy_to_uspace( value , &data , sizeof(uint32_t) );
+            }
+            // return value to user
+            hal_copy_to_uspace( current_value , &current , sizeof(uint32_t) );
             break;
+        }
 …
+        {
             // get extended pointer on remote semaphore
             xptr_t sem_xp = remote_sem_from_vaddr( (intptr_t)vaddr );
             if( sem_xp == XPTR_NULL )     // user error
+            {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : semaphore %x not registered / thread %x / process %x\n",
+__FUNCTION__ , (intptr_t)value, this->trdid, process->pid );
+#endif
+                this->errno = EINVAL;
                 return -1;
+            }
             else                          // success
+            {
                 // wait semaphore available
                 remote_sem_wait( sem_xp );
+            }
+            sem_xp = remote_sem_from_vaddr( (intptr_t)vaddr );
+            // check semaphore registered
+            if( sem_xp == XPTR_NULL )
+            {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : semaphore %x not registered / thread %x in process %x\n",
+__FUNCTION__ , (intptr_t)vaddr, this->trdid, process->pid );
+#endif
+                this->errno = EINVAL;
+                return -1;
+            }
+            // call relevant kernel function to wait semaphore available
+            remote_sem_wait( sem_xp );
             break;
+        }
 …
+        {
             // get extended pointer on remote semaphore
             xptr_t sem_xp = remote_sem_from_vaddr( (intptr_t)vaddr );
             if( sem_xp == XPTR_NULL )     // user error
+            {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : semaphore %x not registered / thread %x / process %x\n",
+__FUNCTION__ , (intptr_t)value, this->trdid, process->pid );
+#endif
+                this->errno = EINVAL;
                 return -1;
+            }
             else                          // success
+            {
                 // release semaphore
                 remote_sem_post( sem_xp );
+            }
+            sem_xp = remote_sem_from_vaddr( (intptr_t)vaddr );
+            // check semaphore registered
+            if( sem_xp == XPTR_NULL )
+            {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : semaphore %x not registered / thread %x in process %x\n",
+__FUNCTION__ , (intptr_t)vaddr, this->trdid, process->pid );
+#endif
+                this->errno = EINVAL;
+                return -1;
+            }
+            // call relevant kernel function to release semaphore
+            remote_sem_post( sem_xp );
                         break;
+        }
 …
+        {
             // get extended pointer on remote semaphore
             xptr_t sem_xp = remote_sem_from_vaddr( (intptr_t)vaddr );
             if( sem_xp == XPTR_NULL )     // user error
+            {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : semaphore %x not registered / thread %x / process %x\n",
+__FUNCTION__ , (intptr_t)value, this->trdid, process->pid );
+#endif
+                this->errno = EINVAL;
                 return -1;
+            }
             else                          // success
+            {
                 // destroy semaphore
                 remote_sem_destroy( sem_xp );
+            }
+            sem_xp = remote_sem_from_vaddr( (intptr_t)vaddr );
+            // check semaphore registered
+            if( sem_xp == XPTR_NULL )
+            {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : semaphore %x not registered / thread %x in process %x\n",
+__FUNCTION__ , (intptr_t)vaddr, this->trdid, process->pid );
+#endif
+                this->errno = EINVAL;
+                return -1;
+            }
+            // destroy semaphore
+            remote_sem_destroy( sem_xp );
             break;
+            }
 …
             default:  // undefined operation
+        {
+            printk("\n[PANIC] in %s : illegal operation type\n", __FUNCTION__ );
+            hal_core_sleep();
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : undefined operation type %d / thread %x in process %x\n",
+__FUNCTION__ , operation, this->trdid, process->pid );
+#endif
+            this->errno = EINVAL;
+            return -1;
+        }
+        }
+    hal_fence();
+#if DEBUG_SYS_SEM
+tm_end = hal_get_cycles();
+if( DEBUG_SYS_SEM < tm_end )
+{
+    cxy_t          sem_cxy = GET_CXY( sem_xp );
+    remote_sem_t * sem_ptr = GET_PTR( sem_xp );
+    uint32_t       value   = hal_remote_lw( XPTR( sem_cxy , &sem_ptr->count ) );
+    printk("\n[DBG] %s : thread %x in process %x exit for %s / value %d / cost = %d / cycle %d\n",
+    __FUNCTION__, this->trdid, process->pid, sys_sem_op_str( operation ), value,
+    (uint32_t)(tm_end - tm_start), (uint32_t)tm_end );
+}
+#endif
     return 0;

trunk/kernel/syscalls/sys_signal.c

r435	r457
23	23	*/
24	24
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <errno.h>
27	27	#include <thread.h>

trunk/kernel/syscalls/sys_stat.c

r440	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_uspace.h>
26	26	#include <hal_special.h>

trunk/kernel/syscalls/sys_thread_cancel.c

r443	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_irqmask.h>
26	26	#include <hal_remote.h>

trunk/kernel/syscalls/sys_thread_create.c

r440	r457
23	23
24	24	#include <kernel_config.h>
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <hal_uspace.h>
27	27	#include <printk.h>

trunk/kernel/syscalls/sys_thread_detach.c

r23	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_remote.h>
26	26	#include <hal_special.h>

trunk/kernel/syscalls/sys_thread_exit.c

r440	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_irqmask.h>
26	26	#include <thread.h>

trunk/kernel/syscalls/sys_thread_join.c

r438	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_remote.h>
26	26	#include <hal_special.h>

trunk/kernel/syscalls/sys_thread_wakeup.c

r438	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <thread.h>
26	26	#include <printk.h>

trunk/kernel/syscalls/sys_thread_yield.c

r445	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_special.h>
26	26	#include <scheduler.h>

trunk/kernel/syscalls/sys_timeofday.c

r440	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_uspace.h>
26	26	#include <thread.h>

trunk/kernel/syscalls/sys_trace.c

r443	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_special.h>
26	26	#include <printk.h>

trunk/kernel/syscalls/sys_unlink.c

r407	r457
21	21	*/
22	22
23		#include <hal_types.h>
	23	#include <hal_kernel_types.h>
24	24	#include <hal_uspace.h>
25	25	#include <vfs.h>

trunk/kernel/syscalls/sys_utls.c

r23	r457
23	23	*/
24	24
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <errno.h>
27	27	#include <thread.h>

trunk/kernel/syscalls/sys_wait.c

r446	r457
22	22	*/
23	23
24		#include <hal_types.h>
	24	#include <hal_kernel_types.h>
25	25	#include <hal_uspace.h>
26	26	#include <hal_irqmask.h>

trunk/kernel/syscalls/sys_write.c

r443	r457
23	23
24	24	#include <kernel_config.h>
25		#include <hal_types.h>
	25	#include <hal_kernel_types.h>
26	26	#include <hal_uspace.h>
27	27	#include <hal_irqmask.h>

trunk/kernel/syscalls/syscalls.h

-                      r445
+                      r457
  * syscalls.h - Kernel side services for syscall handling.
+ *
  * Author     Alain Greiner (2016,2017)
+ * Author     Alain Greiner (2016,2017,2018)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
 #define _SYSCALLS_H_
 #include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <shared_syscalls.h>
 …
  * and the code implementing the operations is in the remore_sem.c file.
  ******************************************************************************************
+ * @ vaddr     : semaphore virtual address in user space == identifier.
+ * @ operation : SEM_INIT / SEM_DESTROY / SEM_GETVALUE / SEM_POST / SEM_WAIT.
+ * @ value     : pointer on in/out argument in user space.
+ * @ vaddr         : semaphore virtual address in user space == identifier.
+ * @ operation     : SEM_INIT / SEM_DESTROY / SEM_GETVALUE / SEM_POST / SEM_WAIT.
+ * @ init_value    : initial semaphore value.
+ * @ current_value : pointer on buffer for current semaphore value.
  * @ return 0 if success / return -1 if failure.
  *****************************************************************************************/
 int sys_sem( void       * vaddr,
              uint32_t     operation,
+             uint32_t   * value );
+             uint32_t     init_value,
+             uint32_t   * current_value );
 /******************************************************************************************
 …
 /******************************************************************************************
+ * [44] TBD
+ ******************************************************************************************
+ * @ cxy    : cluster identifier.
+ * @ lid    : core local index.
+ * @ return 0 if success / return -1 if failure.
+ *****************************************************************************************/
+int sys_place( uint32_t cxy,
+               uint32_t lid );
+/******************************************************************************************
  * [45] This function block the calling thread on the THREAD_BLOCKED_GLOBAL condition,
  * and deschedule.
 …
 /******************************************************************************************
+ * [49] TBD
+ ******************************************************************************************
+ * @ cxy    : cluster identifier.
+ * @ lid    : core local index.
+ * @ return 0 if success / return -1 if failure.
+ *****************************************************************************************/
+int sys_place( uint32_t cxy,
+               uint32_t lid );
+ * [49] This function returns a non-zero value in the <is_fg> buffer when the process
+ * identified by the <pid> argument is the current TXT owner.
+ ******************************************************************************************
+ * @ pid      : process identifier.
+ * @ is_fg    : pointer on buffer.
+ * @ return 0 if success / return -1 if failure.
+ *****************************************************************************************/
+int sys_is_fg( pid_t      pid,
+               uint32_t * is_fg );
 #endif  // _SYSCALLS_H_

trunk/libs/libalmosmkh/almosmkh.c

-                      r445
+                      r457
 #include <almosmkh.h>
 #include <hal_user.h>
 #include <hal_types.h>
+#include <hal_shared_types.h>
 #include <syscalls_numbers.h>
 #include <string.h>
 …
     return hal_user_syscall( SYS_FG,
                              (reg_t)pid, 0, 0, 0 );
+}
+//////////////////////////////
+int is_fg( unsigned int   pid,
+           unsigned int * owner )
+{
+    return hal_user_syscall( SYS_IS_FG,
+                             (reg_t)pid,
+                             (reg_t)owner, 0, 0 );
+}
 …
 //////////////////////////////////
 int trace( unsigned int active,
            unsigned int pid,
+           unsigned int cxy,
            unsigned int lid )
+{
     return hal_user_syscall( SYS_TRACE,
                              (reg_t)active,
                              (reg_t)pid,
+                             (reg_t)cxy,
                              (reg_t)lid, 0 );
+}
 …
 ///////////////    non standard debug functions    //////////////////////////
+///////////////    non standard malloc functions    //////////////////////////
 #define  MALLOC_DEBUG  0

trunk/libs/libalmosmkh/almosmkh.h

-                      r450
+                      r457
 /***************************************************************************************
  * various the user level, ALMOS-MKH specific library. It contains:
+ * This file defines an user level, ALMOS-MKH specific library, containing:
  * - non standard system calls.
  * - debug functions.
 …
 /***************************************************************************************
  * This function is used to give the process identified by the <pid> argument the
  * exclusive ownership of the attached TXT_RX terminal.
+ * exclusive ownership of its TXT terminal.
  ***************************************************************************************
  * @ pid        : process identifier.
 …
  **************************************************************************************/
 int fg( unsigned int pid );
+/***************************************************************************************
+ * This function stores in the buffer identified by the <owner> argument a non zero
+ * value when the process identified by the <pid> argument is currently the exclusive
+ * owner of its TXT terminal.
+ ***************************************************************************************
+ * @ pid        : [in]  process identifier.
+ * @ owner      : [out] pointer on buffer to store the
+ * @ returns O if success / returns -1 if process not found.
+ **************************************************************************************/
+int is_fg( unsigned int pid,
+           unsigned int * owner );
 /***************************************************************************************

trunk/libs/libpthread/Makefile

-                      r445
+                      r457
 endif
+SRCS = pthread.c
+OBJS = $(addprefix build/, $(SRCS:.c=.o)) \
+OBJS = build/pthread.o                    \
        $(HAL_ARCH)/build/core/hal_user.o
 …
 headers: build
         cp $(SRCS:.c=.h)  build/include/.
+        cp pthread.h  build/include/.

trunk/libs/libpthread/pthread.c

-                      r445
+                      r457
 /*
  * pthread.c - User leve <pthread> library implementation.
+ * pthread.c - User level <pthread> library implementation.
+ *
  * Author     Alain Greiner (2016,2017,2018)
 …
 #include <hal_user.h>
 #include <hal_types.h>
+#include <hal_shared_types.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <pthread.h>
+#include <shared_pthread.h>
 #include <almosmkh.h>
 #include <syscalls_numbers.h>

trunk/libs/libpthread/pthread.h

-                      r445
+                      r457
 #define _PTHREAD_H_
+//////////////////////////////////////////////////////////////////////////////////////////////
+//             POSIX Threads related functions (including barriers and mutexes)
+//////////////////////////////////////////////////////////////////////////////////////////////
 #include <shared_pthread.h>
-//////////////////////////////////////////////////////////////////////////////////////////////
-//             POSIX Threads related functions
-//////////////////////////////////////////////////////////////////////////////////////////////
 /*********************************************************************************************

trunk/libs/mini-libc/dirent.c

r449	r457
23	23
24	24	#include <dirent.h>
25		#include <hal_types.h>
	25	#include <hal_shared_types.h>
26	26	#include <hal_user.h>
27	27	#include <syscalls_numbers.h>

trunk/libs/mini-libc/fcntl.c

r449	r457
23	23
24	24	#include <fcntl.h>
25		#include <hal_types.h>
	25	#include <hal_shared_types.h>
26	26	#include <hal_user.h>
27	27	#include <syscalls_numbers.h>

trunk/libs/mini-libc/mman.c

r449	r457
23	23
24	24	#include <mman.h>
25		#include <hal_types.h>
	25	#include <hal_shared_types.h>
26	26	#include <hal_user.h>
27	27	#include <syscalls_numbers.h>

trunk/libs/mini-libc/signal.c

-                      r449
+                      r457
 /*
  * signal.c - User side signals related syscalls implementation.
+ * signal.c - User side signals related library implementation.
+ *
  * Author     Alain Greiner (2016,2017,2018)
 …
 #include <signal.h>
 #include <hal_types.h>
+#include <hal_shared_types.h>
 #include <hal_user.h>
 #include <syscalls_numbers.h>

trunk/libs/mini-libc/stat.c

-                      r449
+                      r457
 /*
  * stat.c - User side file stat related syscalls implementation.
+ * stat.c - User side file statistics related library implementation.
+ *
  * Author     Alain Greiner (2016,2017,2018)
 …
 #include <stat.h>
 #include <hal_user.h>
 #include <hal_types.h>
+#include <hal_shared_types.h>
 #include <syscalls_numbers.h>

trunk/libs/mini-libc/stdio.c

r445	r457
266	266	if ( count == -1 )
267	267	{
268		display_string( "~~stdlib~~ : xprintf failure" );
	268	display_string( "printf : xprintf failure" );
269	269	return -1;
270	270	}
…	…
272	272	{
273	273	string[count] = 0;
274		return write( 1 , &string , count ~~+ 1~~ );
	274	return write( 1 , &string , count );
275	275	}
276	276	}

trunk/libs/mini-libc/stdlib.c

-                      r445
+                      r457
 #include <stdlib.h>
 #include <hal_types.h>
+#include <hal_shared_types.h>
 #include <hal_user.h>
+#include <syscalls_numbers.h>
 #include <almosmkh.h>
 #include <stdio.h>
-#include <syscalls_numbers.h>
 //////////////////////////

trunk/libs/mini-libc/time.c

-                      r449
+                      r457
 #include <time.h>
 #include <hal_user.h>
+#include <hal_user.h>
+#include <hal_types.h>
+#include <hal_shared_types.h>
 #include <syscalls_numbers.h>
 …
                   struct timezone * tz )
+{
     return hal_user_syscall( SYS_TIMEOFDAY, // TODO SYS_SIGNAL ?
+    return hal_user_syscall( SYS_TIMEOFDAY,
                              (reg_t)tv,
                              (reg_t)tz, 0, 0 );

trunk/libs/mini-libc/unistd.c

r449	r457
23	23
24	24	#include <unistd.h>
25		#include <hal_types.h>
	25	#include <hal_shared_types.h>
26	26	#include <hal_user.h>
27	27	#include <syscalls_numbers.h>

trunk/libs/mini-libc/wait.c

r449	r457
24	24	#include <wait.h>
25	25	#include <hal_user.h>
26		#include <hal_types.h>
	26	#include <hal_shared_types.h>
27	27	#include <syscalls_numbers.h>
28	28

trunk/libs/mini-libc/wait.h

-                      r449
+                      r457
  * This blocking function returns only when one child process of the calling process
  * changes state (from RUNNING to STOPPED / EXITED / KILLED). It returns the terminating
  * child process PID, and set in the <status> buffer the new child process state.
+ * child process PID, and set in the <status> buffer the terminating child process state.
  *****************************************************************************************
  * @ status    : [out] terminating child process state.
+ * @ status    : [out] pointer on buffer for terminating child process state.
  * @ returns terminating child process pid.
  ****************************************************************************************/

trunk/params-hard.mk

r446	r457
5	5	Y_SIZE = 2
6	6	NB_PROCS = 1
7		NB_TTYS = 2
	7	NB_TTYS = 3
8	8	FBF_WIDTH = 128
9	9	IOC_TYPE = IOC_BDV

trunk/params-soft.mk

-                      r445
+                      r457
 LIBPTHREAD         = $(LIBPTHREAD_PATH)/build/lib/
 LIBPTHREAD_INCLUDE = $(LIBPTHREAD_PATH)/build/include/
+# define paths for LIBSEMAPHORE
+LIBSEMAPHORE_PATH    = $(ALMOSMKH_DIR)/libs/libsemaphore
+LIBSEMAPHORE         = $(LIBSEMAPHORE_PATH)/build/lib/
+LIBSEMAPHORE_INCLUDE = $(LIBSEMAPHORE_PATH)/build/include/
 # define paths for LIBALMOSMKH

trunk/tools/arch_info/arch_info.h

r6	r457
49	49	***************************************************************************************/
50	50
51		#include <hal_types.h>
	51	#include <hal_kernel_types.h>
52	52
53	53	#define ARCHINFO_HEADER_SIZE sizeof(archinfo_header_t)

trunk/tools/arch_info/boot_info.h

-                      r296
+                      r457
 #define _BOOT_INFO_H_
 #include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <kernel_config.h>
 …
     // kernel segments
     reg_t         kcode_base;                    /*! kernel code base paddr                 */
     reg_t         kcode_size;                    /*! kernel code size                       */
     reg_t         kdata_base;                    /*! kernel data base paddr                 */
     reg_t         kdata_size;                    /*! kernel data size                       */
     reg_t         kentry_base;                   /*! kernel entry base paddr                */
     reg_t         kentry_size;                   /*! kernel entry size                      */
+    intptr_t      kcode_base;                    /*! kernel code base paddr                 */
+    intptr_t      kcode_size;                    /*! kernel code size                       */
+    intptr_t      kdata_base;                    /*! kernel data base paddr                 */
+    intptr_t      kdata_size;                    /*! kernel data size                       */
+    intptr_t      kentry_base;                   /*! kernel entry base paddr                */
+    intptr_t      kentry_size;                   /*! kernel entry size                      */
+}
 boot_info_t;

trunk/user/idbg/idbg.c

-                      r450
+                      r457
     printf( "\n[IDBG] starts at cycle %d\n", (unsigned int)cycle );
+//    idbg();
+    exit( 0 );
+    idbg();
 } // end main()

trunk/user/init/init.c

-                      r445
+                      r457
     for( i = 1 ; i <  NB_TXT_CHANNELS ; i++ )
+    {
+#if DEBUG_PROCESS_INIT
+snprintf( string , 64 , "[INIT] start child[%d] creation" , i );
+display_string( string );
+#endif
         // INIT process fork process CHILD[i]
         ret_fork = fork();
 …
+        {
             // INIT display error message
             snprintf( string , 64 , "[INIT] cannot fork child[%d] => suicide" , i );
+            snprintf( string , 64 , "[INIT ERROR] cannot fork child[%d] => suicide" , i );
             display_string( string );
 …
         else                                      // we are in INIT process
+        {
              // INIT display CHILD[i] process PID
              snprintf( string , 64 , "[INIT] created KSH[%d] / pid = %x", i , ret_fork );
              display_string( string );
+            // INIT display CHILD[i] process PID
+            snprintf( string , 64 , "[INIT] created KSH[%d] / pid = %x", i , ret_fork );
+            display_string( string );
+        }
-        // INIT wait CHILD[i] process deletion before creating KSH[i+1]
-        // int n;
-        // for( n = 0 ; n < 100000 ; n++ ) asm volatile ( "nop" );
-        wait( &status );
+    }
 #if DEBUG_PROCESS_INIT
+unsigned int  x_size;        // number of clusters in a row
+unsigned int  y_size;        // number of clusters in a column
+unsigned int  ncores;        // number of cores per cluster
+unsigned int  x;             // cluster x coordinate
+unsigned int  y;             // cluster y coordinate
+unsigned int  cxy;           // cluster identifier
+unsigned int  lid;           // core local index
+    unsigned int  x_size;        // number of clusters in a row
+    unsigned int  y_size;        // number of clusters in a column
+    unsigned int  ncores;        // number of cores per cluster
+    unsigned int  x;             // cluster x coordinate
+    unsigned int  y;             // cluster y coordinate
+    unsigned int  cxy;           // cluster identifier
+    unsigned int  lid;           // core local index
+    // get hardware config
+    get_config( &x_size , &y_size , &ncores );
+// get hardware config
+get_config( &x_size , &y_size , &ncores );
+    // INIT displays processes and threads in all clusters
+    for( x = 0 ; x < x_size ; x++ )
+// INIT displays processes and threads in all clusters
+for( x = 0 ; x < x_size ; x++ )
+{
+    for( y = 0 ; y < y_size ; y++ )
+    {
+        for( y = 0 ; y < y_size ; y++ )
+        {
+            cxy = CXY_FROM_XY( x , y );
+            display_cluster_processes( cxy );
+            for( lid = 0 ; lid < ncores ; lid++ )
+            {
+                display_sched( cxy , lid );
+            }
+        cxy = CXY_FROM_XY( x , y );
+        display_cluster_processes( cxy );
+        for( lid = 0 ; lid < ncores ; lid++ )
+        {
+            display_sched( cxy , lid );
+        }
+    }
+}
 #endif

trunk/user/ksh/Makefile

-                      r445
+                      r457
 OBJS = build/ksh.o
+INCLUDES = -I.                      \
+           -I$(LIBC_INCLUDE)        \
+           -I$(LIBPTHREAD_INCLUDE)  \
+           -I$(LIBALMOSMKH_INCLUDE) \
+INCLUDES = -I.                       \
+           -I$(LIBC_INCLUDE)         \
+           -I$(LIBPTHREAD_INCLUDE)   \
+           -I$(LIBALMOSMKH_INCLUDE)  \
+           -I$(LIBSEMAPHORE_INCLUDE) \
            -I$(SHARED_INCLUDE)
 …
 build/ksh.elf : $(OBJS) ksh.ld
+        $(LD) -o $@ -T ksh.ld $(OBJS) -L$(LIBC) -L$(LIBPTHREAD) -L$(LIBALMOSMKH) -lc -lpthread -lalmosmkh -lpthread -lc
+        $(LD) -o $@ -T ksh.ld $(OBJS) -L$(LIBC) -L$(LIBPTHREAD) -L$(LIBALMOSMKH) -L$(LIBSEMAPHORE) \
+    -lc -lpthread -lalmosmkh -lpthread -lsemaphore -lc
         $(DU) -D $@ > $@.txt

trunk/user/ksh/ksh.c

-                      r446
+                      r457
 // Author :  Alain Greiner
 ///////////////////////////////////////////////////////////////////////////////
+// This applications implement a minimal shell for ALMOS-MKH.
+// This user process contains two POSIX threads:
+// This application implements a minimal shell for ALMOS-MKH.
+//
+// This user KSH process contains two POSIX threads:
 // - the "main" thread contains the infinite loop implementing
+//   the children processes termination monitoring (children processes
+//   are created by the <load> command and attached to the KSH TXT terminal).
+//   the children processes termination monitoring using the wait syscall.
 // - the "interactive" thread contains the infinite loop implementing
 //   the command interpreter attached to the TXT terminal.
+//   This "interactive" thread block and deschedules when the KSH process
+//   loses the TXT terminal ownership. It is reactivated when the KSH
+//   process returns in background.
+//
+// Note: the children processes are created by the <load> command, and are
+// attached to the same TXT terminal as the KSH process itself.
+// . A child process can be lauched in foreground: the KSH process loses
+//   the TXT terminal ownership, that is transfered to the new process.
+// . A child process can be lauched in background: the KSH process keeps
+//   the TXT terminal ownership. that is transfered to the new process.
 ///////////////////////////////////////////////////////////////////////////////
 …
 #include <unistd.h>
 #include <almosmkh.h>
+#include <semaphore.h>
 #define CMD_MAX_SIZE   (256)    // max number of characters in one command
 …
 #define MAX_ARGS           (32)     // max number of arguments in a command
 #define FIFO_SIZE      (1024)   // FIFO depth for recursive ls
+#define KSH_DEBUG      0
 ////////////////////////////////////////////////////////////////////////////////
 …
 unsigned int    ptr;                      // read pointer in log_entries[]
+pthread_attr_t  attr;                     // monitor thread attributes
+pthread_attr_t  attr;                     // interactive thread attributes
+sem_t           semaphore;                // block interactive thread when zero
 ////////////////////////////////////////////////////////////////////////////////
 …
 */
+    // release semaphore to get next command
+    sem_post( &semaphore );
 }   // end cmd_cat()
 …
     printf("  error: not implemented yet\n");
+/*
+        path = argv[1];
+        if (chdir(path) == -1)
+    {
+                printf("  error: cannot cd to %s\n", path);
+        }
+*/
+    // release semaphore to get next command
+    sem_post( &semaphore );
 }   // end cmd_cd()
 …
 */
+    // release semaphore to get next command
+    sem_post( &semaphore );
 }   // end cmd_cp()
 …
         printf("  usage: display (vmm/sched/process/vfs/chdev/txt) [arg2] [arg3]\n");
+    }
+    // release semaphore to get next command
+    sem_post( &semaphore );
 } // end cmd_display()
 …
                 printf("  error: cannot find process %x\n", pid );
+        }
+    // release semaphore to get next command
+    sem_post( &semaphore );
 }  // end cmd_fg()
 …
                 printf("\t%s\t : %s\n", cmd[i].name , cmd[i].desc);
+        }
+    // release semaphore to get next command
+    sem_post( &semaphore );
 }   // end cmd_help()
 …
                 printf("  error: process %x cannot be killed\n", pid );
+        }
+    // release semaphore to get next command
+    sem_post( &semaphore );
 }   // end cmd_kill()
 …
         char               * pathname;           // path to .elf file
     unsigned int         background;         // background execution if non zero
-    int                  status;             // new process exit status
         if( (argc < 2) || (argc > 3) )
 …
     ksh_pid = getpid();
+#if KSH_DEBUG
+printf("\n[KSH_DEBUG] in %s : ksh PID %x / path %s / background %d\n",
+__FUNCTION__, ksh_pid, argv[1], background );
+#endif
     // KSH process fork CHILD process
         ret_fork = fork();
     if ( ret_fork < 0 )          // it is a failure reported to KSH
+    if ( ret_fork < 0 )     // it is a failure reported to KSH
+    {
         printf("  error: ksh process unable to fork\n");
         return;
+    }
     else if (ret_fork == 0)      // it is the CHILD process
+    else if (ret_fork == 0) // it is the CHILD process
+    {
         // CHILD process exec NEW process
 …
+        }
+        }
+    else                        // it is the parent KSH : ret_fork is the new process PID
+    {
+        // give back terminal ownership to KSH
+        // when new process created in background
+        if( background )   fg( ksh_pid );
+        // return to command interpreter
+        return;
+    else                    // it is the KSH process : ret_fork is the new process PID
+    {
+#if KSH_DEBUG
+int sem_value;
+sem_getvalue( &semaphore , &sem_value );
+printf("\n[KSH_DEBUG] in %s : child PID %x / background %d / sem_value %d\n",
+ret_fork, background, sem_value  );
+#endif
+        if( background )        // child in background =>  KSH keeps TXT ownership
+        {
+            // execve() tranfered TXT ownership to child => give it back to KSH
+            fg( ksh_pid );
+            // release semaphore to get next command
+            sem_post( &semaphore );
+        }
+    }
 }   // end cmd_load
 …
                 printf(" - %d\t: %s\n", i, &log_entries[i].buf);
+        }
+}
+    // release semaphore to get next command
+    sem_post( &semaphore );
+} // end cmd_log()
 ////////////////////////////////////////////
 …
         closedir(dir);
 */
+}
+    // release semaphore to get next command
+    sem_post( &semaphore );
+} // end cmd_ls()
 ///////////////////////////////////////////////
 …
     printf("  error: not implemented yet\n");
+/*
+        if ( mkdir( path, 0x700) == -1 )
+    {
+                printf("  error: cannot create directory %s\n", path);
+        }
+*/
+}
+    // release semaphore to get next command
+    sem_post( &semaphore );
+} // end cmd_mkdir()
 ////////////////////////////////////////////
 …
     printf("  error: not implemented yet\n");
+/*
+        int ret = giet_fat_rename(argv[1], argv[2]);
+        if (ret < 0)
+        {
+                printf("  error : cannot move %s to %s / err = %d\n", argv[1], argv[2], ret );
+        }
+*/
+}
+    // release semaphore to get next command
+    sem_post( &semaphore );
+}  // end cmd_mv
 /////////////////////////////////////////////
 …
                 printf("%s\n", buf);
+        }
+}
+    // release semaphore to get next command
+    sem_post( &semaphore );
+}  // end cmd_pwd()
 ////////////////////////////////////////////
 …
     printf("  error: not implemented yet\n");
+/*
+        if (remove(path) == -1)
+    {
+                printf("  error: cannot remove %s\n", path);
+        }
+*/
+}
+    // release semaphore to get next command
+    sem_post( &semaphore );
+}  // end_cmd_rm()
 ///////////////////////////////////////////////
 static void cmd_rmdir( int argc , char **argv )
+{
+    // same as cmd_rm()
         cmd_rm(argc, argv);
+}
 …
         printf("  error: core[%x,%d] not found\n", cxy, lid );
+    }
+}
+    // release semaphore to get next command
+    sem_post( &semaphore );
+}  // end cmd_trace
 ///////////////////////////////////////////////
 …
         printf("  error: core[%x,%d] not found\n", cxy, lid );
+    }
+}
+//////////////////////////////////////////////////////////////////
+    // release semaphore to get next command
+    sem_post( &semaphore );
+}  // end cmd_untrace()
+///////////////////////////////////////////////////////////////////////////////////
 // Array of commands
 //////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////
 ksh_cmd_t cmd[] =
 …
         { "load",    "load an user application",                        cmd_load    },
         { "help",    "list available commands",                         cmd_help    },
         { "kill",    "kill an application (all threads)",               cmd_kill    },
+        { "kill",    "kill a process (all threads)",                    cmd_kill    },
         { "log",     "list registered commands",                        cmd_log     },
         { "ls",      "list directory entries",                          cmd_ls      },
 …
 ////////////////////////////////////////////////////////////////////////////////////
 // This function analyses one command (with arguments), execute it, and return.
+// This function analyses one command (with arguments), executes it, and returns.
 ////////////////////////////////////////////////////////////////////////////////////
 static void parse(char *buf)
+static void parse( char * buf )
+{
         int argc = 0;
 …
+                }
+                if (!found)
+        {
+                        printf("  undefined command <%s>\n", argv[0]);
+                if (!found)  // undefined command
+        {
+                        printf("  error : undefined command <%s>\n", argv[0]);
+            // release semaphore to get next command
+            sem_post( &semaphore );
+                }
+        }
 …
         char         c;                                           // read character
         char         buf[CMD_MAX_SIZE];           // buffer for one command
+        unsigned int count;                               // pointer in buf
+    unsigned int end_command;             // last character found in a command
+        unsigned int count;                               // pointer in command buffer
         unsigned int i;                                           // index for loops
+        unsigned int state;                   // escape sequence state
+char string[80];
         enum fsm_states
+    {
                 NORMAL,
                 ESCAPE,
                 BRAKET,
+                NORMAL = 0,
+                ESCAPE = 1,
+                BRAKET = 2,
         };
+        // initialize command buffer
+        memset( buf, 0x20 , sizeof(buf) );
+        count = 0;
+        // display first prompt
+        printf("# ");
+        // This lexical analyser writes one command line in the buf buffer.
+        // It is implemented as a 3 states FSM to handle the following sequences:
+        // This lexical analyser writes one command line in the command buffer.
+        // It is implemented as a 3 states FSM to handle the following escape sequences:
         // - ESC [ A : up arrow
         // - ESC [ B : down arrow
 …
         // - BRAKET : the wo characters (ESC,[) have been found
+        unsigned int state = NORMAL;
+// @@@
+parse("load /bin/user/idbg.elf");
+// @@@
+    // external loop on the commands
+    // the in teractive thread should not exit this loop
         while (1)
+        {
+                c = (char)getchar();
+        if( c == 0 ) continue;
+                switch (state)
+                {
+                        case NORMAL:
+                        {
+            // initialize command buffer
+            memset( buf, 0x20 , sizeof(buf) );   // TODO useful ?
+            count = 0;
+            state = NORMAL;
+        // block if the KSH process is not the TXT owner
+        // - if the command is not a "load"
+        //   the semaphore must be released by the cmd_***()
+        // - if the command is a load, it depends on
+        //   the "background" argument
+        sem_wait( &semaphore );
+        // display prompt on a new line
+        printf("\n[ksh] ");
+        end_command = 0;
+        // internal loop on characters in one command
+        while( end_command == 0 )
+        {
+            // get one character from TXT_RX
+                c = (char)getchar();
+            if( c == 0 ) continue;
+                    if( state == NORMAL )  // we are not in an escape sequence
+                    {
                                 if ((c == '\b') || (c == 0x7F))  // backspace => remove one character
+                                {
+                                        if (count > 0) {
+                                                printf("\b \b");
+                                                count--;
+                                    if (count > 0)
+                    {
+                                        printf("\b \b");
+                                        count--;
+                                    }
+                                }
+                                else if (c == '\n')                  // new line => end of command
+                                {
+                                    if (count > 0)               // analyse & execute command
+                                    {
+                                            // complete command with NUL character
+                                            buf[count] = 0;
+                        count++;
+                                        // register command in log arrays
+                                            strcpy(log_entries[ptw].buf, buf);
+                                            log_entries[ptw].count = count;
+                                            ptw = (ptw + 1) % LOG_DEPTH;
+                                            ptr = ptw;
+                        // echo character
+                        putchar( c );
+                                            // call parser to analyse and execute command
+                                            parse( buf );
+                                    }
+                    else                         // no command registered
+                    {
+                        // release semaphore to get next command
+                        sem_post( &semaphore );
+                    }
+                    // exit internal loop on characters
+                    end_command = 1;
+                }
+                            else if (c == '\t')             // tabulation => do nothing
+                                {
+                            }
+                            else if (c == (char)0x1B)       // ESC => start an escape sequence
+                            {
+                    state = ESCAPE;
+                            }
+                            else                                               // normal character
+                                {
+                                    if (count < sizeof(buf) - 1)
+                                    {
+                        // register character in command buffer
+                                            buf[count] = c;
+                                            count++;
+                        // echo character
+                        putchar( c );
+                                        }
+                                }
-                                else if (c == '\n')      // new line => call parser to execute command
+                                {
-                                        if (count > 0)
+                                        {
-                                                // complete command
-                                                buf[count] = '\0';
-                                                // register command in log arrays
-                                                strcpy(log_entries[ptw].buf, buf);
-                                                log_entries[ptw].count = count;
-                                                ptw = (ptw + 1) % LOG_DEPTH;
-                                                ptr = ptw;
-                                                // execute command
-                                                printf("\n");
-                                                parse((char *)&buf);
-                                                // reinitialise buffer and display prompt
-                                                for ( i = 0 ; i < sizeof(buf) ; i++ ) buf[i] = 0x20;
-                                                count = 0;
-                                                printf("# ");
+                                        }
-                    else
+                    {
-                        printf("\n# ");
+                    }
+                                }
-                                else if (c == '\t')     // tabulation => do nothing
+                                {
+                                }
-                                else if (c == (char)0x1B)       // ESC => start an escape sequence
+                                {
-                                        state = ESCAPE;
+                                }
-                                else                                     // register character in command buffer
+                                {
-                                        if (count < sizeof(buf) - 1)
+                                        {
-                                                putchar( c );
-                                                buf[count] = c;
-                                                count++;
+                                        }
+                                }
-                                break;
+                        }
                         case ESCAPE:
+                        else if( state == ESCAPE )
+                        {
                                 if (c == '[')           //  valid sequence => continue
 …
                                         state = NORMAL;
+                                }
-                                break;
+                        }
                         case BRAKET:
+                        else if( state == BRAKET )
+                        {
                                 if (c == 'D')   // valid  LEFT sequence => move buf pointer left
 …
                                         state = NORMAL;
+                                }
-                                break;
+                        }
+                }
+        }
+                }  // end internal while loop on characters
+        }  // end external while loop on commands
 }  // end interactive()
 …
     unsigned int lid;             // core identifier for this KSH main thread
     int          status;          // child process termination status
+    int          pid;             // chils process identifier
+    int          child_pid;       // child process identifier
+    int          parent_pid;      // parent process identifier
     pthread_t    trdid;           // kernel allocated index for interactive thread
+    unsigned int is_owner;        // non-zero if KSH process is TXT owner
     // initialize log buffer
 …
         ptr   = 0;
+    // get KSH process pid and core
+    parent_pid = getpid();
     get_core( &cxy , & lid );
         printf( "\n\n~~~ KSH on core[%x,%d] ~~~\n\n", cxy , lid );
+    // initializes the semaphore used to unblock the interactive thread
+    sem_init( &semaphore , 0 , 1 );
     // initialize interactive thread attributes
 …
     while( 1 )
+    {
         pid = wait( &status );
+#if 0
+        if     ( WIFEXITED  (status) ) printf("\n[KSH] process %x exited\n" , pid );
         else if( WIFSIGNALED(status) ) printf("\n[KSH] process %x killed\n" , pid );
         else if( WIFSTOPPED (status) ) printf("\n[KSH] process %x stopped\n", pid );
+        else                           printf("\n[KSH] process %x strange\n", pid );
+        // wait children termination
+        child_pid = wait( &status );
+#if KSH_DEBUG
+if( WIFEXITED  (status) ) printf("\n[KSH] child process %x exited\n" , child_pid );
+if( WIFSIGNALED(status) ) printf("\n[KSH] child process %x killed\n" , child_pid );
+if( WIFSTOPPED (status) ) printf("\n[KSH] child process %x stopped\n", child_pid );
 #endif
+        // release semaphore if KSH process is TXT owner, to unblock interactive thread
+        is_fg( parent_pid , &is_owner );
+        if( is_owner ) sem_post( &semaphore );
+    }
 }  // end main()

trunk/user/sort/sort.c

-                      r445
+                      r457
 #define DISPLAY_ARRAY       0
 #define INTERACTIVE_MODE    1
+#define INTERACTIVE_MODE    0
 ///////////////////////////////////////////////////////
 …
 #if INTERACTIVE_MODE
 // idbg();
+idbg();
 #endif
+            }

Context Navigation

Legend: