Changeset 457


Ignore:
Timestamp:
Aug 2, 2018, 11:47:13 AM (6 years ago)
Author:
alain
Message:

This version modifies the exec syscall and fixes a large number of small bugs.
The version number has been updated (0.1)

Location:
trunk
Files:
243 edited

Legend:

Unmodified
Added
Removed

  • trunk/Makefile

    r444 r457  
    9090        $(MAKE) -C $(LIBC_PATH) clean
    9191        $(MAKE) -C $(LIBPTHREAD_PATH) clean
     92        $(MAKE) -C $(LIBSEMAPHORE_PATH) clean
    9293        $(MAKE) -C $(LIBALMOSMKH_PATH) clean
    9394        $(MAKE) -C user/init clean
    … …  
    136137        $(MAKE) -C $(LIBALMOSMKH_PATH) headers
    137138        $(MAKE) -C $(LIBPTHREAD_PATH) headers
     139        $(MAKE) -C $(LIBSEMAPHORE_PATH) headers
    138140        $(MAKE) -C $(LIBC_PATH)
    139141        $(MAKE) -C $(LIBALMOSMKH_PATH)
    140142        $(MAKE) -C $(LIBPTHREAD_PATH)
     143        $(MAKE) -C $(LIBSEMAPHORE_PATH)
    141144
    142145#####################################################################
    … …  
    146149        dd if=$@ of=$(DISK_IMAGE) seek=2 conv=notrunc
    147150
    148 #####################################################################
    149 # Rule to generate boot.elf and place it in sector #2 of virtual disk
     151######################################################
     152# Rule to generate HAL objects (depending on HAL_ARCH)
    150153build_hal:
    151154        $(MAKE) -C $(HAL_ARCH)

  • trunk/boot/tsar_mips32/Makefile

    r439 r457  
    5959                                                                boot_utils.h      \
    6060                                                                boot_config.h     \
    61                                                                 $(HAL_ARCH)/core/hal_types.h        \
     61                                                                $(HAL_ARCH)/core/hal_kernel_types.h        \
    6262                                                                ../../hard_config.h
    6363        $(CC) $(BOOT_INCLUDE) $(CFLAGS) -c -o $@ $<
    … …  
    6868                                                                boot_utils.h      \
    6969                                                                boot_config.h     \
    70                                                                 $(HAL_ARCH)/core/hal_types.h        \
     70                                                                $(HAL_ARCH)/core/hal_kernel_types.h        \
    7171                                                                ../../hard_config.h
    7272        $(CC) $(BOOT_INCLUDE) $(CFLAGS) -c -o $@ $<
    … …  
    7777                                                                boot_utils.h      \
    7878                                                                boot_config.h     \
    79                                                                 $(HAL_ARCH)/core/hal_types.h        \
     79                                                                $(HAL_ARCH)/core/hal_kernel_types.h        \
    8080                                                                ../../hard_config.h
    8181        $(CC) $(BOOT_INCLUDE) $(CFLAGS) -c -o $@ $<
    … …  
    8686                                                                boot_utils.h      \
    8787                                                                boot_config.h     \
    88                                                                 $(HAL_ARCH)/core/hal_types.h        \
     88                                                                $(HAL_ARCH)/core/hal_kernel_types.h        \
    8989                                                                ../../hard_config.h
    9090        $(CC) $(BOOT_INCLUDE) $(CFLAGS) -c -o $@ $<
    … …  
    9797                                                                boot_utils.h      \
    9898                                                                boot_config.h     \
    99                                                                 $(HAL_ARCH)/core/hal_types.h        \
     99                                                                $(HAL_ARCH)/core/hal_kernel_types.h        \
    100100                                                                ../../hard_config.h                     
    101101        $(CC) $(BOOT_INCLUDE) $(CFLAGS) -c -o $@ $<
    … …  
    107107                                                                boot_utils.h       \
    108108                                                                boot_tty_driver.h  \
    109                                                                 $(HAL_ARCH)/core/hal_types.h         \
     109                                                                $(HAL_ARCH)/core/hal_kernel_types.h         \
    110110                                                                ../../hard_config.h
    111111        $(CC) $(BOOT_INCLUDE) $(CFLAGS) -c -o $@ $<
    … …  
    122122                                                                boot_mmc_driver.h  \
    123123                                                                boot_config.h      \
    124                                                                 $(HAL_ARCH)/core/hal_types.h         \
     124                                                                $(HAL_ARCH)/core/hal_kernel_types.h         \
    125125                                                                ../../hard_config.h                             
    126126        $(CC) $(BOOT_INCLUDE) $(CFLAGS) $(MACROS) -c -o $@ $<

  • trunk/boot/tsar_mips32/boot.c

    r439 r457  
    7070
    7171#include <elf-types.h>
    72 #include <hal_types.h>
     72#include <hal_kernel_types.h>
    7373
    7474#include <kernel_config.h>

  • trunk/boot/tsar_mips32/boot_bdv_driver.h

    r439 r457  
    1919#define BOOT_BDV_DRIVER_H
    2020
    21 #include <hal_types.h>
     21#include <hal_kernel_types.h>
    2222
    2323/****************************************************************************

  • trunk/boot/tsar_mips32/boot_fat32.h

    r439 r457  
    318318 ****************************************************************************/
    319319
    320 #include <hal_types.h>
     320#include <hal_kernel_types.h>
    321321
    322322typedef struct fat_desc_s

  • trunk/boot/tsar_mips32/boot_hba_driver.h

    r439 r457  
    2727#define BOOT_HBA_DRIVER_H
    2828
    29 #include <hal_types.h>
     29#include <hal_kernel_types.h>
    3030
    3131/****************************************************************************

  • trunk/boot/tsar_mips32/boot_mmc_driver.h

    r439 r457  
    1313#define _GIET_MMC_DRIVERS_H_
    1414
    15 #include <hal_types.h>
     15#include <hal_kernel_types.h>
    1616
    1717///////////////////////////////////////////////////////////////////////////////////

  • trunk/boot/tsar_mips32/boot_tty_driver.c

    r439 r457  
    2424#include <boot_config.h>
    2525#include <boot_tty_driver.h>
    26 #include <hal_types.h>
     26#include <hal_kernel_types.h>
    2727#include <boot_utils.h>
    2828

  • trunk/boot/tsar_mips32/boot_tty_driver.h

    r439 r457  
    3333#define BOOT_TTY_DRIVER_H
    3434
    35 #include <hal_types.h>
     35#include <hal_kernel_types.h>
    3636
    3737/****************************************************************************

  • trunk/boot/tsar_mips32/boot_utils.c

    r439 r457  
    2525
    2626#include <boot_tty_driver.h>
    27 #include <hal_types.h>
     27#include <hal_kernel_types.h>
    2828#include <boot_utils.h>
    2929

  • trunk/boot/tsar_mips32/boot_utils.h

    r439 r457  
    4141#define _BOOT_UTILS_H
    4242
    43 #include <hal_types.h>
     43#include <hal_kernel_types.h>
    4444#include <hard_config.h>
    4545

  • trunk/hal/generic/hal_atomic.h

    r408 r457  
    2626
    2727#include <kernel_config.h>
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929
    3030//////////////////////////////////////////////////////////////////////////////////////////

  • trunk/hal/generic/hal_context.h

    r408 r457  
    4343 * identified by the <thread> argument. The context is not initialised.
    4444 ****************************************************************************************
     45 * @ thread  : pointer on the thread descriptor.
    4546 * @ return 0 if success / return -1 if failure.
    4647 ***************************************************************************************/
    … …  
    4849
    4950/****************************************************************************************
    50  * This function allocates memory for a CPU context, initialize it from scratch,
    51  * and links it to the thread identified by the <thread> argument.
     51 * This function initializes a CPU context from scratch.
    5252 ****************************************************************************************
    5353 * @ thread  : pointer on the thread descriptor.
    54  * @ return 0 if success / return -1 if failure.
    5554 ***************************************************************************************/
    56 error_t hal_cpu_context_create( struct thread_s * thread );
     55void hal_cpu_context_init( struct thread_s * thread );
    5756
    5857/****************************************************************************************
    … …  
    7170
    7271/****************************************************************************************
     72 * This function is used to implement the exec() system call.
     73 * 1) It initialize the relevant slots of the the calling thread CPU context.
     74 * 2) It call the hal_do_cpu_restore() function to return to user mode and start
     75 *    execution of the new process.
     76 ****************************************************************************************
     77 * @ thread  : pointer on the thread descriptor.
     78 ***************************************************************************************/
     79void hal_cpu_context_exec( struct thread_s * thread );
     80
     81/****************************************************************************************
    7382 * This function display some slots of the CPU context.
    74  * - For the MIPS32 :
    75  *   . GPR : gp_28 , sp_29 , ra_31
    76  *   . CP0 : c0_sr , c0_th , c0_epc
    77  *   . CP2 : c2_ptpr , c2-mode
    78  * - For X86 TODO :
    7983 ****************************************************************************************
    8084 * @ thread_xp  : extended pointer on the thread descriptor.
    … …  
    103107 ***************************************************************************************/
    104108error_t hal_fpu_context_alloc( struct thread_s * thread );
     109
     110/****************************************************************************************
     111 * This function initializes a FPU context from scratch.
     112 ****************************************************************************************
     113 * @ thread  : pointer on the thread descriptor.
     114 ***************************************************************************************/
     115void hal_fpu_context_init( struct thread_s * thread );
    105116
    106117/****************************************************************************************

  • trunk/hal/generic/hal_exception.h

    r455 r457  
    2525#define _HAL_EXCEPTION_H_
    2626
    27 #include <hal_types.h>
     27#include <hal_kernel_types.h>
    2828
    2929//////////////////////////////////////////////////////////////////////////////////////////

  • trunk/hal/generic/hal_gpt.h

    r432 r457  
    2525#define _GPT_H_
    2626
    27 #include <hal_types.h>
     27#include <hal_kernel_types.h>
    2828
    2929/////////////////////////////////////////////////////////////////////////////////////////

  • trunk/hal/generic/hal_interrupt.h

    r408 r457  
    2525#define _HAL_INTERRUPT_H_
    2626
    27 #include <hal_types.h>
     27#include <hal_kernel_types.h>
    2828
    2929///////////////////////////////////////////////////////////////////////////////////////

  • trunk/hal/generic/hal_irqmask.h

    r279 r457  
    2626#define  _HAL_IRQMASK_H_
    2727
    28 #include <hal_types.h>
     28#include <hal_shared_types.h>
    2929
    3030

  • trunk/hal/generic/hal_ppm.h

    r409 r457  
    2626#define _HAL_PPM_H_
    2727
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929#include <boot_info.h>
    3030

  • trunk/hal/generic/hal_remote.h

    r407 r457  
    2626#define  _HAL_REMOTE_H_
    2727
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929
    3030//////////////////////////////////////////////////////////////////////////////////////////

  • trunk/hal/generic/hal_special.h

    r408 r457  
    2525#define  _HAL_CPU_H_
    2626
    27 #include <hal_types.h>
     27#include <hal_shared_types.h>
     28#include <hal_kernel_types.h>
    2829
    2930/****  Forward declarations  ***/

  • trunk/hal/generic/hal_switch.h

    r408 r457  
    2828
    2929/*************************************************************************************
    30  * The hal_do_cpu_switch() function is an assembly level function, called by the
    31  * sched_yield() function, to make a CPU context switch.
    32  * The current thread CPU context is identified by the <ctx_current> pointer.
    33  * The new thread CPU context is identified by the <ctx_next> pointer.
     30 * This assembly level function is called by the sched_yield() function,
     31 * to make a CPU context switch.
     32 * The current thread CPU context is identified by the <ctx_old> pointer.
     33 * The new thread CPU context is identified by the <ctx_new> pointer.
    3434 * The architecture specific hal_cpu_context_t structure used to store a CPU context
    3535 * is defined in the architecture specific hal_context.c file.
    … …  
    4545
    4646/*************************************************************************************
    47  * The hal_do_cpu_save() function is an assembly level function, called by the
    48  * hal_cpu_context_save() functio to save the calling CPU register values to a
    49  * CPU context identified by the <ctx> pointer.
     47 * This assembly level function is called by the hal_cpu_context_fork() function.
     48 * It save the calling CPU register values to a CPU context identified by <ctx>.
    5049 * This function does NOT modify any register before saving values into context.
    5150 * The architecture specific hal_cpu_context_t structure used to store a CPU context
    … …  
    5756void hal_do_cpu_save( void * ctx );
    5857
     58/*************************************************************************************
     59 * This assembly level function, is called by the hal_cpu_context_exec() function.
     60 * It restore the calling CPU register values from a CPU context identified by <ctx>.
     61 * The architecture specific hal_cpu_context_t structure used to store a CPU context
     62 * is defined in the architecture specific hal_context.c file.
     63 * When the restore is completed, it simply jumps to the address contained in ra_31.
     64 * In ALMOS-MKH, ra_31 must contain a pointer on the eret() function, and c0_epc
     65 * must contain the new main thread entry point.
     66 *************************************************************************************
     67 * @ ctx     : local pointer on CPU context.
     68 ************************************************************************************/
     69void hal_do_cpu_restore( void * ctx );
     70
    5971#endif  /* _HAL_SWITCH_H_ */

  • trunk/hal/generic/hal_syscall.h

    r408 r457  
    2525#define _HAL_KERNEL_SYSCALL_H_
    2626
    27 #include <hal_types.h>
     27#include <hal_kernel_types.h>
    2828
    2929///////////////////////////////////////////////////////////////////////////////////////

  • trunk/hal/generic/hal_user.h

    r445 r457  
    2525#define _HAL_USER_H_
    2626
    27 #include <hal_types.h>
     27#include <hal_shared_types.h>
    2828
    2929//////////////////////////////////////////////////////////////////////////////////////////

  • trunk/hal/generic/hal_uspace.h

    r407 r457  
    2525#define  _HAL_USPACE_H_
    2626
    27 #include <hal_types.h>
     27#include <hal_kernel_types.h>
    2828
    2929//////////////////////////////////////////////////////////////////////////////////////////

  • trunk/hal/generic/hal_vmm.h

    r411 r457  
    2525#define _HAL_PPM_H_
    2626
    27 #include <hal_types.h>
     27#include <hal_kernel_types.h>
    2828#include <boot_info.h>
    2929

  • trunk/hal/tsar_mips32/Makefile

    r444 r457  
    7272                                $(HAL_ARCH)/drivers/%.h      \
    7373                                $(KERNEL)/kernel_config.h    \
    74                                 $(HAL_ARCH)/core/hal_types.h
     74                                $(HAL_ARCH)/core/hal_kernel_types.h
    7575        $(CC) $(HAL_INCLUDE) $(CFLAGS)  -c -o $@ $<
    7676
    … …  
    8080                                $(HAL)/generic/%.h           \
    8181                                $(KERNEL)/kernel_config.h    \
    82                                 $(HAL_ARCH)/core/hal_types.h
     82                                $(HAL_ARCH)/core/hal_kernel_types.h
    8383        $(CC) $(HAL_INCLUDE) $(CFLAGS) -c -o $@ $<
    8484
    … …  
    8686                                      $(HAL_ARCH)/core/hal_kentry.h \
    8787                                      $(KERNEL)/kernel_config.h     \
    88                                       $(HAL_ARCH)/core/hal_types.h
     88                                      $(HAL_ARCH)/core/hal_kernel_types.h
    8989        $(CC) $(HAL_INCLUDE) $(CFLAGS) -c -o $@ $<
    9090

  • trunk/hal/tsar_mips32/core/hal_atomic.c

    r62 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525
    2626////////////////////////////////////

  • trunk/hal/tsar_mips32/core/hal_context.c

    r432 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <hal_switch.h>
    2626#include <memcpy.h>
    … …  
    136136}   // end hal_cpu_context_alloc()
    137137
    138 ///////////////////////////////////////////////////
    139 // The following context slots are initialised :
     138/////////////////////////////////////////////////
     139// The following context slots are initialised
    140140// GPR : a0_04 / sp_29 / ra_31
    141141// CP0 : c0_sr / c0_th / c0_epc
    142142// CP2 : c2_ptpr / c2_mode
    143 ///////////////////////////////////////////////////
    144 error_t hal_cpu_context_create( thread_t * thread )
    145 {
    146     // allocate memory for a CPU context
    147     error_t error = hal_cpu_context_alloc( thread );
    148 
    149     if( error ) return error;
    150 
     143/////////////////////////////////////////////////
     144void hal_cpu_context_init( thread_t * thread )
     145{
    151146    hal_cpu_context_t * context = (hal_cpu_context_t *)thread->cpu_context;
     147
     148    assert( (context != NULL ), __FUNCTION__, "CPU context not allocated" );
    152149
    153150    // initialisation depends on thread type
    … …  
    173170        context->c2_mode = 0x3;
    174171    }
    175 
    176     return 0;
    177 
    178 }  // end hal_cpu_context_create()
     172}  // end hal_cpu_context_init()
    179173
    180174////////////////////////////////////////////
    … …  
    243237        assert( (current == child_ptr) , __FUNCTION__ , "current = %x / child = %x\n");
    244238    }
    245 
    246239}  // end hal_cpu_context_fork()
     240
     241//////////////////////////////////////////////
     242void hal_cpu_context_exec( thread_t * thread )
     243{
     244    // re_initialize CPU context
     245    hal_cpu_context_init( thread );
     246
     247    // restore CPU registers ... and jump
     248    hal_do_cpu_restore( (hal_cpu_context_t *)thread->cpu_context );
     249
     250} // end hal_cpu_context_exec()
    247251
    248252/////////////////////////////////////////////////
    … …  
    312316
    313317}   // end hal_fpu_context_alloc()
     318
     319//////////////////////////////////////////////
     320void hal_fpu_context_init( thread_t * thread )
     321{
     322    hal_fpu_context_t * context = thread->fpu_context;
     323
     324    assert( (context != NULL) , __FUNCTION__ , "fpu context not allocated" );
     325
     326    memset( context , 0 , sizeof(hal_fpu_context_t) );
     327}
    314328
    315329//////////////////////////////////////////

  • trunk/hal/tsar_mips32/core/hal_drivers.c

    r407 r457  
    2020 */
    2121
    22 #include <hal_types.h>
     22#include <hal_kernel_types.h>
    2323#include <chdev.h>
    2424#include <hal_drivers.h>

  • trunk/hal/tsar_mips32/core/hal_exception.c

    r440 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <hal_irqmask.h>
    2626#include <hal_special.h>
    … …  
    134134        core_t   * core = this->core;
    135135
    136     // enable FPU
     136    // enable FPU (in core SR)
    137137        hal_fpu_enable();
    138138
    139     // save FPU context in current owner thread if required
     139    // save FPU register values in current owner thread if required
    140140        if( core->fpu_owner != NULL )
    141141    {
    142142        if( core->fpu_owner != this )
    143143            {
     144            // save the FPU registers to current owner thread context
    144145                    hal_fpu_context_save( XPTR( local_cxy , core->fpu_owner ) );
     146
     147            // restore FPU registers from requesting thread context
     148                hal_fpu_context_restore( this->fpu_context );
     149
     150            // attach the FPU to the requesting thread
     151                core->fpu_owner = this;
    145152        }
    146153        }
    147 
    148     // attach the FPU to the requesting thread
    149         hal_fpu_context_restore( this->fpu_context );
    150         core->fpu_owner = this;
     154    else
     155    {
     156        // restore FPU registers from requesting thread context
     157            hal_fpu_context_restore( this->fpu_context );
     158
     159        // attach the FPU to the requesting thread
     160            core->fpu_owner = this;
     161    }
    151162
    152163        return EXCP_NON_FATAL;
    … …  
    206217uint32_t cycle = (uint32_t)hal_get_cycles();
    207218if( DEBUG_HAL_EXCEPTIONS < cycle )
    208 printk("\n[DBG] %s : thread %x enter / is_ins %d / %s / vaddr %x / cycle %d\n",
    209 __FUNCTION__, this, is_ins, hal_mmu_exception_str(excp_code), bad_vaddr, cycle );
     219printk("\n[DBG] %s : thread %x in process %x enter / is_ins %d / %s / vaddr %x / cycle %d\n",
     220__FUNCTION__, this->trdid, process->pid, is_ins, hal_mmu_exception_str(excp_code), bad_vaddr, cycle);
    210221#endif
    211222
    … …  
    235246cycle = (uint32_t)hal_get_cycles();
    236247if( DEBUG_HAL_EXCEPTIONS < cycle )
    237 printk("\n[DBG] %s : thread %x exit / page-fault handled for vaddr = %x\n",
    238 __FUNCTION__ , this , bad_vaddr );
     248printk("\n[DBG] %s : thread %x in process %x exit / page-fault handled for vaddr = %x\n",
     249__FUNCTION__, this->trdid, process->pid, bad_vaddr );
    239250#endif
    240251 
    … …  
    275286cycle = (uint32_t)hal_get_cycles();
    276287if( DEBUG_HAL_EXCEPTIONS < cycle )
    277 printk("\n[DBG] %s : thread %x exit / copy-on-write handled for vaddr = %x\n",
    278 __FUNCTION__ , this , bad_vaddr );
     288printk("\n[DBG] %s : thread %x in process %x exit / copy-on-write handled for vaddr = %x\n",
     289__FUNCTION__, this->trdid, process->pid, bad_vaddr );
    279290#endif
    280291
    … …  
    300311        {
    301312            assert( false , __FUNCTION__ ,
    302             "thread %x / core[%x,%d] / epc %x / vaddr %x / cycle %d\n",
    303             this, local_cxy, this->core->lid, excPC, bad_vaddr, (uint32_t)hal_get_cycles() );
     313            "thread %x in process %x / core[%x,%d] / epc %x / vaddr %x / cycle %d\n",
     314            this->trdid, this->process->pid, local_cxy, this->core->lid,
     315            excPC, bad_vaddr, (uint32_t)hal_get_cycles() );
    304316
    305317            return EXCP_KERNEL_PANIC;
    … …  
    398410uint32_t cycle = (uint32_t)hal_get_cycles();
    399411if( DEBUG_HAL_EXCEPTIONS < cycle )
    400 printk("\n[DBG] %s : thread %x enter / core[%x,%d] / pid %x / epc %x / xcode %x / cycle %d\n",
    401 __FUNCTION__, this, local_cxy, this->core->lid, this->process->pid, excPC, excCode, cycle );
     412printk("\n[DBG] %s : thread %x in process %x enter / core[%x,%d] / epc %x / xcode %x / cycle %d\n",
     413__FUNCTION__, this->trdid, this->process->pid, local_cxy, this->core->lid, excPC, excCode, cycle );
    402414#endif
    403415
    … …  
    458470cycle = (uint32_t)hal_get_cycles();
    459471if( DEBUG_HAL_EXCEPTIONS < cycle )
    460 printk("\n[DBG] %s : thread %x exit / core[%x,%d] / pid %x / epc %x / xcode %x / cycle %d\n",
    461 __FUNCTION__, this, local_cxy, this->core->lid, this->process->pid, excPC, excCode, cycle );
     472printk("\n[DBG] %s : thread %x in process %x exit / core[%x,%d] / epc %x / xcode %x / cycle %d\n",
     473__FUNCTION__, this->trdid, this->process->pid, local_cxy, this->core->lid, excPC, excCode, cycle );
    462474#endif
    463475

  • trunk/hal/tsar_mips32/core/hal_gpt.c

    r445 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <hal_gpt.h>
    2626#include <hal_special.h>

  • trunk/hal/tsar_mips32/core/hal_interrupt.c

    r435 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <hal_special.h>
    2626#include <kernel_config.h>

  • trunk/hal/tsar_mips32/core/hal_irqmask.c

    r285 r457  
    2323 */
    2424
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
     26#include <hal_shared_types.h>
    2627
    2728//////////////////////////////////////////

  • trunk/hal/tsar_mips32/core/hal_ppm.c

    r443 r457  
    2323
    2424#include <kernel_config.h>
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <hal_ppm.h>
    2727#include <hal_special.h>

  • trunk/hal/tsar_mips32/core/hal_remote.c

    r313 r457  
    2323 */
    2424
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <hal_irqmask.h>
    2727

  • trunk/hal/tsar_mips32/core/hal_special.c

    r425 r457  
    2323
    2424
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <hal_special.h>
    2727#include <core.h>

  • trunk/hal/tsar_mips32/core/hal_switch.S

    r408 r457  
    2626    .global  hal_do_cpu_switch
    2727    .global  hal_do_cpu_save
     28    .global  hal_do_cpu_restore
    2829
    2930    .set     noat
    … …  
    9091        sw      $27,  33*4($26)           /* save c2_mode to slot 33 */
    9192
     93    sync                           
     94
    9295    /* restore new thread context */
    9396 
    … …  
    144147        mtc2    $27,  $1                   /* restore c2_mode from slot 33 */
    145148    mtc0        $26,  $12                  /* restore c0_sr from slot 34 */
    146 
    147     sync                           
    148149
    149150    jr      $31                        /* return to caller */
    … …  
    211212    nop
    212213
     214#---------------------------------------------------------------------------------
     215# The hal_do_cpu_restore()function makes the following assumption:
     216# - register $4 contains a pointer on the target thread context.
     217#---------------------------------------------------------------------------------
     218hal_do_cpu_restore:
     219
     220    move    $26,  $4                  /* $26 <= &context */
     221
     222    lw      $27,   0*4($26)         
     223    mtc0    $27,   $14                 /* restore C0_epc from slot 0 */
     224
     225    lw      $1,    1*4($26)         
     226    lw      $2,    2*4($26)         
     227    lw      $3,    3*4($26)         
     228    lw      $4,    4*4($26)         
     229    lw      $5,    5*4($26)         
     230    lw      $6,    6*4($26)         
     231    lw      $7,    7*4($26)         
     232    lw      $8,    8*4($26)         
     233    lw      $9,    9*4($26)         
     234    lw      $10,  10*4($26)         
     235    lw      $11,  11*4($26)         
     236    lw      $12,  12*4($26)         
     237    lw      $13,  13*4($26)         
     238    lw      $14,  14*4($26)         
     239    lw      $15,  15*4($26)         
     240        lw      $16,  16*4($26)         
     241        lw      $17,  17*4($26)         
     242    lw      $18,  18*4($26)         
     243    lw      $19,  19*4($26)         
     244    lw      $20,  20*4($26)         
     245    lw      $21,  21*4($26)         
     246    lw      $22,  22*4($26)         
     247    lw      $23,  23*4($26)         
     248    lw      $24,  24*4($26)         
     249    lw      $25,  25*4($26)         
     250
     251    lw      $27,  26*4($26)         
     252    mthi    $27                        /* restore hi from slot 26 */
     253    lw      $27,  27*4($26)         
     254    mtlo    $27                        /* restore lo from slot 27 */
     255
     256        lw      $28,  28*4($26)         
     257        lw      $29,  29*4($26)         
     258        lw      $30,  30*4($26)         
     259        lw      $31,  31*4($26)            /* restore ra from slot 31 */
     260
     261        lw      $27,  32*4($26)
     262        mtc2    $27,  $0                   /* restore c2_ptpr from slot 32 */
     263
     264        lw      $27,  35*4($26)     
     265    mtc0        $27,  $4, 2                /* restore c0_th from slot 35 */
     266
     267        lw      $27,  33*4($26)
     268        lw      $26,  34*4($26)
     269
     270        mtc2    $27,  $1                   /* restore c2_mode from slot 33 */
     271    mtc0        $26,  $12                  /* restore c0_sr from slot 34 */
     272
     273    jr      $31                        /* return to caller */
     274    nop
     275
    213276        .set reorder                   
    214277    .set at                         

  • trunk/hal/tsar_mips32/core/hal_syscall.c

    r425 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <hal_syscall.h>
    2626#include <do_syscall.h>
    … …  
    4848    enter_uzone = (uint32_t *)this->uzone_current;
    4949
    50 //printk("\n@@@ enter %s : thread = %x / enter_uzone = %x / EPC = %x\n",
    51 //__FUNCTION__ , this , enter_uzone , enter_uzone[UZ_EPC] );
    52 
    5350    // get syscall arguments from uzone
    5451        service_num = enter_uzone[UZ_V0];
    … …  
    7168    exit_uzone = (uint32_t *)this->uzone_current;
    7269
    73 //printk("\n@@@ exit %s : thread = %x / exit_uzone = %x / EPC = %x\n",
    74 //__FUNCTION__ , this , exit_uzone , exit_uzone[UZ_EPC] );
    75 
    7670    // set return value to uzone
    7771        exit_uzone[UZ_V0] = retval;

  • trunk/hal/tsar_mips32/core/hal_uspace.c

    r425 r457  
    2525#include <errno.h>
    2626#include <vmm.h>
    27 #include <hal_types.h>
     27#include <hal_kernel_types.h>
    2828#include <hal_uspace.h>
    2929#include <hal_irqmask.h>

  • trunk/hal/tsar_mips32/core/hal_vmm.c

    r411 r457  
    2323
    2424#include <kernel_config.h>
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <hal_vmm.h>
    2727#include <hal_gpt.h>

  • trunk/hal/tsar_mips32/drivers/soclib_pic.c

    r451 r457  
    137137#endif
    138138
    139     // analyse status and handle up to 3 pending IRQ (one WTI, one HWI, one PTI)
     139    // analyse status and handle up to 3 pending IRQs (one WTI, one HWI, one PTI)
    140140
    141141    if( wti_status )          // pending WTI
    … …  
    150150#if DEBUG_HAL_IRQS
    151151if (DEBUG_HAL_IRQS < cycle )
    152 printk("\n[DBG] %s : core[%x,%d] received an IPI\n", __FUNCTION__ , local_cxy , core->lid );
     152printk("\n[DBG] %s : core[%x,%d] handling IPI\n", __FUNCTION__ , local_cxy , core->lid );
    153153#endif
    154154            // acknowledge IRQ (this require an XCU read)
    … …  
    156156
    157157            // check RPC FIFO,  and activate or create a RPC thread
    158             // condition is always true, but we must use the ack value
     158            // condition is always true, but we use the ack value
     159            // to avoid a GCC warning
    159160            if( ack + 1 ) rpc_check();
    160161        }
    … …  
    182183#if DEBUG_HAL_IRQS
    183184if (DEBUG_HAL_IRQS < cycle )
    184 printk("\n[DBG] %s : core[%x,%d] received external WTI %d\n",
     185printk("\n[DBG] %s : core[%x,%d] handling external WTI %d\n",
    185186__FUNCTION__ , local_cxy , core->lid , index );
    186187#endif
    … …  
    216217#if DEBUG_HAL_IRQS
    217218if (DEBUG_HAL_IRQS < cycle )
    218 printk("\n[DBG] %s : core[%x,%d] received HWI %d\n",
     219printk("\n[DBG] %s : core[%x,%d] handling HWI %d\n",
    219220__FUNCTION__ , local_cxy , core->lid , index );
    220221#endif
    … …  
    232233#if DEBUG_HAL_IRQS
    233234if (DEBUG_HAL_IRQS < cycle )
    234 printk("\n[DBG] %s : core[%x,%d] received PTI %d\n",
     235printk("\n[DBG] %s : core[%x,%d] handling PTI %d\n",
    235236__FUNCTION__ , core->lid , local_cxy , index );
    236237#endif
    … …  
    239240
    240241        // execute all actions related to TICK event
    241         // condition is always true, but we must use the ack value
     242        // condition is always true, but we use the ack value
     243        // to avoid a GCC warning
    242244        if( ack + 1 ) core_clock( core );
    243245        }
    … …  
    515517{
    516518    // calling core local index
    517     lid_t  lid = CURRENT_CORE->lid;
     519    lid_t  lid = CURRENT_THREAD->core->lid;
    518520
    519521    // get XCU segment base
    … …  
    533535{
    534536    // calling core local index
    535     lid_t  lid = CURRENT_CORE->lid;
     537    lid_t  lid = CURRENT_THREAD->core->lid;
    536538
    537539    // get XCU segment base

  • trunk/hal/tsar_mips32/drivers/soclib_tty.c

    r451 r457  
    272272    xptr_t       parent_main_xp;    // local pointer on parent process main thread
    273273
    274     // get TXT chdev channel, direction and server thread
     274    // get TXT chdev channel, direction, server thread, and server core
    275275    channel    = chdev->channel;
    276276    is_rx      = chdev->is_rx;
    … …  
    455455                thread_unblock( XPTR( local_cxy , server ) , THREAD_BLOCKED_ISR );
    456456
    457                 // send IPI to core running server thread
    458                 dev_pic_send_ipi( local_cxy , server_lid );
     457                // send IPI to core running server thread if required
     458                if( server_lid != CURRENT_THREAD->core->lid )
     459                {
     460                    dev_pic_send_ipi( local_cxy , server_lid );
     461                }
    459462            }
    460463            else
    … …  
    501504        thread_unblock( XPTR( local_cxy , server ) , THREAD_BLOCKED_ISR );
    502505
    503         // send IPI to core running server thread
    504         dev_pic_send_ipi( local_cxy , server_lid );
     506        // send IPI to core running server thread if required
     507        if( server_lid != CURRENT_THREAD->core->lid )
     508        {
     509            dev_pic_send_ipi( local_cxy , server_lid );
     510        }
    505511
    506512    }  // end TX

  • trunk/hal/tsar_mips32/drivers/soclib_tty.h

    r436 r457  
    22 * soclib_tty.c - soclib tty driver definition.
    33 *
    4  * Author  Alain Greiner (2016)
     4 * Author  Alain Greiner (2016,2017,2018)
    55 *
    66 * Copyright (c)  UPMC Sorbonne Universites
    … …  
    2929/****************************************************************************************
    3030 * This driver supports the vci_tty_tsar component.
    31  * It implements the generic TXT device API:
     31 * Regarding read/write request, it implements the generic TXT device API:
    3232 * - transfer one single character from TTY to command "buffer" if to_mem is non-zero.
    3333 * - transfer "count" characters from command "buffer" to TTY if "to_mem is zero.
     34 * It handles asynchronous control characters (^C / ^Z), that are translated to signals
     35 * transmited to the TXT owner process (foreground process).
    3436 ***************************************************************************************/
    3537
    … …  
    101103/****************************************************************************************
    102104 * This ISR is executed to handle both the TTY_TX_IRQ and the TTY_RX_IRQ, even if
    103  *   The RX_IRQ is activated as soon as the TTY_STATUS_RX_FULL bit is 1 in the
     105 * there is two different channel devices for TX and RX transfers.
     106 *
     107 * As the <chdev> argument is a local pointer, this ISR is always executed by a core
     108 * that is in the same cluster as the core running the DEV server thread.
     109 *
     110 * - The RX_IRQ is activated as soon as the TTY_STATUS_RX_FULL bit is 1 in the
    104111 *   TTY_STATUS register, when the TTY_RX_IRQ_ENABLE is non zero, indicating that
    105112 *   the TTY_READ buffer is full and can be read.
    106  *   The TX_IRQ is activated as soon as the TTY_STATUS_TX_FULL bit is 0 in the
     113 * - The TX_IRQ is activated as soon as the TTY_STATUS_TX_FULL bit is 0 in the
    107114 *   TTY_STATUS register, when the TTY_TX_IRQ_ENABLE is non zero, indicating that
    108115 *   the TTY_WRITE buffer is empty, and can be written.
    109  * WARNING : In ALMOS-MKH, the RX_IRQ is always enabled to catch the control signals,
     116 *
     117 * The RX_IRQ is always enabled to catch the control characters (^Z / ^C),
    110118 * but the TX_IRQ is dynamically enabled by the TXT_WRITE command, and disabled when
    111119 * the command is completed.
    112120 *
    113  * 1) The ISR first read the TTY_STATUS to get the current state of the TTY_READ and
    114  *   the TTY_WRITE buffers.
     121 * For normal characters The ISR uses two private TTY_RX and TTY_TX software FIFOs
     122 * (two FIFOs per channel) to communicates with the DEV server thread executing the
     123 * soclib_tty_cmd() function.
     124
     125 * For an RX transfer, this ISR executes a while loop moving bytes until the source
     126 * TTY_READ buffer is empty:
     127 *   1) The ISR read one byte from the TTY_READ register and acknowledge the RX_IRQ.
     128 *   2) if the byte is a ^Z character, it uses a multicast RPC to block all treads of
     129 *      the TXT owner process, and transfer TXT ownership to another process of the group.
     130 *   3) if the byte is a ^C character, it removes the process from the TXT group, and send
     131 *      a multicast RPC to delete all threads of the TXT owner process.
     132 *   4) if the byte is a normal character and the destination TTY_RX_FIFO is not full,
     133 *      it writes the byte to this FIFO, unblock the TXT_RX server thread, and send an IPI
     134 *      to this server thread (only if it is running on another core than the ISR).
     135 *   5) It discards the byte if the TTY_RX_FIFO is full, with a warning message on TXT0.
    115136 *
    116  * 2) It try to read the first command registered in the server thread queue associated
    117  *    to the TTY channel
    118  *
    119  * 2) The ISR handles the RX when the TTY_READ buffer is full :
    120  *   . it read the available character from the TTY_READ buffer, and this
    121  *     acknowledges the RX_IRQ.
    122  *   . if it is a control character ( ^C / ^D / ^Z ) it translate it to the proper
    123  *     signal and execute the relevant sigaction for the foreground process.
    124  *   . if it is a normal character, it try to get the first command registered in the
    125  *     server thread queue. If it is a TXT_READ, it returns this character to the
    126  *     command buffer in the client thread.
    127  *
    128  * 3) The ISR handles the TX when the TTY_WRITE buffer is empty and a TXT_WRITE
    129  *   . it try to get it copies the
    130  *     character to the command buffer, acknowledges the TTY_RX_IRQ, and unblock the
    131  *     associated server thread.
    132      
    133  *   . the control characters ^C / ^D / ^Z  are directly handled by the ISR and
    134  *     translated to the foreground process.
    135 
    136  * - the
    137  the TXT_READ and TXT_WRITE commands.
    138  * It gets the command arguments from the first client thread in the TXT chdev queue:
    139  * - if TXT_READ, it transfers one byte from the TTY_READ_REG to the command buffer.
    140  *   It simply returns for retry if TTY_READ_REG is empty.
    141  * - if TXT_WRITE, it tries to transfer several bytes from the command buffer to the
    142  *   TTY_WRITE_REG. If the TTY_WRITE_REG is full, it updates the "count" and "buffer"
    143  *   command arguments and returns for retry.
    144  * When the I/O operation is completed, it sets the status field in the command, unblocks
    145  * the server thread, and unblocks the client thread.
     137 * For a TX transfer, this ISR executes a while loop moving bytes until the source
     138 * TTY_TX_FIFO is empty:
     139 *   1) if the destination TTY_WRITE register is not full, it moves the byte from the
     140 *      TTY_TX_FIFO to the TTY_WRITE register.
     141 *   2) if the TTY_WRITE register is full, it polls (busy waiting) the TTY_STATUS register,
     142 *      until the TTY_WRITE register is empty.
     143 *   3) when the source TTY_TX_FIFO is empty, this ISR disable the TTY_TX_IRQ, unblock
     144 *      the TXT_TX server thread, and send an IPI to this server thread (only if it is
     145 *      running on another core than the ISR).
    146146 ****************************************************************************************
    147147 * @ chdev     : local pointer on TXT chdev descriptor.

  • trunk/hal/x86_64/Makefile

    r444 r457  
    7272                                drivers/%.h \
    7373                                $(KERNEL)/kernel_config.h             \
    74                                 core/hal_types.h
     74                                core/hal_kernel_types.h
    7575        $(CC) $(HAL_INCLUDE) $(CFLAGS)  -c -o $@ $<
    7676
    … …  
    8080                                $(HAL)/generic/%.h             \
    8181                                $(KERNEL)/kernel_config.h             \
    82                                 core/hal_types.h
     82                                core/hal_kernel_types.h
    8383        $(CC) $(HAL_INCLUDE) $(CFLAGS) -c -o $@ $<
    8484
    … …  
    8888                                core/hal_segmentation.h \
    8989                                $(KERNEL)/kernel_config.h              \
    90                                 core/hal_types.h
     90                                core/hal_kernel_types.h
    9191        $(CC) $(HAL_INCLUDE) $(CFLAGS) -c -o $@ $<
    9292
    … …  
    9696                                core/hal_segmentation.h \
    9797                                $(KERNEL)/kernel_config.h              \
    98                                 core/hal_types.h
     98                                core/hal_kernel_types.h
    9999        $(CC) $(HAL_INCLUDE) $(CFLAGS) -c -o $@ $<
    100100
    … …  
    107107                                core/hal_internal.h     \
    108108                                $(KERNEL)/kernel_config.h               \
    109                                 core/hal_types.h
     109                                core/hal_kernel_types.h
    110110        $(CC) $(HAL_INCLUDE) $(CFLAGS) -c -o $@ $<
    111111
    … …  
    114114                                core/hal_segmentation.h \
    115115                                $(KERNEL)/kernel_config.h              \
    116                                 core/hal_types.h
     116                                core/hal_kernel_types.h
    117117        $(CC) $(HAL_INCLUDE) $(CFLAGS) -c -o $@ $<
    118118
    … …  
    121121                                core/hal_boot.h        \
    122122                                $(KERNEL)/kernel_config.h              \
    123                                 core/hal_types.h
     123                                core/hal_kernel_types.h
    124124        $(CC) $(HAL_INCLUDE) $(CFLAGS) -c -o $@ $<
    125125
    … …  
    127127                                core/hal_acpi.h        \
    128128                                $(KERNEL)/kernel_config.h              \
    129                                 core/hal_types.h
     129                                core/hal_kernel_types.h
    130130        $(CC) $(HAL_INCLUDE) $(CFLAGS) -c -o $@ $<
    131131
    … …  
    133133                                core/hal_apic.h        \
    134134                                $(KERNEL)/kernel_config.h              \
    135                                 core/hal_types.h
     135                                core/hal_kernel_types.h
    136136        $(CC) $(HAL_INCLUDE) $(CFLAGS) -c -o $@ $<
    137137
    138138$(HAL_ARCH)/build/core/x86_printf.o:  core/x86_printf.c      \
    139139                                $(KERNEL)/kernel_config.h              \
    140                                 core/hal_types.h
     140                                core/hal_kernel_types.h
    141141        $(CC) $(HAL_INCLUDE) $(CFLAGS) -c -o $@ $<
    142142

  • trunk/hal/x86_64/core/hal_acpi.c

    r348 r457  
    2020 */
    2121
    22 #include <hal_types.h>
     22#include <hal_kernel_types.h>
    2323#include <hal_boot.h>
    2424#include <hal_acpi.h>

  • trunk/hal/x86_64/core/hal_apic.c

    r327 r457  
    2020 */
    2121
    22 #include <hal_types.h>
     22#include <hal_kernel_types.h>
    2323#include <hal_boot.h>
    2424#include <hal_register.h>

  • trunk/hal/x86_64/core/hal_atomic.c

    r234 r457  
    2020 */
    2121
    22 #include <hal_types.h>
     22#include <hal_kernel_types.h>
    2323#include <hal_internal.h>
    2424

  • trunk/hal/x86_64/core/hal_context.c

    r368 r457  
    2020 */
    2121
    22 #include <hal_types.h>
     22#include <hal_kernel_types.h>
    2323#include <memcpy.h>
    2424#include <thread.h>

  • trunk/hal/x86_64/core/hal_drivers.c

    r346 r457  
    2020 */
    2121
    22 #include <hal_types.h>
     22#include <hal_kernel_types.h>
    2323#include <chdev.h>
    2424#include <hal_drivers.h>

  • trunk/hal/x86_64/core/hal_exception.c

    r403 r457  
    2020 */
    2121
    22 #include <hal_types.h>
     22#include <hal_kernel_types.h>
    2323#include <hal_irqmask.h>
    2424#include <hal_exception.h>

  • trunk/hal/x86_64/core/hal_gpt.c

    r408 r457  
    2020 */
    2121
    22 #include <hal_types.h>
     22#include <hal_kernel_types.h>
    2323#include <hal_boot.h> /* XXX */
    2424#include <hal_gpt.h>

  • trunk/hal/x86_64/core/hal_init.c

    r365 r457  
    2020 */
    2121
    22 #include <hal_types.h>
     22#include <hal_kernel_types.h>
    2323#include <hal_boot.h>
    2424#include <hal_multiboot.h>

  • trunk/hal/x86_64/core/hal_interrupt.c

    r344 r457  
    2020 */
    2121
    22 #include <hal_types.h>
     22#include <hal_kernel_types.h>
    2323#include <kernel_config.h>
    2424#include <thread.h>

  • trunk/hal/x86_64/core/hal_irqmask.c

    r370 r457  
    2020 */
    2121
    22 #include <hal_types.h>
     22#include <hal_kernel_types.h>
    2323#include <hal_internal.h>
    2424#include <hal_segmentation.h>

  • trunk/hal/x86_64/core/hal_ppm.c

    r407 r457  
    2121
    2222#include <kernel_config.h>
    23 #include <hal_types.h>
     23#include <hal_kernel_types.h>
    2424#include <hal_ppm.h>
    2525#include <hal_special.h>

  • trunk/hal/x86_64/core/hal_remote.c

    r314 r457  
    2020 */
    2121
    22 #include <hal_types.h>
     22#include <hal_kernel_types.h>
    2323#include <hal_internal.h>
    2424

  • trunk/hal/x86_64/core/hal_special.c

    r371 r457  
    2020 */
    2121
    22 #include <hal_types.h>
     22#include <hal_kernel_types.h>
    2323#include <hal_apic.h>
    2424#include <hal_special.h>

  • trunk/hal/x86_64/core/hal_syscall.c

    r145 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <hal_syscall.h>
    2626#include <do_syscall.h>

  • trunk/hal/x86_64/core/hal_types.h

    r407 r457  
    11/*
    2  * hal_types.h - common kernel types for x86_64
     2 * hal_kernel_types.h - common kernel types for x86_64
    33 *
    44 * Author  Alain Greiner (2016)

  • trunk/hal/x86_64/core/hal_uspace.c

    r407 r457  
    2323 */
    2424
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <hal_uspace.h>
    2727#include <hal_irqmask.h>

  • trunk/hal/x86_64/core/x86_printf.c

    r242 r457  
    2020 */
    2121
    22 #include <hal_types.h>
     22#include <hal_kernel_types.h>
    2323#include <hal_boot.h>
    2424#include <hal_internal.h>

  • trunk/hal/x86_64/drivers/ioc_ata.h

    r215 r457  
    2424
    2525#include <chdev.h>
    26 #include <hal_types.h>
     26#include <hal_kernel_types.h>
    2727
    2828void ioc_ata_init(chdev_t *chdev);

  • trunk/hal/x86_64/drivers/pic_apic.c

    r404 r457  
    2020 */
    2121
    22 #include <hal_types.h>
     22#include <hal_kernel_types.h>
    2323#include <chdev.h>
    2424#include <pic_apic.h>

  • trunk/hal/x86_64/drivers/pic_apic.h

    r280 r457  
    2323#define _PIC_APIC_H_
    2424
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626
    2727void pic_apic_init(chdev_t *pic);

  • trunk/kernel/Makefile

    r444 r457  
    177177              build/syscalls/sys_thread_wakeup.o   \
    178178              build/syscalls/sys_trace.o           \
    179               build/syscalls/sys_fg.o
     179              build/syscalls/sys_fg.o              \
     180              build/syscalls/sys_is_fg.o
    180181
    181182VFS_OBJS    = build/fs/vfs.o              \
    … …  
    228229                        kern/%.h                      \
    229230                        kernel_config.h               \
    230                         $(HAL_ARCH)/core/hal_types.h
     231                        $(HAL_ARCH)/core/hal_kernel_types.h
    231232        $(CC) $(KERNEL_INCLUDE) $(CFLAGS) -c -o $@ $<
    232233
    … …  
    237238                        devices/%.h                   \
    238239                        kernel_config.h               \
    239                         $(HAL_ARCH)/core/hal_types.h
     240                        $(HAL_ARCH)/core/hal_kernel_types.h
    240241        $(CC) $(KERNEL_INCLUDE) $(CFLAGS) -c -o $@ $<
    241242
    … …  
    245246                        mm/%.h                        \
    246247                        kernel_config.h               \
    247                         $(HAL_ARCH)/core/hal_types.h
     248                        $(HAL_ARCH)/core/hal_kernel_types.h
    248249        $(CC) $(KERNEL_INCLUDE) $(CFLAGS) -c -o $@ $<
    249250
    … …  
    253254                        libk/%.h                      \
    254255                        kernel_config.h               \
    255                         $(HAL_ARCH)/core/hal_types.h
     256                        $(HAL_ARCH)/core/hal_kernel_types.h
    256257        $(CC) $(KERNEL_INCLUDE) $(CFLAGS) -c -o $@ $<
    257258
    … …  
    261262                        syscalls/syscalls.h           \
    262263                        kernel_config.h               \
    263                         $(HAL_ARCH)/core/hal_types.h
     264                        $(HAL_ARCH)/core/hal_kernel_types.h
    264265        $(CC) $(KERNEL_INCLUDE) $(CFLAGS) -c -o $@ $<
    265266
    … …  
    269270                        fs/%.h                        \
    270271                        kernel_config.h               \
    271                         $(HAL_ARCH)/core/hal_types.h
     272                        $(HAL_ARCH)/core/hal_kernel_types.h
    272273        $(CC) $(KERNEL_INCLUDE) $(CFLAGS) -c -o $@ $<
    273274

  • trunk/kernel/devices/dev_dma.c

    r437 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <hal_special.h>
    2626#include <chdev.h>

  • trunk/kernel/devices/dev_dma.h

    r437 r457  
    2626
    2727#include <kernel_config.h>
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929#include <spinlock.h>
    3030

  • trunk/kernel/devices/dev_fbf.c

    r440 r457  
    2323
    2424#include <kernel_config.h>
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <hal_gpt.h>
    2727#include <thread.h>

  • trunk/kernel/devices/dev_fbf.h

    r188 r457  
    2525#define _DEV_FBF_H
    2626
    27 #include <hal_types.h>
     27#include <hal_kernel_types.h>
    2828
    2929/****  Forward declarations  ****/

  • trunk/kernel/devices/dev_iob.c

    r422 r457  
    2323
    2424#include <kernel_config.h>
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <hal_special.h>
    2727#include <remote_spinlock.h>

  • trunk/kernel/devices/dev_iob.h

    r346 r457  
    2626
    2727#include <kernel_config.h>
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929#include <spinlock.h>
    3030

  • trunk/kernel/devices/dev_ioc.c

    r440 r457  
    2323
    2424#include <kernel_config.h>
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <hal_gpt.h>
    2727#include <hal_drivers.h>

  • trunk/kernel/devices/dev_ioc.h

    r437 r457  
    2626
    2727#include <kernel_config.h>
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929
    3030/****  Forward declarations  ****/

  • trunk/kernel/devices/dev_mmc.c

    r440 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <hal_special.h>
    2626#include <hal_drivers.h>

  • trunk/kernel/devices/dev_mmc.h

    r440 r457  
    2626
    2727#include <kernel_config.h>
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929#include <spinlock.h>
    3030

  • trunk/kernel/devices/dev_nic.c

    r438 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <hal_special.h>
    2626#include <printk.h>

  • trunk/kernel/devices/dev_nic.h

    r437 r457  
    2626
    2727#include <kernel_config.h>
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929
    3030/*****************************************************************************************

  • trunk/kernel/devices/dev_pic.c

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

  • trunk/kernel/devices/dev_pic.h

    r437 r457  
    2626
    2727#include <kernel_config.h>
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929
    3030/*****************************************************************************************

  • trunk/kernel/devices/dev_txt.c

    r438 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <hal_special.h>
    2626#include <hal_remote.h>

  • trunk/kernel/devices/dev_txt.h

    r435 r457  
    2626
    2727#include <kernel_config.h>
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929#include <xlist.h>
    3030#include <remote_spinlock.h>

  • trunk/kernel/fs/devfs.c

    r438 r457  
    2323 */
    2424
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <hal_special.h>
    2727#include <hal_uspace.h>
    … …  
    9999#endif
    100100
    101     // creates DEVFS "dev" inode in cluster IO
    102     error = vfs_add_child_in_parent( LOCAL_CLUSTER->io_cxy,
     101    // creates DEVFS "dev" inode in cluster 0
     102    error = vfs_add_child_in_parent( 0,                // cxy
    103103                                     INODE_TYPE_DIR,
    104104                                     FS_TYPE_DEVFS,
    … …  
    115115#endif
    116116
    117     // create DEVFS "external" inode in cluster IO
    118     error = vfs_add_child_in_parent( LOCAL_CLUSTER->io_cxy,
     117    // create DEVFS "external" inode in cluster 0
     118    error = vfs_add_child_in_parent( 0,               // cxy
    119119                                     INODE_TYPE_DIR,
    120120                                     FS_TYPE_DEVFS,

  • trunk/kernel/fs/fatfs.c

    r440 r457  
    2323
    2424
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <hal_special.h>
    2727#include <printk.h>

  • trunk/kernel/fs/fatfs.h

    r407 r457  
    2626#define _FATFS_H_
    2727
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929#include <rwlock.h>
    3030#include <vfs.h>

  • trunk/kernel/fs/ramfs.c

    r188 r457  
    2424
    2525
    26 #include <hal_types.h>
     26#include <hal_kernel_types.h>
    2727#include <hal_special.h>
    2828#include <printk.h>

  • trunk/kernel/fs/vfs.c

    r441 r457  
    2525
    2626#include <kernel_config.h>
    27 #include <hal_types.h>
     27#include <hal_kernel_types.h>
    2828#include <hal_atomic.h>
    2929#include <hal_special.h>

  • trunk/kernel/fs/vfs.h

    r437 r457  
    2727
    2828#include <kernel_config.h>
    29 #include <hal_types.h>
     29#include <hal_kernel_types.h>
    3030#include <hal_atomic.h>
    3131#include <remote_rwlock.h>

  • trunk/kernel/kern/chdev.c

    r450 r457  
    2323
    2424#include <kernel_config.h>
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <hal_special.h>
    2727#include <hal_remote.h>
    … …  
    127127    xptr_t     server_xp;     // extended pointer on server thread
    128128    core_t   * core_ptr;      // local pointer on core running the server thread
    129     uint32_t   lid;           // core running the server thread local index
     129    uint32_t   server_lid;    // core running the server thread local index
    130130    xptr_t     lock_xp;       // extended pointer on lock protecting the chdev queue
    131     uint32_t   different;     // non zero if server thread core != client thread core
    132131    uint32_t   save_sr;       // for critical section
    133132
    … …  
    154153
    155154    // get server core local index
    156     lid = hal_remote_lw( XPTR( chdev_cxy , &core_ptr->lid ) );
     155    server_lid = hal_remote_lw( XPTR( chdev_cxy , &core_ptr->lid ) );
    157156
    158157#if (DEBUG_CHDEV_CMD_RX || DEBUG_CHDEV_CMD_TX)
    … …  
    210209#endif
    211210
     211#if (DEBUG_CHDEV_CMD_RX & 1)
     212if( (is_rx) && (DEBUG_CHDEV_CMD_RX < rx_cycle) )
     213printk("\n[DBG] in %s : client thread %x blocked\n", __FUNCTION__, this );
     214#endif
     215
    212216    // unblock server thread if required
    213217    if( hal_remote_lw( blocked_xp ) & THREAD_BLOCKED_IDLE )
    … …  
    216220#if (DEBUG_CHDEV_CMD_TX & 1)
    217221if( (is_rx == 0) && (DEBUG_CHDEV_CMD_TX < tx_cycle) )
    218 {
    219 printk("\n[DBG] in %s : server thread %x unblocked\n", __FUNCTION__, server_ptr );
    220 chdev_queue_display( chdev_xp );
    221 }
     222printk("\n[DBG] in %s : TX server thread %x unblocked\n", __FUNCTION__, server_ptr );
     223#endif
     224
     225#if (DEBUG_CHDEV_CMD_RX & 1)
     226if( (is_rx) && (DEBUG_CHDEV_CMD_RX < rx_cycle) )
     227printk("\n[DBG] in %s : RX server thread %x unblocked\n", __FUNCTION__, server_ptr );
    222228#endif
    223229
    … …  
    227233#if (DEBUG_CHDEV_CMD_TX & 1)
    228234if( (is_rx == 0)  && (DEBUG_CHDEV_CMD_TX < tx_cycle) )
    229 {
    230235printk("\n[DBG] in %s : thread %x registered write request in chdev\n", __FUNCTION__, this );
    231 chdev_queue_display( chdev_xp );
    232 }
     236#endif
     237 
     238#if (DEBUG_CHDEV_CMD_RX & 1)
     239if( (is_rx)  && (DEBUG_CHDEV_CMD_RX < rx_cycle) )
     240printk("\n[DBG] in %s : thread %x registered read request in chdev\n", __FUNCTION__, this );
    233241#endif
    234242 
    235243    // send IPI to core running the server thread when server != client
    236     different = (lid != this->core->lid) || (local_cxy != chdev_cxy);
    237     if( different )
    238     {
    239         dev_pic_send_ipi( chdev_cxy , lid );
    240    
     244    if( (server_lid != this->core->lid) || (local_cxy != chdev_cxy) )
     245    {
     246        dev_pic_send_ipi( chdev_cxy , server_lid );
     247
    241248#if (DEBUG_CHDEV_CMD_TX & 1)
    242249if( (is_rx == 0)  && (DEBUG_CHDEV_CMD_TX < tx_cycle) )
    243 printk("\n[DBG] in %s : client thread %x sent IPI to server thread %x\n",
     250printk("\n[DBG] in %s : client thread %x sent IPI to TX server thread %x\n",
     251__FUNCTION__, this, server_ptr );
     252#endif
     253
     254#if (DEBUG_CHDEV_CMD_RX & 1)
     255if( (is_rx)  && (DEBUG_CHDEV_CMD_RX < rx_cycle) )
     256printk("\n[DBG] in %s : client thread %x sent IPI to RX server thread %x\n",
    244257__FUNCTION__, this, server_ptr );
    245258#endif

  • trunk/kernel/kern/chdev.h

    r450 r457  
    2626
    2727#include <kernel_config.h>
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929#include <xlist.h>
    3030#include <remote_spinlock.h>

  • trunk/kernel/kern/cluster.c

    r456 r457  
    123123
    124124#if( DEBUG_CLUSTER_INIT & 1 )
    125 uint32_t cycle = (uint32_t)hal_get_cycles();
     125cycle = (uint32_t)hal_get_cycles();
    126126if( DEBUG_CLUSTER_INIT < cycle )
    127127printk("\n[DBG] %s : KHM initialized in cluster %x at cycle %d\n",
    … …  
    133133
    134134#if( DEBUG_CLUSTER_INIT & 1 )
    135 uint32_t cycle = (uint32_t)hal_get_cycles();
     135cycle = (uint32_t)hal_get_cycles();
    136136if( DEBUG_CLUSTER_INIT < cycle )
    137137printk("\n[DBG] %s : KCM initialized in cluster %x at cycle %d\n",

  • trunk/kernel/kern/cluster.h

    r443 r457  
    2828
    2929#include <kernel_config.h>
    30 #include <hal_types.h>
     30#include <hal_kernel_types.h>
    3131#include <bits.h>
    3232#include <spinlock.h>

  • trunk/kernel/kern/core.c

    r443 r457  
    2424
    2525#include <kernel_config.h>
    26 #include <hal_types.h>
     26#include <hal_kernel_types.h>
    2727#include <hal_special.h>
    2828#include <errno.h>

  • trunk/kernel/kern/core.h

    r443 r457  
    2727
    2828#include <kernel_config.h>
    29 #include <hal_types.h>
     29#include <hal_kernel_types.h>
    3030#include <list.h>
    3131#include <rpc.h>
    … …  
    6565}
    6666core_t;
    67 
    68 /****************************************************************************************
    69  * This macro returns a pointer on the calling core descriptor.
    70  ***************************************************************************************/
    71 
    72 #define CURRENT_CORE  (CURRENT_THREAD->core)
    7367
    7468/***************************************************************************************

  • trunk/kernel/kern/do_interrupt.c

    r248 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <kernel_config.h>
    2626#include <thread.h>

  • trunk/kernel/kern/do_interrupt.h

    r16 r457  
    2727#define _DO_INTERRUPT_H_
    2828
    29 #include <hal_types.h>
     29#include <hal_kernel_types.h>
    3030#include <thread.h>
    3131

  • trunk/kernel/kern/do_syscall.c

    r443 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <hal_irqmask.h>
    2626#include <do_syscall.h>
    … …  
    102102    sys_trace,              // 47
    103103    sys_fg,                 // 48
    104     sys_undefined,          // 49
     104    sys_is_fg,              // 49
    105105};
    106106
    … …  
    160160        else if( index == SYS_TRACE          ) return "TRACE";            // 47
    161161        else if( index == SYS_FG             ) return "FG";               // 48
     162        else if( index == SYS_IS_FG          ) return "IS_FG";            // 49
    162163
    163164    else                                   return "undefined";   

  • trunk/kernel/kern/do_syscall.h

    r408 r457  
    2727#define _D0_SYSCALL_H_
    2828
    29 #include <hal_types.h>
     29#include <hal_kernel_types.h>
    3030#include <thread.h>
    3131

  • trunk/kernel/kern/dqdt.c

    r438 r457  
    2323
    2424#include <kernel_config.h>
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <hal_special.h>
    2727#include <hal_atomic.h>

  • trunk/kernel/kern/dqdt.h

    r438 r457  
    2626
    2727#include <kernel_config.h>
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929#include <hal_atomic.h>
    3030

  • trunk/kernel/kern/kernel_init.c

    r443 r457  
    2525#include <kernel_config.h>
    2626#include <errno.h>
    27 #include <hal_types.h>
     27#include <hal_kernel_types.h>
    2828#include <hal_special.h>
    2929#include <hal_context.h>
    … …  
    186186           "    /_/        \\_\\ |______| |_|    |_|   \\_____/  |______/        |_|    |_|  |_|  \\_\\ |_|   |_|  \n"
    187187           "\n\n\t\t Advanced Locality Management Operating System / Multi Kernel Hybrid\n"
    188            "\n\n\t\t Version 0.0 / %d cluster(s) / %d core(s) per cluster / cycle %d\n\n",
    189            nclusters , ncores , hal_time_stamp() );
     188           "\n\n\t\t %s / %d cluster(s) / %d core(s) per cluster\n\n",
     189           CONFIG_ALMOS_VERSION , nclusters , ncores );
    190190}
    191191
    … …  
    761761    reg_t        status;                    // running core status register
    762762
    763     cxy_t        io_cxy = info->io_cxy;
    764 
    765     assert( (io_cxy == ((info->x_size - 1)<<(info->y_width)) + (info->y_size - 1)) ,
    766     __FUNCTION__ , "illegal IO cluter identifier\n" );
    767 
    768763    /////////////////////////////////////////////////////////////////////////////////
    769764    // STEP 0 : Each core get its core identifier from boot_info, and makes
    … …  
    796791    thread->remote_locks = 0;
    797792
    798     // CP0 in I/O cluster initialises TXT0 chdev descriptor
    799     if( (core_lid == 0) && (core_cxy == io_cxy) ) txt0_device_init( info );
    800 
    801     /////////////////////////////////////////////////////////////////////////////////
    802     if( core_lid == 0 ) remote_barrier( XPTR( io_cxy , &global_barrier ),
     793    // CP0 in cluster 0 initialises TXT0 chdev descriptor
     794    if( (core_lid == 0) && (core_cxy == 0) ) txt0_device_init( info );
     795
     796    /////////////////////////////////////////////////////////////////////////////////
     797    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ),
    803798                                        (info->x_size * info->y_size) );
    804799    barrier_wait( &local_barrier , info->cores_nr );
    … …  
    838833
    839834    /////////////////////////////////////////////////////////////////////////////////
    840     if( core_lid == 0 ) remote_barrier( XPTR( io_cxy , &global_barrier ),
     835    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ),
    841836                                        (info->x_size * info->y_size) );
    842837    barrier_wait( &local_barrier , info->cores_nr );
    … …  
    865860   
    866861    ////////////////////////////////////////////////////////////////////////////////
    867     if( core_lid == 0 ) remote_barrier( XPTR( io_cxy , &global_barrier ),
     862    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ),
    868863                                        (info->x_size * info->y_size) );
    869864    barrier_wait( &local_barrier , info->cores_nr );
    … …  
    898893
    899894    /////////////////////////////////////////////////////////////////////////////////
    900     if( core_lid == 0 ) remote_barrier( XPTR( io_cxy , &global_barrier ),
     895    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ),
    901896                                        (info->x_size * info->y_size) );
    902897    barrier_wait( &local_barrier , info->cores_nr );
    … …  
    926921
    927922    // all cores initialize the idle thread descriptor
    928     error = thread_idle_init( thread,
    929                               THREAD_IDLE,
    930                               &thread_idle_func,
    931                               NULL,
    932                               core_lid );
    933     if( error )
    934     {
    935         assert( false , __FUNCTION__ ,
    936         "core[%x][%d] cannot initialize idle thread", local_cxy , core_lid );
    937     }
     923    thread_idle_init( thread,
     924                      THREAD_IDLE,
     925                      &thread_idle_func,
     926                      NULL,
     927                      core_lid );
    938928
    939929    // all cores unblock idle thread, and register it in scheduler
    … …  
    1008998
    1009999    /////////////////////////////////////////////////////////////////////////////////
    1010     if( core_lid == 0 ) remote_barrier( XPTR( io_cxy , &global_barrier ),
     1000    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ),
    10111001                                        (info->x_size * info->y_size) );
    10121002    barrier_wait( &local_barrier , info->cores_nr );
    … …  
    10691059
    10701060    /////////////////////////////////////////////////////////////////////////////////
    1071     if( core_lid == 0 ) remote_barrier( XPTR( io_cxy , &global_barrier ),
     1061    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ),
    10721062                                        (info->x_size * info->y_size) );
    10731063    barrier_wait( &local_barrier , info->cores_nr );
    … …  
    10761066#if DEBUG_KERNEL_INIT
    10771067if( (core_lid ==  0) & (local_cxy == 0) )
    1078 printk("\n[DBG] %s : exit barrier 5 : VFS_root = %l in cluster %x / cycle %d\n",
    1079 __FUNCTION__, vfs_root_inode_xp , io_cxy , (uint32_t)hal_get_cycles());
     1068printk("\n[DBG] %s : exit barrier 5 : VFS_root = %l in cluster 0 / cycle %d\n",
     1069__FUNCTION__, vfs_root_inode_xp , (uint32_t)hal_get_cycles());
    10801070#endif
    10811071
    … …  
    10861076    /////////////////////////////////////////////////////////////////////////////////
    10871077
    1088     if( (core_lid ==  0) && (local_cxy == io_cxy) )
     1078    if( (core_lid ==  0) && (local_cxy == 0) )
    10891079    {
    10901080        // create "dev" and "external" directories.
    … …  
    11041094
    11051095    /////////////////////////////////////////////////////////////////////////////////
    1106     if( core_lid == 0 ) remote_barrier( XPTR( io_cxy , &global_barrier ),
     1096    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ),
    11071097                                        (info->x_size * info->y_size) );
    11081098    barrier_wait( &local_barrier , info->cores_nr );
    … …  
    11111101#if DEBUG_KERNEL_INIT
    11121102if( (core_lid ==  0) & (local_cxy == 0) )
    1113 printk("\n[DBG] %s : exit barrier 6 : dev_root = %l in cluster %x / cycle %d\n",
    1114 __FUNCTION__, devfs_dev_inode_xp , io_cxy , (uint32_t)hal_get_cycles() );
     1103printk("\n[DBG] %s : exit barrier 6 : dev_root = %l in cluster 0 / cycle %d\n",
     1104__FUNCTION__, devfs_dev_inode_xp , (uint32_t)hal_get_cycles() );
    11151105#endif
    11161106
    … …  
    11251115    if( core_lid == 0 )
    11261116    {
    1127         // get extended pointer on "extend" field of VFS context for DEVFS in cluster IO
    1128         xptr_t  extend_xp = XPTR( io_cxy , &fs_context[FS_TYPE_DEVFS].extend );
    1129 
    1130         // get pointer on DEVFS context in cluster IO
     1117        // get extended pointer on "extend" field of VFS context for DEVFS in cluster 0
     1118        xptr_t  extend_xp = XPTR( 0 , &fs_context[FS_TYPE_DEVFS].extend );
     1119
     1120        // get pointer on DEVFS context in cluster 0
    11311121        devfs_ctx_t * devfs_ctx = hal_remote_lpt( extend_xp );
    11321122       
    1133         devfs_dev_inode_xp      = hal_remote_lwd( XPTR( io_cxy ,
    1134                                                         &devfs_ctx->dev_inode_xp ) );
    1135         devfs_external_inode_xp = hal_remote_lwd( XPTR( io_cxy ,
    1136                                                         &devfs_ctx->external_inode_xp ) );
     1123        devfs_dev_inode_xp      = hal_remote_lwd( XPTR( 0 , &devfs_ctx->dev_inode_xp ) );
     1124        devfs_external_inode_xp = hal_remote_lwd( XPTR( 0 , &devfs_ctx->external_inode_xp ) );
    11371125
    11381126        // populate DEVFS in all clusters
    … …  
    11431131
    11441132    /////////////////////////////////////////////////////////////////////////////////
    1145     if( core_lid == 0 ) remote_barrier( XPTR( io_cxy , &global_barrier ),
     1133    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ),
    11461134                                        (info->x_size * info->y_size) );
    11471135    barrier_wait( &local_barrier , info->cores_nr );
    … …  
    11581146    /////////////////////////////////////////////////////////////////////////////////
    11591147
    1160     if( (core_lid ==  0) && (local_cxy == 0) )
     1148    if( (core_lid == 0) && (local_cxy == 0) )
    11611149    {
    11621150
    … …  
    11691157
    11701158    /////////////////////////////////////////////////////////////////////////////////
    1171     if( core_lid == 0 ) remote_barrier( XPTR( io_cxy , &global_barrier ),
     1159    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ),
    11721160                                        (info->x_size * info->y_size) );
    11731161    barrier_wait( &local_barrier , info->cores_nr );
    … …  
    11891177    /////////////////////////////////////////////////////////////////////////////////
    11901178   
    1191     if( (core_lid ==  0) && (local_cxy == io_cxy) )
     1179    if( (core_lid == 0) && (local_cxy == 0) )
    11921180    {
    11931181        print_banner( (info->x_size * info->y_size) , info->cores_nr );

  • trunk/kernel/kern/printk.c

    r446 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <hal_irqmask.h>
    2626#include <hal_special.h>

  • trunk/kernel/kern/printk.h

    r437 r457  
    4141#define _PRINTK_H
    4242
    43 #include <hal_types.h>
     43#include <hal_kernel_types.h>
    4444#include <stdarg.h>
    4545

  • trunk/kernel/kern/process.c

    r450 r457  
    2525
    2626#include <kernel_config.h>
    27 #include <hal_types.h>
     27#include <hal_kernel_types.h>
    2828#include <hal_remote.h>
    2929#include <hal_uspace.h>
    … …  
    8989void process_reference_init( process_t * process,
    9090                             pid_t       pid,
    91                              xptr_t      parent_xp,
    92                              xptr_t      model_xp )
     91                             xptr_t      parent_xp )
    9392{
    9493    cxy_t       parent_cxy;
    9594    process_t * parent_ptr;
    96     cxy_t       model_cxy;
    97     process_t * model_ptr;
    9895    xptr_t      stdin_xp;
    9996    xptr_t      stdout_xp;
    … …  
    110107    chdev_t *   chdev_ptr;
    111108    cxy_t       chdev_cxy;
    112     pid_t       model_pid;
    113109    pid_t       parent_pid;
    114 
    115     // get model process cluster and local pointer
    116     model_cxy = GET_CXY( model_xp );
    117     model_ptr = GET_PTR( model_xp );
    118110
    119111    // get parent process cluster and local pointer
    … …  
    121113    parent_ptr = GET_PTR( parent_xp );
    122114
    123     // get model_pid and parent_pid
     115    // get parent_pid
    124116    parent_pid = hal_remote_lw( XPTR( parent_cxy , &parent_ptr->pid ) );
    125     model_pid  = hal_remote_lw( XPTR( model_cxy  , &model_ptr->pid ) );
    126117
    127118#if DEBUG_PROCESS_REFERENCE_INIT
    128119uint32_t cycle = (uint32_t)hal_get_cycles();
    129120if( DEBUG_PROCESS_REFERENCE_INIT )
    130 printk("\n[DBG] %s : thread %x enter / pid = %x / ppid = %x / model_pid = %x / cycle %d\n",
    131 __FUNCTION__ , CURRENT_THREAD , pid , parent_pid , model_pid , cycle );
     121printk("\n[DBG] %s : thread %x in process %x enter to initalialize process %x / cycle %d\n",
     122__FUNCTION__, CURRENT_THREAD->trdid, parent_pid , pid , cycle );
    132123#endif
    133124
    … …  
    146137cycle = (uint32_t)hal_get_cycles();
    147138if( DEBUG_PROCESS_REFERENCE_INIT )
    148 printk("\n[DBG] %s : thread %x / vmm empty for process %x / cycle %d\n",
    149 __FUNCTION__ , CURRENT_THREAD , pid , cycle );
     139printk("\n[DBG] %s : thread %x in process %x / vmm empty for process %x / cycle %d\n",
     140__FUNCTION__, CURRENT_THREAD->trdid, parent_pid , cycle );
    150141#endif
    151142
    … …  
    154145
    155146    // define the stdin/stdout/stderr pseudo files <=> select a TXT terminal.
    156     // - if INIT (pid == 1)         => link to kernel TXT[0]
    157     // - if KSH[i] (model_pid == 1) => allocate a free TXT[i]
    158     // - if USER process            => same terminal as model
    159 
    160     if( (pid == 1) || (model_pid == 1)) // INIT or KSH process
    161     {
    162         if (pid == 1 )  txt_id = 0;                    // INIT
    163         else            txt_id = process_txt_alloc();  // KSH[i]
    164 
    165         // attach process to TXT[txt_id]
     147    if( (pid == 1) || (parent_pid == 1)) // INIT or KSH process
     148    {
     149        // allocate a TXT channel
     150        if( pid == 1 )  txt_id = 0;                     // INIT
     151        else            txt_id = process_txt_alloc();   // KSH
     152
     153        // attach process to TXT
    166154        process_txt_attach( process , txt_id );
     155
     156#if (DEBUG_PROCESS_REFERENCE_INIT & 1)
     157cycle = (uint32_t)hal_get_cycles();
     158if( DEBUG_PROCESS_REFERENCE_INIT )
     159printk("\n[DBG] %s : thread %x in process %x / process %x attached to TXT%d / cycle %d\n",
     160__FUNCTION__, CURRENT_THREAD->trdid, parent_pid, pid, txt_id, cycle );
     161#endif
     162
     163
    167164
    168165        // build path to TXT_RX[i] and TXT_TX[i] chdevs
    … …  
    184181cycle = (uint32_t)hal_get_cycles();
    185182if( DEBUG_PROCESS_REFERENCE_INIT )
    186 printk("\n[DBG] %s : thread %x / stdin open for process %x / cycle %d\n",
    187 __FUNCTION__ , CURRENT_THREAD , pid , cycle );
     183printk("\n[DBG] %s : thread %x in process %x / stdin open for process %x / cycle %d\n",
     184__FUNCTION__, CURRENT_THREAD->trdid, parent_pid, pid, cycle );
    188185#endif
    189186
    … …  
    202199cycle = (uint32_t)hal_get_cycles();
    203200if( DEBUG_PROCESS_REFERENCE_INIT )
    204 printk("\n[DBG] %s : thread %x / stdout open for process %x / cycle %d\n",
    205 __FUNCTION__ , CURRENT_THREAD , pid , cycle );
     201printk("\n[DBG] %s : thread %x in process %x / stdout open for process %x / cycle %d\n",
     202__FUNCTION__, CURRENT_THREAD->trdid, parent_pid, pid, cycle );
    206203#endif
    207204
    … …  
    220217cycle = (uint32_t)hal_get_cycles();
    221218if( DEBUG_PROCESS_REFERENCE_INIT )
    222 printk("\n[DBG] %s : thread %x / stderr open for process %x / cycle %d\n",
    223 __FUNCTION__ , CURRENT_THREAD , pid , cycle );
     219printk("\n[DBG] %s : thread %x in process %x / stderr open for process %x / cycle %d\n",
     220__FUNCTION__, CURRENT_THREAD->trdid, parent_pid, pid, cycle );
    224221#endif
    225222
    … …  
    227224    else                                            // normal user process
    228225    {
    229         // get extended pointer on stdin pseudo file in model process
    230         file_xp = (xptr_t)hal_remote_lwd( XPTR( model_cxy , &model_ptr->fd_array.array[0] ) );
    231 
    232         // get extended pointer on model process TXT chdev
     226        // get extended pointer on stdin pseudo file in parent process
     227        file_xp = (xptr_t)hal_remote_lwd( XPTR( parent_cxy , &parent_ptr->fd_array.array[0] ) );
     228
     229        // get extended pointer on parent process TXT chdev
    233230        chdev_xp = chdev_from_file( file_xp );
    234231 
    … …  
    243240        process_txt_attach( process , txt_id );
    244241
    245         // copy all open files from model process fd_array to this process
     242        // copy all open files from parent process fd_array to this process
    246243        process_fd_remote_copy( XPTR( local_cxy , &process->fd_array ),
    247                                 XPTR( model_cxy , &model_ptr->fd_array ) );
     244                                XPTR( parent_cxy , &parent_ptr->fd_array ) );
    248245    }
    249246
    250247    // initialize specific inodes root and cwd
    251     process->vfs_root_xp = (xptr_t)hal_remote_lwd( XPTR( model_cxy,
    252                                                          &model_ptr->vfs_root_xp ) );
    253     process->vfs_cwd_xp  = (xptr_t)hal_remote_lwd( XPTR( model_cxy,
    254                                                          &model_ptr->vfs_cwd_xp ) );
     248    process->vfs_root_xp = (xptr_t)hal_remote_lwd( XPTR( parent_cxy,
     249                                                         &parent_ptr->vfs_root_xp ) );
     250    process->vfs_cwd_xp  = (xptr_t)hal_remote_lwd( XPTR( parent_cxy,
     251                                                         &parent_ptr->vfs_cwd_xp ) );
    255252    vfs_inode_remote_up( process->vfs_root_xp );
    256253    vfs_inode_remote_up( process->vfs_cwd_xp );
    … …  
    469466////////////////////////////////////////
    470467void process_sigaction( pid_t       pid,
    471                         uint32_t    action_type )
     468                        uint32_t    type )
    472469{
    473470    cxy_t              owner_cxy;         // owner cluster identifier
    … …  
    479476    xptr_t             process_xp;        // extended pointer on process copy
    480477    cxy_t              process_cxy;       // process copy cluster identifier
     478    process_t        * process_ptr;       // local pointer on process copy
    481479    reg_t              save_sr;           // for critical section
    482480    rpc_desc_t         rpc;               // shared RPC descriptor
    483 
    484     thread_t * client = CURRENT_THREAD;
     481    thread_t         * client;            // pointer on client thread
     482    xptr_t             client_xp;         // extended pointer on client thread
     483    process_t        * local;             // pointer on process copy in local cluster
     484    uint32_t           remote_nr;         // number of remote process copies
     485
     486    client    = CURRENT_THREAD;
     487    client_xp = XPTR( local_cxy , client );
     488    local     = NULL;
     489    remote_nr = 0;
    485490
    486491#if DEBUG_PROCESS_SIGACTION
    487492uint32_t cycle = (uint32_t)hal_get_cycles();
    488493if( DEBUG_PROCESS_SIGACTION < cycle )
    489 printk("\n[DBG] %s : thread %x enter to %s process %x / cycle %d\n",
    490 __FUNCTION__ , client, process_action_str( action_type ) , pid , cycle );
     494printk("\n[DBG] %s : thread %x in process %x enter to %s process %x / cycle %d\n",
     495__FUNCTION__ , client->trdid, client->process->pid,
     496process_action_str( type ) , pid , cycle );
    491497#endif
    492498
    … …  
    503509
    504510    // check action type
    505     assert( ((action_type == DELETE_ALL_THREADS ) ||
    506              (action_type == BLOCK_ALL_THREADS )  ||
    507              (action_type == UNBLOCK_ALL_THREADS )), __FUNCTION__ , "illegal action type" );
     511    assert( ((type == DELETE_ALL_THREADS ) ||
     512             (type == BLOCK_ALL_THREADS )  ||
     513             (type == UNBLOCK_ALL_THREADS )), __FUNCTION__ , "illegal action type" );
    508514             
    509     // allocate a - shared - RPC descriptor in client thread stack
    510     // it can be shared because all parallel, non-blocking, server threads
    511     // use the same input arguments, and use the shared RPC response field
    512 
    513     // the client thread makes the following sequence:
    514     // 1. mask interrupts
    515     // 2. block itself
    516     // 3. send RPC requests to all copies
    517     // 4. unmask interrupts
    518     // 5. deschedule
     515
     516    // The client thread send parallel RPCs to all remote clusters containing
     517    // target process copies, wait all responses, and then handles directly the
     518    // threads in local cluster, when required.
     519    // The client thread allocates a - shared - RPC descriptor in the stack,
     520    // because all parallel, non-blocking, server threads use the same input
     521    // arguments, and use the shared RPC response field
    519522
    520523    // mask IRQs
    521524    hal_disable_irq( &save_sr);
    522525
    523     // client register blocking condition for itself
    524     thread_block( XPTR( local_cxy , client ) , THREAD_BLOCKED_RPC );
     526    // client thread blocks itself
     527    thread_block( client_xp , THREAD_BLOCKED_RPC );
    525528
    526529    // take the lock protecting the copies
    … …  
    533536    rpc.thread    = client;
    534537    rpc.lid       = client->core->lid;
    535     rpc.args[0]   = action_type;
     538    rpc.args[0]   = type;
    536539    rpc.args[1]   = pid;
    537540
    538     // send RPCs to all clusters containing process copiess
     541    // scan list of process copies
     542    // to send RPCs to remote copies
    539543    XLIST_FOREACH( root_xp , iter_xp )
    540544    {
    541         // atomically increment responses counter
    542         hal_atomic_add( (void *)&rpc.responses , 1 );
    543 
     545        // get extended pointers and cluster on process
    544546        process_xp  = XLIST_ELEMENT( iter_xp , process_t , copies_list );
    545547        process_cxy = GET_CXY( process_xp );
     548        process_ptr = GET_PTR( process_xp );
     549
     550        if( process_cxy == local_cxy )    // process is local
     551        {
     552            local = process_ptr;
     553        }
     554        else                              // process is remote
     555        {
     556            // update number of remote process copies
     557            remote_nr++;
     558
     559            // atomically increment responses counter
     560            hal_atomic_add( (void *)&rpc.responses , 1 );
    546561
    547562#if DEBUG_PROCESS_SIGACTION
    548563if( DEBUG_PROCESS_SIGACTION < cycle )
    549 printk("\n[DBG] %s : send RPC to %s process %x in cluster %x\n",
    550 __FUNCTION__ , process_action_str( action_type ) , pid , process_cxy );
    551 #endif
    552         // call RPC in target cluster
    553         rpc_process_sigaction_client( process_cxy , &rpc );
    554     }
    555    
     564printk("\n[DBG] %s : thread %x in process %x handles remote process %x in cluster %x\n",
     565__FUNCTION__, client->trdid, client->process->pid, pid , process_cxy );
     566#endif
     567            // call RPC in target cluster
     568            rpc_process_sigaction_client( process_cxy , &rpc );
     569        }
     570    }  // end list of copies
     571
    556572    // release the lock protecting process copies
    557573    remote_spinlock_unlock( lock_xp );
    … …  
    560576    hal_restore_irq( save_sr);
    561577
    562     // client thread deschedule : will be unblocked by the last RPC server thread
    563     sched_yield("blocked on rpc_process_sigaction");
     578    // - if there is remote process copies, the client thread deschedules,
     579    //   (it will be unblocked by the last RPC server thread).
     580    // - if there is no remote copies, the client thread unblock itself.
     581    if( remote_nr )
     582    {
     583        sched_yield("blocked on rpc_process_sigaction");
     584    }
     585    else
     586    {
     587        thread_unblock( client_xp , THREAD_BLOCKED_RPC );
     588    }
     589
     590    // handle the local process copy if required
     591    if( local != NULL )
     592    {
     593
     594#if DEBUG_PROCESS_SIGACTION
     595if( DEBUG_PROCESS_SIGACTION < cycle )
     596printk("\n[DBG] %s : thread %x in process %x handles local process %x in cluster %x\n",
     597__FUNCTION__, client->trdid, client->process->pid, pid , local_cxy );
     598#endif
     599        if     (type == DELETE_ALL_THREADS  ) process_delete_threads ( local , client_xp );
     600        else if(type == BLOCK_ALL_THREADS   ) process_block_threads  ( local , client_xp );
     601        else if(type == UNBLOCK_ALL_THREADS ) process_unblock_threads( local );
     602    }
    564603
    565604#if DEBUG_PROCESS_SIGACTION
    566605cycle = (uint32_t)hal_get_cycles();
    567606if( DEBUG_PROCESS_SIGACTION < cycle )
    568 printk("\n[DBG] %s : thread %x exit after %s process %x in cluster %x / cycle %d\n",
    569 __FUNCTION__ , client, process_action_str( action_type ) , pid , local_cxy , cycle );
     607printk("\n[DBG] %s : thread %x in process %x exit after %s process %x / cycle %d\n",
     608__FUNCTION__, client->trdid, client->process->pid,
     609process_action_str( type ), pid, cycle );
    570610#endif
    571611
    … …  
    11001140uint32_t cycle = (uint32_t)hal_get_cycles();
    11011141if( DEBUG_PROCESS_MAKE_FORK < cycle )
    1102 printk("\n[DBG] %s : thread %x enter for process %x / cluster %x / cycle %d\n",
    1103 __FUNCTION__, CURRENT_THREAD, parent_pid, local_cxy, cycle );
     1142printk("\n[DBG] %s : thread %x in process %x enter / cluster %x / cycle %d\n",
     1143__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, local_cxy, cycle );
    11041144#endif
    11051145
    … …  
    11231163    }
    11241164
     1165#if DEBUG_PROCESS_MAKE_FORK
     1166cycle = (uint32_t)hal_get_cycles();
     1167if( DEBUG_PROCESS_MAKE_FORK < cycle )
     1168printk("\n[DBG] %s : thread %x in process %x allocated process %x / cycle %d\n",
     1169__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, new_pid, cycle );
     1170#endif
     1171
    11251172    // initializes child process descriptor from parent process descriptor
    11261173    process_reference_init( process,
    11271174                            new_pid,
    1128                             parent_process_xp,
    11291175                            parent_process_xp );
    11301176
    … …  
    11321178cycle = (uint32_t)hal_get_cycles();
    11331179if( DEBUG_PROCESS_MAKE_FORK < cycle )
    1134 printk("\n[DBG] %s : thread %x created child_process %x / child_pid %x / cycle %d\n",
    1135 __FUNCTION__, CURRENT_THREAD, process, new_pid, cycle );
    1136 #endif
     1180printk("\n[DBG] %s : thread %x in process %x initialized child_process %x / cycle %d\n",
     1181__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, new_pid, cycle );
     1182#endif
     1183
     1184    // give TXT ownership to child process
     1185    process_txt_set_ownership( XPTR( local_cxy , process ) );
    11371186
    11381187    // copy VMM from parent descriptor to child descriptor
    … …  
    11511200cycle = (uint32_t)hal_get_cycles();
    11521201if( DEBUG_PROCESS_MAKE_FORK < cycle )
    1153 printk("\n[DBG] %s : thread %x copied VMM from parent %x to child %x / cycle %d\n",
    1154 __FUNCTION__ , CURRENT_THREAD , parent_pid, new_pid, cycle );
    1155 #endif
     1202printk("\n[DBG] %s : thread %x in process %x copied VMM from parent %x to child %x / cycle %d\n",
     1203__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid,
     1204parent_pid, new_pid, cycle );
     1205#endif
     1206
     1207    // parent process gives TXT ownership to child process if required
     1208    if( process_txt_is_owner(parent_process_xp) )
     1209    {
     1210        process_txt_set_ownership( XPTR( local_cxy , process ) );
     1211
     1212#if( DEBUG_PROCESS_MAKE_FORK & 1 )
     1213cycle = (uint32_t)hal_get_cycles();
     1214if( DEBUG_PROCESS_MAKE_EXEC < cycle )
     1215printk("\n[DBG] %s : thread %x in process %x gives TXT from parent %x to child %x / cycle %d\n",
     1216__FUNCTION__ , CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid,
     1217parent_pid, new_pid, cycle );
     1218#endif
     1219
     1220    }
    11561221
    11571222    // update extended pointer on .elf file
    … …  
    11781243cycle = (uint32_t)hal_get_cycles();
    11791244if( DEBUG_PROCESS_MAKE_FORK < cycle )
    1180 printk("\n[DBG] %s : thread %x created child thread %x on core[%x,%d] / cycle %d\n",
    1181 __FUNCTION__ , CURRENT_THREAD, thread, local_cxy, thread->core->lid, cycle );
     1245printk("\n[DBG] %s : thread %x in process %x created main thread %x on core[%x,%d] / cycle %d\n",
     1246__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid,
     1247thread, local_cxy, thread->core->lid, cycle );
    11821248#endif
    11831249
    … …  
    12001266cycle = (uint32_t)hal_get_cycles();
    12011267if( DEBUG_PROCESS_MAKE_FORK < cycle )
    1202 printk("\n[DBG] %s : thread %x set COW in parent and child / cycle %d\n",
    1203 __FUNCTION__ , CURRENT_THREAD, cycle );
     1268printk("\n[DBG] %s : thread %x in process %x set COW in parent and child / cycle %d\n",
     1269__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, cycle );
    12041270#endif
    12051271
    … …  
    12221288cycle = (uint32_t)hal_get_cycles();
    12231289if( DEBUG_PROCESS_MAKE_FORK < cycle )
    1224 printk("\n[DBG] %s : thread %x exit / cycle %d\n",
    1225 __FUNCTION__, CURRENT_THREAD, cycle );
     1290printk("\n[DBG] %s : thread %x in process %x exit / created process %x / cycle %d\n",
     1291__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, new_pid, cycle );
    12261292#endif
    12271293
    … …  
    12291295
    12301296}   // end process_make_fork()
    1231 
    12321297
    12331298/////////////////////////////////////////////////////
    12341299error_t process_make_exec( exec_info_t  * exec_info )
    12351300{
    1236     char           * path;                    // pathname to .elf file
    1237     pid_t            pid;                     // old_process PID, given to new_process
    1238     pid_t            temp_pid;                // temporary PID / given to old_process
    1239     process_t      * old_process;             // local pointer on old process
    1240     thread_t       * old_thread;              // local pointer on old thread
    1241     process_t      * new_process;             // local pointer on new process
    1242     thread_t       * new_thread;              // local pointer on new thread
    1243     xptr_t           parent_xp;               // extended pointer on parent process
    1244     process_t      * parent_ptr;              // local pointer on parent process
    1245     cxy_t            parent_cxy;              // parent process cluster identifier
    1246     xptr_t           children_lock_xp;        // extended pointer on children lock in parent
    1247     xptr_t           children_root_xp;        // extended pointer on children root in parent
    1248     xptr_t           children_nr_xp;          // extended pointer on children number in parent
    1249     thread_t       * parent_main_ptr;         // local pointer on parent main thread
    1250     xptr_t           parent_main_xp;          // extended pointer on parent main thread
    1251     pthread_attr_t   attr;                    // new thread attributes
    1252     lid_t            lid;                     // selected core local index
     1301    thread_t       * thread;                  // local pointer on this thread
     1302    process_t      * process;                 // local pointer on this process
     1303    pid_t            pid;                     // this process identifier
    12531304        error_t          error;                   // value returned by called functions
    1254    
    1255     // get old_thread, old_process & PID
    1256     old_thread  = CURRENT_THREAD;
    1257     old_process = old_thread->process;
    1258     pid         = old_process->pid;
    1259 
    1260         // get .elf pathname from exec_info
    1261         path = exec_info->path;
    1262 
    1263     // this function must be executed by a thread running in owner cluster
    1264     assert( (CXY_FROM_PID( pid ) == local_cxy), __FUNCTION__,
    1265     "local_cluster must be owner_cluster\n" );
    1266 
    1267     assert( (LTID_FROM_TRDID( old_thread->trdid ) == 0) , __FUNCTION__,
    1268     "must be called by the main thread\n" );
    1269  
     1305    char           * path;                    // path to .elf file
     1306    xptr_t           file_xp;                 // extended pointer on .elf file descriptor
     1307    uint32_t         file_id;                 // file index in fd_array
     1308    uint32_t         args_nr;                 // number of main thread arguments
     1309    char          ** args_pointers;           // array of pointers on main thread arguments
     1310
     1311    // get thread, process & PID
     1312    thread  = CURRENT_THREAD;
     1313    process = thread->process;
     1314    pid     = process->pid;
     1315
     1316        // get relevant infos from exec_info
     1317        path          = exec_info->path;
     1318    args_nr       = exec_info->args_nr;
     1319    args_pointers = exec_info->args_pointers;
     1320
    12701321#if DEBUG_PROCESS_MAKE_EXEC
    12711322uint32_t cycle = (uint32_t)hal_get_cycles();
    12721323if( DEBUG_PROCESS_MAKE_EXEC < cycle )
    12731324printk("\n[DBG] %s : thread %x in process %x enters / path %s / cycle %d\n",
    1274 __FUNCTION__, old_thread->trdid, pid, path, cycle );
    1275 #endif
    1276 
    1277     // get parent process pointers
    1278     parent_xp   = old_process->parent_xp;
    1279     parent_cxy  = GET_CXY( parent_xp );
    1280     parent_ptr  = GET_PTR( parent_xp );
    1281    
     1325__FUNCTION__, thread->trdid, pid, path, cycle );
     1326#endif
     1327
     1328    // open the file identified by <path>
     1329    file_xp = XPTR_NULL;
     1330    file_id = -1;
     1331        error   = vfs_open( process,
     1332                            path,
     1333                            O_RDONLY,
     1334                            0,
     1335                            &file_xp,
     1336                            &file_id );
     1337        if( error )
     1338        {
     1339                printk("\n[ERROR] in %s : failed to open file <%s>\n", __FUNCTION__ , path );
     1340                return -1;
     1341        }
     1342
    12821343#if (DEBUG_PROCESS_MAKE_EXEC & 1)
    12831344if( DEBUG_PROCESS_MAKE_EXEC < cycle )
    1284 printk("\n[DBG] %s : thread %x in process %x get parent process %x in cluster %x\n",
    1285 __FUNCTION__, old_thread->trdid, pid, parent_ptr, parent_cxy );
    1286 #endif
    1287 
    1288     // get extended pointers on parent children_root, children_lock and children_nr
    1289     children_root_xp = XPTR( parent_cxy , &parent_ptr->children_root );
    1290     children_lock_xp = XPTR( parent_cxy , &parent_ptr->children_lock );
    1291     children_nr_xp   = XPTR( parent_cxy , &parent_ptr->children_nr   );
    1292 
    1293     // get pointers on the parent process main thread
    1294     parent_main_ptr = hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->th_tbl[0] ) );
    1295     parent_main_xp  = XPTR( parent_cxy , parent_main_ptr );
    1296 
    1297      // allocate memory for new_process descriptor
    1298     new_process = process_alloc();
    1299 
    1300     if( new_process == NULL )
    1301     {
    1302         printk("\n[ERROR] in %s : cannot allocate process for %s\n", __FUNCTION__ , path );
     1345printk("\n[DBG] %s : open file <%s>\n", __FUNCTION__, path );
     1346#endif
     1347
     1348    // delete all threads other than this main thread in all clusters
     1349    process_sigaction( pid , DELETE_ALL_THREADS );
     1350
     1351    // reset local process VMM
     1352    vmm_destroy( process );
     1353
     1354#if( DEBUG_PROCESS_MAKE_EXEC & 1 )
     1355cycle = (uint32_t)hal_get_cycles();
     1356if( DEBUG_PROCESS_MAKE_EXEC < cycle )
     1357printk("\n[DBG] %s : thread %x in process %x / reset VMM / cycle %d\n",
     1358__FUNCTION__, thread->trdid, pid, cycle );
     1359#endif
     1360
     1361    // re-initialize the VMM (kentry/args/envs vsegs registration)
     1362    error = vmm_init( process );
     1363    if( error )
     1364    {
     1365        printk("\n[ERROR] in %s : cannot initialise VMM for %s\n", __FUNCTION__ , path );
     1366        vfs_close( file_xp , file_id );
     1367        // FIXME restore old process VMM
    13031368        return -1;
    13041369    }
    1305 
    1306     // get a temporary PID for old_process
    1307     error = cluster_pid_alloc( old_process , &temp_pid );
    1308     if( error )
    1309     {
    1310         printk("\n[ERROR] in %s : cannot get PID in cluster %x\n",
    1311         __FUNCTION__ , local_cxy );
    1312         process_free( new_process );
    1313         return -1;
    1314     }
    1315 
    1316     // set temporary PID to old_process
    1317     old_process->pid = temp_pid;
    1318 
    1319     // initialize new process descriptor
    1320     process_reference_init( new_process,
    1321                             pid,
    1322                             parent_xp,                          // parent_process_xp
    1323                             XPTR(local_cxy , old_process) );    // model_process
    1324 
    1325     // give TXT ownership to new_process
    1326     process_txt_set_ownership( XPTR( local_cxy , new_process) );
    1327 
     1370   
    13281371#if( DEBUG_PROCESS_MAKE_EXEC & 1 )
    13291372cycle = (uint32_t)hal_get_cycles();
    13301373if( DEBUG_PROCESS_MAKE_EXEC < cycle )
    1331 printk("\n[DBG] %s : thread %x in process %x created new process %x\n",
    1332 __FUNCTION__ , old_thread->trdid, pid, new_process );
    1333 #endif
    1334 
    1335     // register code & data vsegs as well as entry-point in new process VMM,
     1374printk("\n[DBG] %s : thread %x in process %x / kentry/args/envs vsegs registered / cycle %d\n",
     1375__FUNCTION__, thread->trdid, pid, cycle );
     1376#endif
     1377
     1378    // register code & data vsegs as well as entry-point in process VMM,
    13361379    // and register extended pointer on .elf file in process descriptor
    1337         error = elf_load_process( path , new_process );
    1338 
     1380        error = elf_load_process( file_xp , process );
    13391381    if( error )
    13401382        {
    13411383                printk("\n[ERROR] in %s : failed to access <%s>\n", __FUNCTION__ , path );
    1342         process_txt_set_ownership( XPTR( local_cxy , old_process) );
    1343         process_txt_detach( XPTR( local_cxy , new_process) );
    1344         process_destroy( new_process );
    1345         old_process->pid = pid;
     1384        vfs_close( file_xp , file_id );
     1385        // FIXME restore old process VMM
    13461386        return -1;
    13471387        }
    … …  
    13501390cycle = (uint32_t)hal_get_cycles();
    13511391if( DEBUG_PROCESS_MAKE_EXEC < cycle )
    1352 printk("\n[DBG] %s : thread %x registered code/data vsegs in new process %x / cycle %d\n",
    1353 __FUNCTION__, old_thread , new_process->pid , cycle );
    1354 #endif
    1355 
    1356     // select a core in local cluster to execute the main thread
    1357     lid  = cluster_select_local_core();
    1358 
    1359     // initialize pthread attributes for main thread
    1360     attr.attributes = PT_ATTR_DETACH | PT_ATTR_CLUSTER_DEFINED | PT_ATTR_CORE_DEFINED;
    1361     attr.cxy        = local_cxy;
    1362     attr.lid        = lid;
    1363 
    1364     // create and initialize main thread in local cluster
    1365         error = thread_user_create( pid,
    1366                                 (void *)new_process->vmm.entry_point,
    1367                                 exec_info->args_pointers,
    1368                                 &attr,
    1369                                 &new_thread );
    1370         if( error )
    1371         {
    1372                 printk("\n[ERROR] in %s : cannot create thread for %s\n", __FUNCTION__ , path );
    1373         process_txt_set_ownership( XPTR( local_cxy , old_process) );
    1374         process_txt_detach( XPTR( local_cxy , new_process) );
    1375         process_destroy( new_process );
    1376         old_process->pid = pid;
     1392printk("\n[DBG] %s : thread %x in process %x / code/data vsegs registered / cycle %d\n",
     1393__FUNCTION__, thread->trdid, pid, cycle );
     1394#endif
     1395
     1396    // update the existing main thread descriptor... and jump to user code
     1397    error = thread_user_exec( (void *)process->vmm.entry_point,
     1398                              args_nr,
     1399                              args_pointers );
     1400    if( error )
     1401    {
     1402        printk("\n[ERROR] in %s : cannot reset main thread for %s\n", __FUNCTION__ , path );
     1403        vfs_close( file_xp , file_id );
     1404        // FIXME restore old process VMM
    13771405        return -1;
    1378         }
    1379 
    1380     // check main thread LTID
    1381     assert( (LTID_FROM_TRDID(new_thread->trdid) == 0) , __FUNCTION__ ,
    1382     "main thread must have LTID == 0\n" );
    1383 
    1384 #if( DEBUG_PROCESS_MAKE_EXEC & 1 )
    1385 cycle = (uint32_t)hal_get_cycles();
    1386 if( DEBUG_PROCESS_MAKE_EXEC < cycle )
    1387 printk("\n[DBG] %s : thread %x created new_process main thread %x / cycle %d\n",
    1388 __FUNCTION__ , old_thread , new_thread , cycle );
    1389 #endif
    1390 
    1391     // register new_process in parent children list
    1392     remote_spinlock_lock( children_lock_xp );
    1393         xlist_add_last( children_root_xp , XPTR( local_cxy , &new_process->children_list ) );
    1394         hal_remote_atomic_add( children_nr_xp , 1 );
    1395     remote_spinlock_unlock( children_lock_xp );
    1396 
    1397     // activate new thread
    1398         thread_unblock( XPTR( local_cxy , new_thread ) , THREAD_BLOCKED_GLOBAL );
    1399 
    1400     // detach old_process from TXT
    1401     process_txt_detach( XPTR( local_cxy , old_process ) );
    1402 
    1403     // block old_thread
    1404     thread_block( XPTR( local_cxy , old_thread ) , THREAD_BLOCKED_GLOBAL );
    1405 
    1406     // atomically update old_process termination state
    1407     hal_atomic_or( &old_process->term_state , PROCESS_TERM_EXIT );
    1408 
    1409     // take the children lock and unblock the parent process main thread
    1410     remote_spinlock_lock( children_lock_xp );
    1411     thread_unblock( parent_main_xp , THREAD_BLOCKED_WAIT );
    1412     remote_spinlock_unlock( children_lock_xp );
    1413 
    1414     hal_fence();
    1415 
    1416 #if DEBUG_PROCESS_MAKE_EXEC
    1417 cycle = (uint32_t)hal_get_cycles();
    1418 if( DEBUG_PROCESS_MAKE_EXEC < cycle )
    1419 printk("\n[DBG] %s : old thread %x blocked for delete / new thread %x activated / cycle %d\n",
    1420 __FUNCTION__ , old_thread , new_thread , cycle );
    1421 #endif
    1422    
     1406    }
     1407
     1408    assert( false, __FUNCTION__, "we should not execute this code");
     1409 
    14231410        return 0;
    14241411
    14251412}  // end process_make_exec()
     1413
    14261414
    14271415///////////////////////////////////////////////
    … …  
    14741462    pthread_attr_t   attr;          // main thread attributes
    14751463    lid_t            lid;           // selected core local index for main thread
     1464    xptr_t           file_xp;       // extended pointer on .elf file descriptor
     1465    uint32_t         file_id;       // file index in fd_array
    14761466    error_t          error;
    14771467
    … …  
    14791469uint32_t cycle = (uint32_t)hal_get_cycles();
    14801470if( DEBUG_PROCESS_INIT_CREATE < cycle )
    1481 printk("\n[DBG] %s : thread %x enter / cycle %d\n", __FUNCTION__, CURRENT_THREAD, cycle );
     1471printk("\n[DBG] %s : thread %x in process %x enter / cycle %d\n",
     1472__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, cycle );
    14821473#endif
    14831474
    14841475    // allocates memory for process descriptor from local cluster
    14851476        process = process_alloc();
    1486         if( process == NULL )
    1487     {
    1488                 printk("\n[PANIC] in %s : no memory for process descriptor in cluster %x\n",
    1489                 __FUNCTION__, local_cxy  );
    1490     }
     1477       
     1478    assert( (process != NULL), __FUNCTION__,
     1479    "no memory for process descriptor in cluster %x\n", local_cxy  );
    14911480
    14921481    // get PID from local cluster
    14931482    error = cluster_pid_alloc( process , &pid );
    1494     if( error )
    1495     {
    1496                 printk("\n[PANIC] in %s : cannot allocate PID in cluster %x\n",
    1497                 __FUNCTION__, local_cxy );
    1498         process_free( process );
    1499     }
    1500 
    1501     // check allocated PID
    1502     assert( (pid == 1) , __FUNCTION__ , "process INIT must be first process in cluster 0\n" );
     1483
     1484    assert( (error == 0), __FUNCTION__,
     1485    "cannot allocate PID in cluster %x\n", local_cxy );
     1486
     1487    assert( (pid == 1) , __FUNCTION__,
     1488    "process INIT must be first process in cluster 0\n" );
    15031489
    15041490    // initialize process descriptor / parent is local process_zero
    15051491    process_reference_init( process,
    15061492                            pid,
    1507                             XPTR( local_cxy , &process_zero ),     // parent
    1508                             XPTR( local_cxy , &process_zero ) );   // model
     1493                            XPTR( local_cxy , &process_zero ) ); 
     1494
     1495    // open the file identified by CONFIG_PROCESS_INIT_PATH
     1496    file_xp = XPTR_NULL;
     1497    file_id = -1;
     1498        error   = vfs_open( process,
     1499                            CONFIG_PROCESS_INIT_PATH,
     1500                            O_RDONLY,
     1501                            0,
     1502                            &file_xp,
     1503                            &file_id );
     1504
     1505        assert( (error == 0), __FUNCTION__,
     1506    "failed to open file <%s>\n", CONFIG_PROCESS_INIT_PATH );
    15091507
    15101508    // register "code" and "data" vsegs as well as entry-point
    15111509    // in process VMM, using information contained in the elf file.
    1512         if( elf_load_process( CONFIG_PROCESS_INIT_PATH , process ) )
    1513         {
    1514                 printk("\n[PANIC] in %s : cannot access .elf file / path = %s\n",
    1515                 __FUNCTION__, CONFIG_PROCESS_INIT_PATH );
    1516         process_destroy( process );
    1517         }
     1510        error = elf_load_process( file_xp , process );
     1511
     1512        assert( (error == 0), __FUNCTION__,
     1513    "cannot access .elf file <%s>\n", CONFIG_PROCESS_INIT_PATH );
    15181514
    15191515    // get extended pointers on process_zero children_root, children_lock
    … …  
    15411537                                &attr,
    15421538                                &thread );
    1543         if( error )
    1544         {
    1545                 printk("\n[PANIC] in %s : cannot create main thread / path = %s\n",
    1546                 __FUNCTION__, CONFIG_PROCESS_INIT_PATH );
    1547         process_destroy( process );
    1548         }
    1549 
    1550     // check main thread index
    1551     assert( (thread->trdid == 0) , __FUNCTION__ , "main thread must have index 0\n" );
     1539
     1540        assert( (error == 0), __FUNCTION__,
     1541    "cannot create main thread for <%s>\n", CONFIG_PROCESS_INIT_PATH );
     1542
     1543    assert( (thread->trdid == 0), __FUNCTION__,
     1544    "main thread must have index 0 for <%s>\n", CONFIG_PROCESS_INIT_PATH );
    15521545
    15531546    // activate thread
    … …  
    15591552cycle = (uint32_t)hal_get_cycles();
    15601553if( DEBUG_PROCESS_INIT_CREATE < cycle )
    1561 printk("\n[DBG] %s : thread %x exit / cycle %d\n", __FUNCTION__, CURRENT_THREAD, cycle );
     1554printk("\n[DBG] %s : thread %x in process %x exit / cycle %d\n",
     1555__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, cycle );
    15621556#endif
    15631557
    … …  
    17021696    xptr_t      lock_xp;      // extended pointer on list lock in chdev
    17031697
    1704 #if DEBUG_PROCESS_TXT
    1705 uint32_t cycle = (uint32_t)hal_get_cycles();
    1706 if( DEBUG_PROCESS_TXT < cycle )
    1707 printk("\n[DBG] %s : thread %x enter for process %x / txt_id = %d  / cycle %d\n",
    1708 __FUNCTION__, CURRENT_THREAD, process->pid, txt_id, cycle );
    1709 #endif
    1710 
    17111698    // check process is in owner cluster
    17121699    assert( (CXY_FROM_PID( process->pid ) == local_cxy) , __FUNCTION__ ,
    … …  
    17321719
    17331720#if DEBUG_PROCESS_TXT
    1734 cycle = (uint32_t)hal_get_cycles();
     1721uint32_t cycle = (uint32_t)hal_get_cycles();
    17351722if( DEBUG_PROCESS_TXT < cycle )
    1736 printk("\n[DBG] %s : thread %x exit for process %x / txt_id = %d / cycle %d\n",
    1737 __FUNCTION__, CURRENT_THREAD, process->pid, txt_id , cycle );
     1723printk("\n[DBG] %s : thread %x in process %x attached process %x to TXT %d / cycle %d\n",
     1724__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid,
     1725process->pid, txt_id , cycle );
    17381726#endif
    17391727
    … …  
    17551743    process_cxy = GET_CXY( process_xp );
    17561744    process_ptr = GET_PTR( process_xp );
     1745
     1746    // check process descriptor in owner cluster
    17571747    process_pid = hal_remote_lw( XPTR( process_cxy , &process_ptr->pid ) );
    1758 
    1759     // check process descriptor in owner cluster
    17601748    assert( (CXY_FROM_PID( process_pid ) == process_cxy ) , __FUNCTION__ ,
    17611749    "process descriptor not in owner cluster" );
    1762 
    1763 #if DEBUG_PROCESS_TXT
    1764 uint32_t cycle = (uint32_t)hal_get_cycles();
    1765 if( DEBUG_PROCESS_TXT < cycle )
    1766 printk("\n[DBG] %s : thread %x enter for process %x / cycle %d\n",
    1767 __FUNCTION__, CURRENT_THREAD, process_pid, cycle );
    1768 #endif
    17691750
    17701751    // release TXT ownership (does nothing if not TXT owner)
    … …  
    17881769
    17891770#if DEBUG_PROCESS_TXT
    1790 cycle  = (uint32_t)hal_get_cycles();
     1771uint32_t cycle  = (uint32_t)hal_get_cycles();
    17911772uint32_t txt_id = hal_remote_lw( XPTR( chdev_cxy , &chdev_ptr->channel ) );
    17921773if( DEBUG_PROCESS_TXT < cycle )
    1793 printk("\n[DBG] %s : thread %x exit / process %x detached from TXT %d / cycle %d\n",
    1794 __FUNCTION__, CURRENT_THREAD, process_pid, txt_id, cycle );
     1774printk("\n[DBG] %s : thread %x in process %x detached process %x from TXT %d / cycle %d\n",
     1775__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid,
     1776process_pid, txt_id, cycle );
    17951777#endif
    17961778
    … …  
    18111793    process_cxy = GET_CXY( process_xp );
    18121794    process_ptr = GET_PTR( process_xp );
    1813 
    1814     // get process PID
    18151795    process_pid = hal_remote_lw( XPTR( process_cxy , &process_ptr->pid ) );
    18161796
    … …  
    18181798    assert( (process_cxy == CXY_FROM_PID( process_pid )) , __FUNCTION__,
    18191799    "process descriptor not in owner cluster\n" );
    1820 
    1821 #if DEBUG_PROCESS_TXT
    1822 uint32_t cycle = (uint32_t)hal_get_cycles();
    1823 if( DEBUG_PROCESS_TXT < cycle )
    1824 printk("\n[DBG] %s : thread %x enter for process %x / cycle %d\n",
    1825 __FUNCTION__, CURRENT_THREAD, process_pid, cycle );
    1826 #endif
    18271800
    18281801    // get extended pointer on stdin pseudo file
    … …  
    18381811
    18391812#if DEBUG_PROCESS_TXT
    1840 cycle = (uint32_t)hal_get_cycles();
     1813uint32_t cycle  = (uint32_t)hal_get_cycles();
     1814uint32_t txt_id = hal_remote_lw( XPTR( txt_cxy , &txt_ptr->channel ) );
    18411815if( DEBUG_PROCESS_TXT < cycle )
    1842 printk("\n[DBG] %s : thread %x exit for process %x / cycle %d\n",
    1843 __FUNCTION__, CURRENT_THREAD, process_pid, cycle );
     1816printk("\n[DBG] %s : thread %x in process %x give TXT %d to process %x / cycle %d\n",
     1817__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, txt_id, process_pid, cycle );
    18441818#endif
    18451819
    … …  
    18651839    cxy_t       current_cxy;     // cluster for current process
    18661840
     1841#if DEBUG_PROCESS_TXT
     1842uint32_t cycle;
     1843#endif
     1844
    18671845    // get pointers on process in owner cluster
    18681846    process_cxy = GET_CXY( process_xp );
    18691847    process_ptr = GET_PTR( process_xp );
    1870 
    1871     // get process PID
    18721848    process_pid = hal_remote_lw( XPTR( process_cxy , &process_ptr->pid ) );
    18731849
    … …  
    18751851    assert( (process_cxy == CXY_FROM_PID( process_pid )) , __FUNCTION__,
    18761852    "process descriptor not in owner cluster\n" );
    1877 
    1878 #if DEBUG_PROCESS_TXT
    1879 uint32_t cycle = (uint32_t)hal_get_cycles();
    1880 if( DEBUG_PROCESS_TXT < cycle )
    1881 printk("\n[DBG] %s : thread %x enter / process %x / cycle %d\n",
    1882 __FUNCTION__, CURRENT_THREAD, process_pid, cycle );
    1883 #endif
    18841853
    18851854    // get extended pointer on stdin pseudo file
    … …  
    18951864    txt_id   = hal_remote_lw ( XPTR( txt_cxy , &txt_ptr->channel ) );
    18961865
    1897 #if( DEBUG_PROCESS_TXT & 1 )
    1898 if( DEBUG_PROCESS_TXT < cycle )
    1899 printk("\n[DBG] %s : file_ptr %x / txt_ptr %x / txt_id %d / owner_ptr = %x\n",
    1900 __FUNCTION__, GET_PTR(file_xp), txt_ptr, txt_id, GET_PTR(owner_xp) );
    1901 #endif
    1902 
    19031866    // transfer ownership only if process is the TXT owner
    19041867    if( (owner_xp == process_xp) && (txt_id > 0) ) 
    … …  
    19131876        if( process_get_ppid( process_xp ) != 1 )           // process is not KSH
    19141877        {
    1915 
    1916 #if( DEBUG_PROCESS_TXT & 1 )
    1917 if( DEBUG_PROCESS_TXT < cycle )
    1918 printk("\n[DBG] %s : process is not the KSH process => search the KSH\n", __FUNCTION__ );
    1919 #endif
    19201878            // scan attached process list to find KSH process
    19211879            XLIST_FOREACH( root_xp , iter_xp )
    … …  
    19341892
    19351893#if DEBUG_PROCESS_TXT
    1936 cycle = (uint32_t)hal_get_cycles();
     1894cycle   = (uint32_t)hal_get_cycles();
     1895uint32_t ksh_pid = hal_remote_lw( XPTR( current_cxy , &current_ptr->pid ) );
    19371896if( DEBUG_PROCESS_TXT < cycle )
    1938 printk("\n[DBG] %s : thread %x exit / process %x to KSH process %x / cycle %d\n",
    1939 __FUNCTION__, CURRENT_THREAD, process_pid,
    1940 hal_remote_lw( XPTR( current_cxy , &current_ptr->pid ) ), cycle );
     1897printk("\n[DBG] %s : thread %x in process %x release TXT %d to KSH %x / cycle %d\n",
     1898__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, txt_id, ksh_pid, cycle );
     1899process_txt_display( txt_id );
    19411900#endif
    19421901                     return;
    … …  
    19541913        else                                               // process is KSH
    19551914        {
    1956 
    1957 #if( DEBUG_PROCESS_TXT & 1 )
    1958 if( DEBUG_PROCESS_TXT < cycle )
    1959 printk("\n[DBG] %s : process is the KSH process => search another\n", __FUNCTION__ );
    1960 #endif
    1961 
    19621915            // scan attached process list to find another process
    19631916            XLIST_FOREACH( root_xp , iter_xp )
    … …  
    19761929
    19771930#if DEBUG_PROCESS_TXT
    1978 cycle = (uint32_t)hal_get_cycles();
     1931cycle   = (uint32_t)hal_get_cycles();
     1932uint32_t new_pid = hal_remote_lw( XPTR( current_cxy , &current_ptr->pid ) );
    19791933if( DEBUG_PROCESS_TXT < cycle )
    1980 printk("\n[DBG] %s : thread %x exit / KSH process %x to process %x / cycle %d\n",
    1981 __FUNCTION__, CURRENT_THREAD, process_pid,
    1982 hal_remote_lw( XPTR( current_cxy , &current_ptr->pid ) ), cycle );
     1934printk("\n[DBG] %s : thread %x in process %x release TXT %d to process %x / cycle %d\n",
     1935__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, txt_id, new_pid, cycle );
     1936process_txt_display( txt_id );
    19831937#endif
    19841938                     return;
    … …  
    19951949cycle = (uint32_t)hal_get_cycles();
    19961950if( DEBUG_PROCESS_TXT < cycle )
    1997 printk("\n[DBG] %s : thread %x exit / KSH process %x to nobody / cycle %d\n",
    1998 __FUNCTION__, CURRENT_THREAD, process_pid, cycle );
     1951printk("\n[DBG] %s : thread %x in process %x release TXT %d to nobody / cycle %d\n",
     1952__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, txt_id, cycle );
     1953process_txt_display( txt_id );
    19991954#endif
    20001955            return;
    … …  
    20071962cycle = (uint32_t)hal_get_cycles();
    20081963if( DEBUG_PROCESS_TXT < cycle )
    2009 printk("\n[DBG] %s : thread %x exit / process %x is not TXT owner / cycle %d\n",
    2010 __FUNCTION__, CURRENT_THREAD, process_pid, cycle );
     1964printk("\n[DBG] %s : thread %x in process %d does nothing (not TXT owner) / cycle %d\n",
     1965__FUNCTION__, CURRENT_THREAD->trdid, process_pid, cycle );
     1966process_txt_display( txt_id );
    20111967#endif
    20121968
    … …  
    20141970}  // end process_txt_transfer_ownership()
    20151971
     1972
     1973//////////////////////////////////////////////////
     1974uint32_t process_txt_is_owner( xptr_t process_xp )
     1975{
     1976    // get local pointer and cluster of process in owner cluster
     1977    cxy_t       process_cxy = GET_CXY( process_xp );
     1978    process_t * process_ptr = GET_PTR( process_xp );
     1979
     1980    // check owner cluster
     1981    pid_t process_pid = hal_remote_lw( XPTR( process_cxy , &process_ptr->pid ) );
     1982    assert( (process_cxy == CXY_FROM_PID( process_pid )) , __FUNCTION__,
     1983    "process descriptor not in owner cluster\n" );
     1984
     1985    // get extended pointer on stdin pseudo file
     1986    xptr_t file_xp = hal_remote_lwd( XPTR( process_cxy , &process_ptr->fd_array.array[0] ) );
     1987
     1988    // get pointers on TXT chdev
     1989    xptr_t    txt_xp  = chdev_from_file( file_xp );
     1990    cxy_t     txt_cxy = GET_CXY( txt_xp );
     1991    chdev_t * txt_ptr = GET_PTR( txt_xp );
     1992
     1993    // get extended pointer on TXT_RX owner process
     1994    xptr_t owner_xp = hal_remote_lwd( XPTR( txt_cxy , &txt_ptr->ext.txt.owner_xp ) );
     1995
     1996    return (process_xp == owner_xp);
     1997
     1998}   // end process_txt_is_owner()
    20161999
    20172000////////////////////////////////////////////////     
    … …  
    20232006
    20242007    return (xptr_t)hal_remote_lwd( XPTR( txt_rx_cxy , &txt_rx_ptr->ext.txt.owner_xp ) );
    2025 }
     2008
     2009}  // end process_txt_get_owner()
    20262010
    20272011///////////////////////////////////////////

  • trunk/kernel/kern/process.h

    r450 r457  
    2929#include <kernel_config.h>
    3030#include <errno.h>
    31 #include <hal_types.h>
     31#include <hal_kernel_types.h>
    3232#include <list.h>
    3333#include <xlist.h>
    … …  
    146146
    147147    uint32_t          term_state;       /*! termination status (flags & exit status)        */
    148 
    149     bool_t            txt_owner;        /*! current TXT owner                               */
    150148}
    151149process_t;
    … …  
    213211/*********************************************************************************************
    214212 * This function initializes a local, reference, user process descriptor from another process
    215  * descriptor, defined by the <model_xp> argument. The <process> and <pid> arguments must
    216  * be previously allocated by he caller. This function can be called by three functions:
    217  * 1) process_init_create() : process is the reference INIT process / pid = 1 /
    218  *    the parent and model process descriptors are both the kernel process_zero.
    219  * 2) process_make_fork() : the model process descriptor is the (generally remote)
    220  *    parent process.
    221  * 3) process_make exec() : the model process is the local old_process, the new_process
    222  *    parent is the same as the old_process parent.
     213 * descriptor, defined by the <parent_xp> argument. The <process> and <pid> arguments must
     214 * be previously allocated by the caller. This function can be called by two functions:
     215 * 1) process_init_create() : process is the INIT process; parent is process-zero.
     216 * 2) process_make_fork() : the parent process descriptor is generally remote.
    223217 * The following fields are initialised :
    224218 * - It set the pid / ppid / ref_xp / parent_xp / state fields.
    225219 * - It initializes the VMM (register the kentry, args, envs vsegs in VSL)
    226220 * - It initializes the FDT, defining the three pseudo files STDIN / STDOUT / STDERR.
     221 *   . if INIT process     => link to kernel TXT[0].
     222 *   . if KSH[i] process   => allocate a free TXT[i] and give TXT ownership.
     223 *   . if USER process     => same TXT[i] as parent process and give TXT ownership.
    227224 * - It set the root_xp, bin_xp, cwd_xp fields.
    228225 * - It reset the children list as empty, but does NOT register it in parent children list.
    … …  
    236233 * @ pid          : [in] process identifier.
    237234 * @ parent_xp    : [in] extended pointer on parent process descriptor.
    238  * @ model_xp     : [in] extended pointer on model process descriptor.
    239235 ********************************************************************************************/
    240236void process_reference_init( process_t * process,
    241237                             pid_t       pid,
    242                              xptr_t      parent_xp,
    243                              xptr_t      model_xp );
     238                             xptr_t      parent_xp );
    244239
    245240/*********************************************************************************************
    … …  
    515510 * It is called only by the process_reference_init() function when creating a KSH process.
    516511 * It makes a kernel panic if no free TXT terminal is found.
    517  * The allocated TXT terminal is only released if the KSH process is deleted,
    518  * which is a rare and abnormal event.
     512 * The allocated TXT terminal is only released when the KSH process is deleted.
    519513 *********************************************************************************************
    520514 * @ return TXT terminal index if succes / kernel panic if no terminal found.
    … …  
    547541
    548542/*********************************************************************************************
    549  * This function gives to a process identified by the <owner_xp> argument, and attached
    550  * to terminal TXT[i] the exclusive ownership of the TXT_RX[i] terminal.
    551  * The process descriptor must be in the process owner cluster.
     543 * This function gives the TXT ownership to a process identified by the <process_xp> argument.
     544 * It can be called by a thread running in any cluster, but the <process_xp> must be the
     545 * owner cluster process descriptor.
    552546 *********************************************************************************************
    553547 * @ owner_xp  : extended pointer on process descriptor in owner cluster.
    554548 ********************************************************************************************/
    555 void process_txt_set_ownership( xptr_t owner_xp );
    556 
    557 /*********************************************************************************************
    558  * When the process dentified by the <owner_xp> argument has the exclusive ownership of
     549void process_txt_set_ownership( xptr_t process_xp );
     550
     551/*********************************************************************************************
     552 * When the process identified by the <owner_xp> argument has the exclusive ownership of
    559553 * the TXT_RX terminal, this function transfer this ownership to another attached process.
    560554 * The process descriptor must be the process owner.
    … …  
    565559 * - If there is no other attached process, the TXT has no more defined owner.
    566560 *********************************************************************************************
    567  * @ owner_xp  : extended pointer on process descriptor in owner cluster.
    568  ********************************************************************************************/
    569 void process_txt_transfer_ownership( xptr_t owner_xp );
    570 
    571 /*********************************************************************************************
    572  * This function returns the TXT owner process (foreground process)
    573  * for a given TXT terminal identified by its <channel> index.
    574  *********************************************************************************************
    575  * @ channel  : TXT terminal channel.
    576  * @ return extentded pointer on TXT owner process in owner cluster.
     561 * @ process_xp  : extended pointer on process descriptor in owner cluster.
     562 ********************************************************************************************/
     563void process_txt_transfer_ownership( xptr_t process_xp );
     564
     565/*********************************************************************************************
     566 * This function returns true if the  process identified by the <process_xp> argument
     567 * is the TXT owner. It can be called by a thread running in any cluster, but the
     568 * process_xp must be the owner cluster process descriptor.
     569 *********************************************************************************************
     570 * @ return a non-zero value if target process is TXT owner.
     571 ********************************************************************************************/
     572uint32_t process_txt_is_owner( xptr_t process_xp );
     573
     574/*********************************************************************************************
     575 * This function returns an extended ponter on the current TXT owner process,
     576 * for the TXT terminal identified by the <channel> index.
     577 *********************************************************************************************
     578 * @ channel : TXT channel.
     579 * @ return extended pointer on TXT owner process.
    577580 ********************************************************************************************/
    578581xptr_t process_txt_get_owner( uint32_t channel );

  • trunk/kernel/kern/rpc.c

    r450 r457  
    2323
    2424#include <kernel_config.h>
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <hal_atomic.h>
    2727#include <hal_remote.h>
    … …  
    100100    volatile error_t   full;
    101101    thread_t         * this;
    102     cluster_t        * cluster;
    103 
    104 #if DEBUG_RPC_CLIENT_GENERIC
    105 uint32_t cycle = (uint32_t)hal_get_cycles();
    106 if( DEBUG_RPC_CLIENT_GENERIC < cycle )
    107 printk("\n[DBG] %s : thread %x in cluster %x enter for rpc[%d] / rpc_ptr %x / cycle %d\n",
    108 __FUNCTION__, CURRENT_THREAD, local_cxy, rpc->index, rpc, cycle );
    109 #endif
    110102
    111103    full            = 0;
    112104    this            = CURRENT_THREAD;
    113     cluster         = LOCAL_CLUSTER;
    114105    client_core_lid = this->core->lid;
    115106
     107#if DEBUG_RPC_CLIENT_GENERIC
     108uint32_t cycle = (uint32_t)hal_get_cycles();
     109if( DEBUG_RPC_CLIENT_GENERIC < cycle )
     110printk("\n[DBG] %s : thread %x in process %x enter for rpc[%d] / cycle %d\n",
     111__FUNCTION__, this->trdid, this->process->pid, rpc->index, cycle );
     112#endif
     113
    116114    // select a server_core : use client core index if possible / core 0 otherwise
    117     if( client_core_lid < hal_remote_lw( XPTR( server_cxy , &cluster->cores_nr ) ) )
     115    if( client_core_lid < hal_remote_lw( XPTR( server_cxy , &LOCAL_CLUSTER->cores_nr ) ) )
    118116    {
    119117        server_core_lid = client_core_lid;
    … …  
    150148 
    151149    hal_fence();
     150
     151#if DEBUG_RPC_CLIENT_GENERIC
     152cycle = (uint32_t)hal_get_cycles();
     153if( DEBUG_RPC_CLIENT_GENERIC < cycle )
     154printk("\n[DBG] %s : thread %x in process %x / rpc[%d] / rpc_ptr %x / cycle %d\n",
     155__FUNCTION__, this->trdid, this->process->pid, rpc->index, rpc, cycle );
     156#endif
    152157       
    153     // send IPI to the selected server core
    154         dev_pic_send_ipi( server_cxy , server_core_lid );
     158   // send IPI to the selected server core
     159   dev_pic_send_ipi( server_cxy , server_core_lid );
    155160
    156161    // wait RPC completion before returning if blocking RPC
    … …  
    165170cycle = (uint32_t)hal_get_cycles();
    166171if( DEBUG_RPC_CLIENT_GENERIC < cycle )
    167 printk("\n[DBG] %s : thread %x in cluster %x busy waiting / rpc[%d] / cycle %d\n",
    168 __FUNCTION__, CURRENT_THREAD, local_cxy, rpc->index , cycle );
     172printk("\n[DBG] %s : thread %x in process %x busy waiting for rpc[%d] / cycle %d\n",
     173__FUNCTION__, this->trdid, this->process->pid, rpc->index , cycle );
    169174#endif
    170175
    … …  
    174179cycle = (uint32_t)hal_get_cycles();
    175180if( DEBUG_RPC_CLIENT_GENERIC < cycle )
    176 printk("\n[DBG] %s : thread %x in cluster %x resumes / rpc[%d] / cycle %d\n",
    177 __FUNCTION__, CURRENT_THREAD, local_cxy, rpc->index, cycle );
     181printk("\n[DBG] %s : thread %x in process %x resumes for rpc[%d] / cycle %d\n",
     182__FUNCTION__, this->trdid, this->process->pid, rpc->index, cycle );
    178183#endif
    179184        }
    … …  
    184189cycle = (uint32_t)hal_get_cycles();
    185190if( DEBUG_RPC_CLIENT_GENERIC < cycle )
    186 printk("\n[DBG] %s : thread %x in cluster %x blocks & deschedules / rpc[%d] / cycle %d\n",
    187 __FUNCTION__, CURRENT_THREAD, local_cxy, rpc->index , cycle );
     191printk("\n[DBG] %s : thread %x in process %x blocks & deschedules for rpc[%d] / cycle %d\n",
     192__FUNCTION__, this->trdid, this->process->pid, rpc->index , cycle );
    188193#endif
    189194            thread_block( XPTR( local_cxy , this ) , THREAD_BLOCKED_RPC );
    … …  
    193198cycle = (uint32_t)hal_get_cycles();
    194199if( DEBUG_RPC_CLIENT_GENERIC < cycle )
    195 printk("\n[DBG] %s : thread %x in cluster %x resumes / rpcr[%d] / cycle %d\n",
    196 __FUNCTION__, CURRENT_THREAD, local_cxy, rpc->index, cycle );
     200printk("\n[DBG] %s : thread %x in process %x resumes for rpc[%d] / cycle %d\n",
     201__FUNCTION__, this->trdid, this->process->pid, rpc->index, cycle );
    197202#endif
    198203        }
    … …  
    207212cycle = (uint32_t)hal_get_cycles();
    208213if( DEBUG_RPC_CLIENT_GENERIC < cycle )
    209 printk("\n[DBG] %s : non blocking rpc[%d] => thread %x return / cycle %d\n",
    210 __FUNCTION__, rpc->index, CURRENT_THREAD, cycle );
     214printk("\n[DBG] %s : thread %x in process %x returns for non blocking rpc[%d] / cycle %d\n",
     215__FUNCTION__, this->trdid, this->process->pid, rpc->index, cycle );
    211216#endif
    212217
    … …  
    225230    thread_t      * thread; 
    226231    uint32_t        sr_save;
     232
     233#if DEBUG_RPC_SERVER_GENERIC
     234uint32_t cycle;
     235#endif
    227236
    228237    bool_t          found    = false;
    … …  
    232241        remote_fifo_t * rpc_fifo = &LOCAL_CLUSTER->rpc_fifo[core->lid];
    233242
    234 #if DEBUG_RPC_SERVER_GENERIC
    235 uint32_t cycle = (uint32_t)hal_get_cycles();
    236 if( DEBUG_RPC_SERVER_GENERIC < cycle )
    237 printk("\n[DBG] %s : thread %x interrupted in cluster %x / cycle %d\n",
    238 __FUNCTION__, this, local_cxy, cycle );
    239 #endif
    240 
    241243    // interrupted thread not preemptable during RPC chek
    242244        hal_disable_irq( &sr_save );
    … …  
    249251cycle = (uint32_t)hal_get_cycles();
    250252if( DEBUG_RPC_SERVER_GENERIC < cycle )
    251 printk("\n[DBG] %s : RPC FIFO non empty in cluster %x / cycle %d\n",
    252 __FUNCTION__, local_cxy, cycle );
     253printk("\n[DBG] %s : RPC FIFO non empty for core[%x,%d] / cycle %d\n",
     254__FUNCTION__, local_cxy, core->lid, cycle );
    253255#endif
    254256
    … …  
    290292cycle = (uint32_t)hal_get_cycles();
    291293if( DEBUG_RPC_SERVER_GENERIC < cycle )
    292 printk("\n[DBG] %s : create a new RPC thread %x in cluster %x / cycle %d\n",
    293 __FUNCTION__, thread, local_cxy, cycle );
     294printk("\n[DBG] %s : new RPC thread %x created for core[%x,%d] / cycle %d\n",
     295__FUNCTION__, thread, local_cxy, core->lid, cycle );
    294296#endif
    295297        }
    … …  
    299301cycle = (uint32_t)hal_get_cycles();
    300302if( DEBUG_RPC_SERVER_GENERIC < cycle )
    301 printk("\n[DBG] %s : interrupted thread %x deschedules in cluster %x / cycle %d\n",
    302 __FUNCTION__, this, local_cxy, cycle );
     303printk("\n[DBG] %s : interrupted thread %x deschedules on core[%x,%d] / cycle %d\n",
     304__FUNCTION__, this, local_cxy, core->lid, cycle );
    303305#endif
    304306
    … …  
    309311cycle = (uint32_t)hal_get_cycles();
    310312if( DEBUG_RPC_SERVER_GENERIC < cycle )
    311 printk("\n[DBG] %s : interrupted thread %x resumes in cluster %x / cycle %d\n",
    312 __FUNCTION__, this, local_cxy, cycle );
     313printk("\n[DBG] %s : interrupted thread %x resumes on core[%x,%d] / cycle %d\n",
     314__FUNCTION__, this, local_cxy, core->lid, cycle );
    313315#endif
    314316
    … …  
    410412#endif
    411413                        // send IPI to client core
    412                             dev_pic_send_ipi( desc_cxy , client_core_lid );
     414                            // dev_pic_send_ipi( desc_cxy , client_core_lid );
    413415                    }
    414416                        }
    … …  
    872874pid_t     pid    = rpc->args[1];
    873875if( DEBUG_RPC_PROCESS_SIGACTION < cycle )
    874 printk("\n[DBG] %s : enter to %s process %x in cluster %x / cycle %d\n",
     876printk("\n[DBG] %s : enter to request %s of process %x in cluster %x / cycle %d\n",
    875877__FUNCTION__ , process_action_str( action ) , pid , cxy , cycle );
    876878#endif
    … …  
    949951
    950952        // send an IPI to client core
    951         dev_pic_send_ipi( client_cxy , client_lid );
     953        // dev_pic_send_ipi( client_cxy , client_lid );
    952954    }
    953955

  • trunk/kernel/kern/rpc.h

    r450 r457  
    2626
    2727#include <kernel_config.h>
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929#include <hal_atomic.h>
    3030#include <bits.h>

  • trunk/kernel/kern/scheduler.c

    r450 r457  
    2323
    2424#include <kernel_config.h>
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <hal_switch.h>
    2727#include <hal_irqmask.h>

  • trunk/kernel/kern/scheduler.h

    r450 r457  
    2525#define _SCHEDULER_H_
    2626
    27 #include <hal_types.h>
     27#include <hal_kernel_types.h>
    2828#include <list.h>
    2929#include <spinlock.h>

  • trunk/kernel/kern/signal.c

    r409 r457  
    2424 */
    2525
    26 #include <hal_types.h>
     26#include <hal_kernel_types.h>
    2727#include <printk.h>
    2828#include <signal.h>

  • trunk/kernel/kern/signal.h

    r435 r457  
    2727#define _SIGNAL_H_
    2828
    29 #include <hal_types.h>
     29#include <hal_kernel_types.h>
    3030
    3131

  • trunk/kernel/kern/thread.c

    r450 r457  
    2424
    2525#include <kernel_config.h>
    26 #include <hal_types.h>
     26#include <hal_kernel_types.h>
    2727#include <hal_context.h>
    2828#include <hal_irqmask.h>
    … …  
    167167    thread->quantum         = 0;            // TODO
    168168    thread->ticks_nr        = 0;            // TODO
    169     thread->time_last_check = 0;
     169    thread->time_last_check = 0;            // TODO
    170170        thread->core            = &local_cluster->core_tbl[core_lid];
    171171        thread->process         = process;
    … …  
    243243uint32_t cycle = (uint32_t)hal_get_cycles();
    244244if( DEBUG_THREAD_USER_CREATE < cycle )
    245 printk("\n[DBG] %s : thread %x enter for process %x in cluster %x / cycle %d\n",
    246 __FUNCTION__, CURRENT_THREAD, pid , local_cxy , cycle );
     245printk("\n[DBG] %s : thread %x in process %x enter in cluster %x / cycle %d\n",
     246__FUNCTION__, CURRENT_THREAD->trdid, pid , local_cxy , cycle );
    247247#endif
    248248
    … …  
    301301    }
    302302
     303#if( DEBUG_THREAD_USER_CREATE & 1)
     304if( DEBUG_THREAD_USER_CREATE < cycle )
     305printk("\n[DBG] %s : stack vseg created / vpn_base %x / %d pages\n",
     306__FUNCTION__, vseg->vpn_base, vseg->vpn_size );
     307#endif
     308
    303309    // allocate memory for thread descriptor
    304310    thread = thread_alloc();
    … …  
    313319#if( DEBUG_THREAD_USER_CREATE & 1)
    314320if( DEBUG_THREAD_USER_CREATE < cycle )
    315 printk("\n[DBG] %s : thread descriptor %x allocated\n",
     321printk("\n[DBG] %s : new thread descriptor %x allocated\n",
    316322__FUNCTION__, thread );
    317323#endif
    … …  
    336342#if( DEBUG_THREAD_USER_CREATE & 1)
    337343if( DEBUG_THREAD_USER_CREATE < cycle )
    338 printk("\n[DBG] %s : thread descriptor %x initialised / trdid = %x\n",
    339 __FUNCTION__, thread , thread->trdid );
     344printk("\n[DBG] %s : new thread descriptor initialised / trdid %x\n",
     345__FUNCTION__, thread->trdid );
    340346#endif
    341347
    … …  
    347353
    348354    // allocate & initialize CPU context
    349         if( hal_cpu_context_create( thread ) )
     355        if( hal_cpu_context_alloc( thread ) )
    350356    {
    351357            printk("\n[ERROR] in %s : cannot create CPU context\n", __FUNCTION__ );
    … …  
    354360        return ENOMEM;
    355361    }
    356 
    357     // allocate  FPU context
     362    hal_cpu_context_init( thread );
     363
     364    // allocate & initialize FPU context
    358365    if( hal_fpu_context_alloc( thread ) )
    359366    {
    … …  
    363370        return ENOMEM;
    364371    }
     372    hal_fpu_context_init( thread );
     373
     374#if( DEBUG_THREAD_USER_CREATE & 1)
     375if( DEBUG_THREAD_USER_CREATE < cycle )
     376printk("\n[DBG] %s : CPU & FPU contexts created\n",
     377__FUNCTION__, thread->trdid );
     378vmm_display( process , true );
     379#endif
    365380
    366381#if DEBUG_THREAD_USER_CREATE
    367382cycle = (uint32_t)hal_get_cycles();
    368383if( DEBUG_THREAD_USER_CREATE < cycle )
    369 printk("\n[DBG] %s : thread %x exit / new_thread %x in process %x / core %d / cycle %d\n",
    370 __FUNCTION__, CURRENT_THREAD, thread->trdid , pid , core_lid, cycle );
     384printk("\n[DBG] %s : thread %x in process %x exit / new_thread %x / core %d / cycle %d\n",
     385__FUNCTION__, CURRENT_THREAD->trdid , pid, thread->trdid, core_lid, cycle );
    371386#endif
    372387
    … …  
    554569}  // end thread_user_fork()
    555570
     571////////////////////////////////////////////////
     572error_t thread_user_exec( void     * entry_func,
     573                          uint32_t   argc,
     574                          char    ** argv )
     575{
     576    thread_t  * thread  = CURRENT_THREAD;
     577    process_t * process = thread->process;
     578
     579#if DEBUG_THREAD_USER_EXEC
     580uint32_t cycle = (uint32_t)hal_get_cycles();
     581if( DEBUG_THREAD_USER_EXEC < cycle )
     582printk("\n[DBG] %s : thread %x in process %x enter / cycle %d\n",
     583__FUNCTION__, thread->trdid, process->pid, cycle );
     584#endif
     585
     586        assert( (thread->type == THREAD_USER )          , __FUNCTION__, "bad type" );
     587        assert( (thread->signature == THREAD_SIGNATURE) , __FUNCTION__, "bad signature" );
     588        assert( (thread->local_locks == 0)              , __FUNCTION__, "bad local locks" );
     589        assert( (thread->remote_locks == 0)             , __FUNCTION__, "bad remote locks" );
     590
     591        // re-initialize various thread descriptor fields
     592    thread->quantum         = 0;            // TODO
     593    thread->ticks_nr        = 0;            // TODO
     594    thread->time_last_check = 0;            // TODO
     595
     596#if CONFIG_LOCKS_DEBUG
     597    list_root_init( &thread->locks_root ); 
     598    xlist_root_init( XPTR( local_cxy , &thread->xlocks_root ) );
     599#endif
     600
     601    thread->entry_func      = entry_func;
     602    thread->main_argc       = argc;
     603    thread->main_argv       = argv;
     604
     605    // the main thread is always detached
     606    thread->flags           = THREAD_FLAG_DETACHED;
     607    thread->blocked         = 0;
     608    thread->errno           = 0;
     609    thread->fork_user       = 0;    // not inherited
     610    thread->fork_cxy        = 0;    // not inherited
     611
     612    // reset thread info
     613    memset( &thread->info , 0 , sizeof(thread_info_t) );
     614
     615    // initialize join_lock
     616    remote_spinlock_init( XPTR( local_cxy , &thread->join_lock ) );
     617
     618    // allocate an user stack vseg for main thread
     619    vseg_t * vseg = vmm_create_vseg( process,
     620                                     VSEG_TYPE_STACK,
     621                                     0,                 // size unused
     622                                     0,                 // length unused
     623                                     0,                 // file_offset unused
     624                                     0,                 // file_size unused
     625                                     XPTR_NULL,         // mapper_xp unused
     626                                     local_cxy );
     627    if( vseg == NULL )
     628    {
     629            printk("\n[ERROR] in %s : cannot create stack vseg for main thread\n", __FUNCTION__ );
     630                return -1;
     631    }
     632
     633    // update user stack in stack descriptor
     634    thread->u_stack_base = vseg->min;
     635    thread->u_stack_size = vseg->max - vseg->min;
     636   
     637    // release FPU ownership if required
     638    if( thread->core->fpu_owner == thread ) thread->core->fpu_owner = NULL;
     639
     640    // re-initialize  FPU context
     641    hal_fpu_context_init( thread );
     642
     643#if DEBUG_THREAD_USER_EXEC
     644cycle = (uint32_t)hal_get_cycles();
     645if( DEBUG_THREAD_USER_EXEC < cycle )
     646printk("\n[DBG] %s : thread %x in process %x set CPU context & jump to user code / cycle %d\n",
     647__FUNCTION__, thread->trdid, process->pid, cycle );
     648vmm_display( process , true );
     649#endif
     650
     651    // re-initialize CPU context... and jump to user code
     652        hal_cpu_context_exec( thread );
     653
     654    assert( false, __FUNCTION__, "we should execute this code");
     655 
     656    return 0;
     657
     658}  // end thread_user_exec()
     659
    556660/////////////////////////////////////////////////////////
    557661error_t thread_kernel_create( thread_t     ** new_thread,
    … …  
    594698    {
    595699        thread_release( thread );
     700        return ENOMEM;
     701    }
     702
     703    // allocate & initialize CPU context
     704        error = hal_cpu_context_alloc( thread );
     705    if( error )
     706    {
     707        thread_release( thread );
    596708        return EINVAL;
    597709    }
    598 
    599     // allocate & initialize CPU context
    600         hal_cpu_context_create( thread );
     710    hal_cpu_context_init( thread );
     711
    601712
    602713#if DEBUG_THREAD_KERNEL_CREATE
    … …  
    612723} // end thread_kernel_create()
    613724
    614 /////////////////////////////////////////////////
    615 error_t thread_idle_init( thread_t      * thread,
    616                           thread_type_t   type,
    617                           void          * func,
    618                           void          * args,
    619                                           lid_t           core_lid )
     725//////////////////////////////////////////////
     726void thread_idle_init( thread_t      * thread,
     727                       thread_type_t   type,
     728                       void          * func,
     729                       void          * args,
     730                           lid_t           core_lid )
    620731{
    621732    assert( (type == THREAD_IDLE) , __FUNCTION__ , "illegal thread type" );
    622 
    623733    assert( (core_lid < LOCAL_CLUSTER->cores_nr) , __FUNCTION__ , "illegal core index" );
    624734
     735    // initialize thread descriptor
    625736    error_t  error = thread_init( thread,
    626737                                  &process_zero,
    … …  
    631742                                  0 , 0 );   // no user stack for a kernel thread
    632743
     744    assert( (error == 0), __FUNCTION__, "cannot create thread idle" );
     745
    633746    // allocate & initialize CPU context if success
    634     if( error == 0 ) hal_cpu_context_create( thread );
    635 
    636     return error;
     747    error = hal_cpu_context_alloc( thread );
     748
     749    assert( (error == 0), __FUNCTION__, "cannot allocate CPU context" );
     750
     751    hal_cpu_context_init( thread );
    637752
    638753}  // end thread_idle_init()
    … …  
    798913
    799914#if DEBUG_THREAD_BLOCK
    800 uint32_t cycle = (uint32_t)hal_get_cycles();
     915uint32_t    cycle   = (uint32_t)hal_get_cycles();
     916process_t * process = hal_remote_lpt( XPTR( cxy , &ptr->process ) );
    801917if( DEBUG_THREAD_BLOCK < cycle )
    802 printk("\n[DBG] %s : thread %x  in cxy %x blocked thread %x in cxy %x / cause %x / cycle %d\n",
    803 __FUNCTION__ , CURRENT_THREAD , local_cxy , ptr , cxy , cause , cycle );
     918printk("\n[DBG] %s : thread %x in process %x blocked thread %x in process %x / cause %x\n",
     919__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid,
     920ptr->trdid, hal_remote_lw(XPTR( cxy , &process->pid )), cause );
    804921#endif
    805922
    … …  
    819936
    820937#if DEBUG_THREAD_BLOCK
    821 uint32_t cycle = (uint32_t)hal_get_cycles();
     938uint32_t    cycle   = (uint32_t)hal_get_cycles();
     939process_t * process = hal_remote_lpt( XPTR( cxy , &ptr->process ) );
    822940if( DEBUG_THREAD_BLOCK < cycle )
    823 printk("\n[DBG] %s : thread %x  in cxy %x unblocked thread %x in cxy %x / cause %x / cycle %d\n",
    824 __FUNCTION__ , CURRENT_THREAD , local_cxy , ptr , cxy , cause , cycle );
     941printk("\n[DBG] %s : thread %x in process %x unblocked thread %x in process %x / cause %x\n",
     942__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid,
     943ptr->trdid, hal_remote_lw(XPTR( cxy , &process->pid )), cause );
    825944#endif
    826945

  • trunk/kernel/kern/thread.h

    r446 r457  
    2626#define _THREAD_H_
    2727
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929#include <shared_syscalls.h>
    3030#include <hal_special.h>
    … …  
    161161    void              * entry_func;      /*! pointer on entry function                */
    162162    void              * entry_args;      /*! pointer on entry function arguments      */
     163    uint32_t            main_argc;       /*! main thread number of arguments          */
     164    char             ** main_argv;       /*! main thread array of strings arguments   */
    163165
    164166    uint32_t            flags;           /*! bit vector of flags                      */
    … …  
    218220 * The CPU context is initialized from scratch.
    219221 * It is registered in the local process descriptor specified by the <pid> argument.
    220  * The THREAD_BLOCKED_GLOBAL bit is set => the thread must be activated to start.
     222 * The THREAD_BLOCKED_GLOBAL bit is set => the thread must be activated by the caller
     223 * to start at the next scheduling point.
    221224 ***************************************************************************************
    222225 * @ pid          : process identifier.
    … …  
    258261
    259262/***************************************************************************************
     263 * This function is called by the process_make_exec() function to re-initialise the
     264 * thread descriptor of the calling thread (that will become the new process main
     265 * thread), and immediately jump to user code without returning to kentry!!!
     266 * It must be called by the main thread of the calling process.
     267 * - A new user stack vseg is created and initialised.
     268 * - The kernel stack (currently in use) is not modified. 
     269 * - The function calls the hal_cpu_context_exec() to re-initialize the CPU context
     270 *   an jump to user code. 
     271 ***************************************************************************************
     272 * @ entry_func : main thread entry point.
     273 * @ argc       : number of main thread arguments.
     274 * @ argv       : array of pointers on stringarguments.
     275 * @ returns 0 if success / returns ENOMEM if error.
     276 **************************************************************************************/
     277error_t thread_user_exec( void     * entry_func,
     278                          uint32_t   argc,
     279                          char    ** argv);
     280
     281/***************************************************************************************
    260282 * This function allocates memory for a kernel thread descriptor in the local cluster,
    261283 * and initializes it from arguments values.
    … …  
    281303 * descriptor from arguments values.
    282304 * The THREAD_BLOCKED_GLOBAL bit is set, and the thread must be activated to start.
     305 * It returns a kernel panic if failure.
    283306 ***************************************************************************************
    284307 * @ thread   : pointer on existing thread descriptor.
    … …  
    287310 * @ args     : function arguments.
    288311 * @ core_lid : local core index.
    289  * @ returns 0 if success / returns EINVAL if error
    290  **************************************************************************************/
    291 error_t thread_idle_init( thread_t      * thread,
    292                           thread_type_t   type,
    293                           void          * func,
    294                           void          * args,
    295                           lid_t           core_lid );
     312 **************************************************************************************/
     313void thread_idle_init( thread_t      * thread,
     314                       thread_type_t   type,
     315                       void          * func,
     316                       void          * args,
     317                       lid_t           core_lid );
    296318
    297319/***************************************************************************************

  • trunk/kernel/kernel_config.h

    r450 r457  
    2727#define _ALMOS_CONFIG_H_
    2828
    29 #define CONFIG_ALMOS_VERSION                "Version 1.0 / March 2018"
     29#define CONFIG_ALMOS_VERSION           "Version 1.0 / August 2018"
    3030
    3131////////////////////////////////////////////////////////////////////////////////////////////
    … …  
    7676#define DEBUG_HAL_IOC_RX               0
    7777#define DEBUG_HAL_IOC_TX               0
    78 #define DEBUG_HAL_GPT
     78#define DEBUG_HAL_GPT                  0
    7979
    8080#define DEBUG_KCM                      0
    … …  
    117117
    118118#define DEBUG_SCHED_HANDLE_SIGNALS     2
    119 #define DEBUG_SCHED_YIELD              2    // must be activated by the trace() syscall
     119#define DEBUG_SCHED_YIELD              1    // must be activated by the trace() syscall
    120120
    121121#define DEBUG_SYSCALLS_ERROR           2
    122122
    123123#define DEBUG_SYS_DISPLAY              0
    124 #define DEBUG_SYS_EXEC                 1
    125 #define DEBUG_SYS_EXIT                 1
     124#define DEBUG_SYS_EXEC                 0
     125#define DEBUG_SYS_EXIT                 0
    126126#define DEBUG_SYS_FG                   0
    127127#define DEBUG_SYS_FORK                 0
    128128#define DEBUG_SYS_GET_CONFIG           0
    129129#define DEBUG_SYS_ISATTY               0
     130#define DEBUG_SYS_IS_FG                0
    130131#define DEBUG_SYS_KILL                 0
    131132#define DEBUG_SYS_MMAP                 0
    … …  
    154155#define DEBUG_THREAD_USER_CREATE       0
    155156#define DEBUG_THREAD_USER_FORK         0
     157#define DEBUG_THREAD_USER_EXEC         0
    156158#define DEBUG_THREAD_BLOCK             0
    157159

  • trunk/kernel/libk/barrier.c

    r16 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <hal_remote.h>
    2626#include <hal_atomic.h>

  • trunk/kernel/libk/barrier.h

    r423 r457  
    2626
    2727#include <kernel_config.h>
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929
    3030/*****************************************************************************************

  • trunk/kernel/libk/bits.c

    r351 r457  
    2323 */
    2424
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <bits.h>
    2727

  • trunk/kernel/libk/bits.h

    r454 r457  
    2727
    2828#include <kernel_config.h>
    29 #include <hal_types.h>
     29#include <hal_kernel_types.h>
    3030
    3131/*********************************************************************************************

  • trunk/kernel/libk/ctype.c

    r1 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525
    2626////////////////////

  • trunk/kernel/libk/elf.c

    r441 r457  
    2323
    2424#include <kernel_config.h>
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <hal_special.h>
    2727#include <hal_uspace.h>
    … …  
    210210} // end elf_segments_register()
    211211
    212 ///////////////////////////////////////////////
    213 error_t elf_load_process( char      * pathname,
    214                           process_t * process)
     212//////////////////////////////////////////////
     213error_t elf_load_process( xptr_t      file_xp,
     214                          process_t * process )
    215215{
    216216        kmem_req_t   req;              // kmem request for program header
    … …  
    218218        void       * segs_base;        // pointer on buffer for segment descriptors array
    219219        uint32_t     segs_size;        // size of buffer for segment descriptors array
    220         xptr_t       file_xp;          // extended pointer on created file descriptor
    221         uint32_t     file_id;          // file descriptor index (unused)
     220    char         name[CONFIG_VFS_MAX_NAME_LENGTH];
    222221        error_t      error;
    223222
     223    // get file name for error reporting and debug
     224    cxy_t         file_cxy = GET_CXY( file_xp );
     225    vfs_file_t  * file_ptr = GET_PTR( file_xp );
     226    vfs_inode_t * inode    = hal_remote_lpt( XPTR( file_cxy , &file_ptr->inode ) );
     227    vfs_inode_get_name( XPTR( file_cxy , inode ) , name );
     228   
    224229#if DEBUG_ELF_LOAD
    225 uint32_t cycle = (uint32_t)hal_get_cycles();
    226 if( DEBUG_ELF_LOAD < cycle )
    227 printk("\n[DBG] %s : thread %d enter for <%s> / cycle %d\n",
    228 __FUNCTION__, CURRENT_THREAD, pathname, cycle );
    229 #endif
    230 
    231     // avoid GCC warning
    232         file_xp = XPTR_NULL; 
    233         file_id = -1;
    234 
    235         // open file
    236         error = vfs_open( process,
    237                           pathname,
    238                           O_RDONLY,
    239                           0,
    240                           &file_xp,
    241                           &file_id );
    242         if( error )
    243         {
    244                 printk("\n[ERROR] in %s : failed to open file <%s>\n", __FUNCTION__ , pathname );
    245                 return -1;
    246         }
    247 
    248 #if (DEBUG_ELF_LOAD & 1)
    249 if( DEBUG_ELF_LOAD < cycle )
    250 printk("\n[DBG] %s : open file <%s>\n", __FUNCTION__, pathname );
     230uint32_t      cycle = (uint32_t)hal_get_cycles();
     231if( DEBUG_ELF_LOAD < cycle )
     232printk("\n[DBG] %s : thread %d in process %x enter for <%s> / cycle %d\n",
     233__FUNCTION__, CURRENT_THREAD->trdid, process->pid, name, cycle );
    251234#endif
    252235
    … …  
    257240        if( error )
    258241        {
    259                 printk("\n[ERROR] in %s : cannot get header for <%s>\n", __FUNCTION__ , pathname );
    260                 vfs_close( file_xp , file_id );
     242                printk("\n[ERROR] in %s : cannot get header for <%s>\n", __FUNCTION__ , name );
    261243                return -1;
    262244        }
    … …  
    264246#if (DEBUG_ELF_LOAD & 1)
    265247if( DEBUG_ELF_LOAD < cycle )
    266 printk("\n[DBG] %s : loaded elf header for <%s>\n", __FUNCTION__ , pathname );
     248printk("\n[DBG] %s : loaded elf header for <%s>\n", __FUNCTION__ , name );
    267249#endif
    268250
    … …  
    270252        {
    271253                printk("\n[ERROR] in %s : no segments found\n", __FUNCTION__ );
    272                 vfs_close( file_xp , file_id );
    273254                return -1;
    274255        }
    … …  
    286267        {
    287268                printk("\n[ERROR] in %s : no memory for segment descriptors\n", __FUNCTION__ );
    288                 vfs_close( file_xp , file_id );
    289269                return -1;
    290270        }
    … …  
    296276        {
    297277                printk("\n[ERROR] in %s : cannot seek for descriptors array\n", __FUNCTION__ );
    298                 vfs_close( file_xp , file_id );
    299278                req.ptr = segs_base;
    300279                kmem_free( &req );
    … …  
    304283#if (DEBUG_ELF_LOAD & 1)
    305284if( DEBUG_ELF_LOAD < cycle )
    306 printk("\n[DBG] %s : segments array allocated for <%s>\n", __FUNCTION__ , pathname );
     285printk("\n[DBG] %s : segments array allocated for <%s>\n", __FUNCTION__ , name );
    307286#endif
    308287
    … …  
    316295        {
    317296                printk("\n[ERROR] in %s : cannot read segments descriptors\n", __FUNCTION__ );
    318                 vfs_close( file_xp , file_id );
    319297                req.ptr = segs_base;
    320298                kmem_free( &req );
    … …  
    324302#if (DEBUG_ELF_LOAD & 1)
    325303if( DEBUG_ELF_LOAD < cycle )
    326 printk("\n[DBG] %s loaded segments descriptors for <%s>\n", __FUNCTION__ , pathname );
     304printk("\n[DBG] %s loaded segments descriptors for <%s>\n", __FUNCTION__ , name );
    327305#endif
    328306
    … …  
    334312        if( error )
    335313        {
    336                 vfs_close( file_xp , file_id );
    337314                req.ptr = segs_base;
    338315                kmem_free( &req );
    … …  
    353330cycle = (uint32_t)hal_get_cycles();
    354331if( DEBUG_ELF_LOAD < cycle )
    355 printk("\n[DBG] %s : thread %d exit for <%s> / entry_point %x / cycle %d\n",
    356 __FUNCTION__, CURRENT_THREAD, pathname, header.e_entry, cycle );
     332printk("\n[DBG] %s : thread %x in process %x exit for <%s> / entry_point %x / cycle %d\n",
     333__FUNCTION__, CURRENT_THREAD->trdid, process->pid, name, header.e_entry, cycle );
    357334#endif
    358335

  • trunk/kernel/libk/elf.h

    r273 r457  
    2222#define _ELF_H_ 1
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525
    2626/*
    … …  
    204204#define PF_MASKPROC     0xf0000000      /* Processor-specific */
    205205
    206 #if defined(HAL_32BIT)
     206#if defined(HAL_ELF_32_BITS)
    207207#define Elf_Half  Elf32_Half
    208208#define Elf_Word  Elf32_Word
    … …  
    213213#define Elf_Phdr  Elf32_Phdr
    214214#define ELFCLASS  ELFCLASS32
    215 #elif defined (HAL_64BIT)
     215#elif defined (HAL_ELF_64_BITS)
    216216#define Elf_Half  Elf64_Half
    217217#define Elf_Word  Elf64_Word
    … …  
    224224#define ELFCLASS  ELFCLASS64
    225225#else
    226 #error "Must define HAL_64BIT/HAL_32BIT"
     226#error "Must define HAL_ELF_64_BITS / HAL_ELF_32_BITS"
    227227#endif
    228228
    229229/****************************************************************************************
    230  * This function registers in VMM the CODE and DATA vsegs defined in the .elf file.
     230 * This function registers in VMM of the process identified by the <process> argument
     231 * the CODE and DATA vsegs defined in the .elf open file descriptor <file_xp>.
    231232 * The segments are not loaded in memory.
    232233 * It also registers the process entry point in VMM.
    233234 ****************************************************************************************
    234  * @ pathname : local pointer on .elf file pathname (in kernel space).
     235 * @ file_xp  : extended pointer on .elf file descriptor.
    235236 * @ process  : local pointer on target process descriptor.
    236237 ***************************************************************************************/
    237 error_t elf_load_process( char      * pathname,
     238error_t elf_load_process( xptr_t      file_xp,
    238239                          process_t * process);
    239240

  • trunk/kernel/libk/grdxt.c

    r423 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <hal_special.h>
    2626#include <errno.h>

  • trunk/kernel/libk/grdxt.h

    r406 r457  
    2525#define _GRDXT_H_
    2626
    27 #include <hal_types.h>
     27#include <hal_kernel_types.h>
    2828
    2929/*******************************************************************************************

  • trunk/kernel/libk/htab.c

    r423 r457  
    2323
    2424#include <kernel_config.h>
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <hal_special.h>
    2727#include <htab.h>

  • trunk/kernel/libk/htab.h

    r23 r457  
    2626#define _HTAB_H_
    2727
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929#include <rwlock.h>
    3030#include <list.h>

  • trunk/kernel/libk/list.h

    r450 r457  
    2727
    2828#include <kernel_config.h>
    29 #include <hal_types.h>
     29#include <hal_kernel_types.h>
    3030
    3131#ifndef NULL

  • trunk/kernel/libk/memcpy.c

    r113 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <printk.h>
    2626

  • trunk/kernel/libk/memcpy.h

    r113 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525
    2626

  • trunk/kernel/libk/readlock.c

    r124 r457  
    2323
    2424#include <kernel_config.h>
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <hal_atomic.h>
    2727#include <hal_special.h>

  • trunk/kernel/libk/readlock.h

    r14 r457  
    2626
    2727#include <kernel_config.h>
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929
    3030/*******************************************************************************************

  • trunk/kernel/libk/remote_barrier.c

    r436 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <hal_remote.h>
    2626#include <hal_irqmask.h>

  • trunk/kernel/libk/remote_barrier.h

    r23 r457  
    2626
    2727#include <kernel_config.h>
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929#include <remote_spinlock.h>
    3030#include <xlist.h>

  • trunk/kernel/libk/remote_condvar.c

    r436 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <hal_remote.h>
    2626#include <hal_irqmask.h>

  • trunk/kernel/libk/remote_condvar.h

    r23 r457  
    2626
    2727#include <kernel_config.h>
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929#include <remote_spinlock.h>
    3030#include <xlist.h>

  • trunk/kernel/libk/remote_fifo.c

    r408 r457  
    2323 */
    2424
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <hal_irqmask.h>
    2727#include <hal_remote.h>

  • trunk/kernel/libk/remote_fifo.h

    r407 r457  
    2727
    2828#include <kernel_config.h>
    29 #include <hal_types.h>
     29#include <hal_kernel_types.h>
    3030#include <printk.h>
    3131#include <errno.h>

  • trunk/kernel/libk/remote_mutex.c

    r436 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <hal_remote.h>
    2626#include <hal_special.h>

  • trunk/kernel/libk/remote_mutex.h

    r23 r457  
    2626
    2727#include <kernel_config.h>
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929#include <xlist.h>
    3030

  • trunk/kernel/libk/remote_rwlock.c

    r438 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <hal_remote.h>
    2626#include <hal_irqmask.h>

  • trunk/kernel/libk/remote_rwlock.h

    r438 r457  
    2626
    2727#include <kernel_config.h>
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929#include <xlist.h>
    3030

  • trunk/kernel/libk/remote_sem.c

    r436 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <hal_remote.h>
    2626#include <thread.h>
    … …  
    7575
    7676///////////////////////////////////////////
    77 error_t remote_sem_create( intptr_t  vaddr,
    78                            uint32_t  value )
    79 {
     77error_t remote_sem_create( intptr_t   vaddr,
     78                           uint32_t   value,
     79                           xptr_t     sem_xp_xp )
     80{
     81    remote_sem_t * sem_ptr;
    8082    xptr_t         sem_xp;
    81     remote_sem_t * sem_ptr;
    8283
    8384    // get pointer on local process descriptor
    … …  
    103104    {
    104105        rpc_kcm_alloc_client( ref_cxy , KMEM_SEM , &sem_xp );
    105         sem_ptr = (remote_sem_t *)GET_PTR( sem_xp );
    106     }
    107 
    108     if( sem_xp == XPTR_NULL ) return ENOMEM;
     106        sem_ptr = GET_PTR( sem_xp );
     107    }
     108
     109    if( sem_xp == XPTR_NULL ) return -1;
    109110
    110111    // initialise semaphore
    111112    hal_remote_sw ( XPTR( ref_cxy , &sem_ptr->count ) , value );
    112113        hal_remote_spt( XPTR( ref_cxy , &sem_ptr->ident ) , (void *)vaddr );
    113 
    114114    remote_spinlock_init( XPTR( ref_cxy , &sem_ptr->lock ) );
    115115        xlist_root_init( XPTR( ref_cxy , &sem_ptr->root ) );
    … …  
    119119    xptr_t root_xp = XPTR( ref_cxy , &ref_ptr->sem_root );
    120120    xptr_t xp_list = XPTR( ref_cxy , &sem_ptr->list );
    121 
    122121    remote_spinlock_lock( XPTR( ref_cxy , &ref_ptr->sync_lock ) );
    123122    xlist_add_first( root_xp , xp_list );
    124123    remote_spinlock_unlock( XPTR( ref_cxy , &ref_ptr->sync_lock ) );
    125124
     125    // write extended pointer on semaphore in calling thread buffer
     126    hal_remote_swd( sem_xp_xp , sem_xp );
     127
    126128    return 0;
    127129
    128 }  // en remote_sem_init()
     130}  // en remote_sem_create()
    129131 
    130132////////////////////////////////////////
    … …  
    139141    // get reference process cluster and local pointer
    140142    cxy_t       ref_cxy = GET_CXY( ref_xp );
    141     process_t * ref_ptr = (process_t *)GET_PTR( ref_xp );
     143    process_t * ref_ptr = GET_PTR( ref_xp );
    142144
    143145    // get semaphore cluster and local pointer
    … …  
    148150    remote_spinlock_lock( XPTR( sem_cxy , &sem_ptr->lock ) );
    149151 
    150     // get remote pointer on waiting queue
    151     xptr_t root_xp = (xptr_t)hal_remote_lwd( XPTR( sem_cxy , &sem_ptr->root ) );
     152    // get remote pointer on waiting queue root
     153    xptr_t root_xp = XPTR( sem_cxy , &sem_ptr->root );
    152154 
    153155    if( !xlist_is_empty( root_xp ) )   // user error
    … …  
    184186}  // end remote_sem_destroy()
    185187
    186 //////////////////////////////////
     188/////////////////////////////////////
    187189void remote_sem_wait( xptr_t sem_xp )
    188190{
    189191    // get semaphore cluster and local pointer
    190192    cxy_t          sem_cxy = GET_CXY( sem_xp );
    191     remote_sem_t * sem_ptr = (remote_sem_t *)GET_PTR( sem_xp );
     193    remote_sem_t * sem_ptr = GET_PTR( sem_xp );
    192194
    193195    // get lock protecting semaphore     
    … …  
    210212
    211213        // register thread in waiting queue
    212         xptr_t root_xp   = (xptr_t)hal_remote_lwd( XPTR( sem_cxy , &sem_ptr->root ) );
    213         xptr_t thread_xp = XPTR( local_cxy , this );
    214                 xlist_add_last( root_xp , thread_xp );
     214        xptr_t root_xp = XPTR( sem_cxy   , &sem_ptr->root );
     215        xptr_t list_xp = XPTR( local_cxy , &this->wait_list );
     216                xlist_add_last( root_xp , list_xp );
    215217
    216218        // release lock
    … …  
    228230    // get semaphore cluster and local pointer
    229231    cxy_t          sem_cxy = GET_CXY( sem_xp );
    230     remote_sem_t * sem_ptr = (remote_sem_t *)GET_PTR( sem_xp );
     232    remote_sem_t * sem_ptr = GET_PTR( sem_xp );
    231233
    232234    // get lock protecting semaphore
    233235        remote_spinlock_lock( XPTR( sem_cxy , &sem_ptr->lock ) );
    234236 
     237    // get semaphore current value
     238    uint32_t count = hal_remote_lw( XPTR( sem_cxy , &sem_ptr->count ) );
     239
    235240    // get remote pointer on waiting queue root
    236     xptr_t root_xp = (xptr_t)hal_remote_lwd( XPTR( sem_cxy , &sem_ptr->root ) );
     241    xptr_t root_xp = XPTR( sem_cxy , &sem_ptr->root );
    237242 
    238243        if( xlist_is_empty( root_xp ) )   // no waiting thread
    239244    {
    240         // get semaphore current value
    241         uint32_t count = hal_remote_lw( XPTR( sem_cxy , &sem_ptr->count ) );
    242 
    243245        // increment semaphore value
    244246        hal_remote_sw( XPTR( sem_cxy , &sem_ptr->count ) , count + 1 );
    … …  
    251253        // get thread cluster and local poiner
    252254        cxy_t      thread_cxy = GET_CXY( thread_xp );
    253         thread_t * thread_ptr = (thread_t *)GET_PTR( thread_xp );
    254 
    255         // remove the thread from the waiting queue, and unblock
     255        thread_t * thread_ptr = GET_PTR( thread_xp );
     256
     257        // remove this thread from the waiting queue, and unblock it
    256258        xlist_unlink( XPTR( thread_cxy , &thread_ptr->wait_list ) );
    257259                thread_unblock( thread_xp , THREAD_BLOCKED_SEM );
    … …  
    270272    // get semaphore cluster and local pointer
    271273    cxy_t          sem_cxy = GET_CXY( sem_xp );
    272     remote_sem_t * sem_ptr = (remote_sem_t *)GET_PTR( sem_xp );
     274    remote_sem_t * sem_ptr = GET_PTR( sem_xp );
    273275
    274276    *data = hal_remote_lw( XPTR( sem_cxy , &sem_ptr->count ) );

  • trunk/kernel/libk/remote_sem.h

    r23 r457  
    2525#define _SEMAPHORE_H_
    2626
    27 #include <hal_types.h>
     27#include <hal_kernel_types.h>
    2828#include <xlist.h>
    2929#include <remote_spinlock.h>
    … …  
    7777 * This function implements the SEM_INIT operation.
    7878 * It allocates memory for a remote semaphore in reference cluster, using a RPC if required,
    79  * and initializes it, using remote accesses.
     79 * and initializes it, using remote accesses from values defined by the <vaddr> and <value>
     80 * arguments. It uses also a remote access to return the extended pointer on the semaphore
     81 * in the buffer identified by the <buf_xp> argument.
    8082 *********************************************************************************************
    81  * @ vaddr    : semaphore virtual address, used as identifier.
    82  * @ value    : semaphore initial value.
    83  * @ returns 0 if success / returns ENOMEM if error.
     83 * @ vaddr     : [in] semaphore virtual address, used as identifier.
     84 * @ value     : [in] semaphore initial value.
     85 * @ sem_xp_xp : [out] extended pointer on buffer to store extended pointer on semaphore.
     86 * @ returns 0 if success / returns -1 if no memory.
    8487 ********************************************************************************************/
    8588error_t remote_sem_create( intptr_t  vaddr,
    86                            uint32_t  value );
     89                           uint32_t  value,
     90                           xptr_t    sem_xp_xp );
    8791 
    8892/****************************yy***************************************************************
    … …  
    9195 * reference cluster, using a RPC if required.
    9296 *********************************************************************************************
    93  * @ sem_xp   : extended pointer on semaphore.
     97 * @ sem_xp   : [in] extended pointer on semaphore.
    9498 ********************************************************************************************/
    9599void remote_sem_destroy( xptr_t sem_xp );
    … …  
    102106 *    waiting queue, block the thread, and yield.
    103107 *********************************************************************************************
    104  * @ sem_xp   : extended pointer on semaphore.
     108 * @ sem_xp   : [in] extended pointer on semaphore.
    105109 ********************************************************************************************/
    106110void remote_sem_wait( xptr_t sem_xp );
    … …  
    111115 * - If the waiting queue is not empty, it wakes up the first waiting thread.
    112116 *********************************************************************************************
    113  * @ sem_xp   : extended pointer on semaphore.
     117 * @ sem_xp   : [in] extended pointer on semaphore.
    114118 ********************************************************************************************/
    115119void remote_sem_post( xptr_t sem_xp );
    … …  
    119123 * It returns in the <data> buffer the semaphore current value.
    120124 *********************************************************************************************
    121  * @ sem_xp   : extended pointer on semaphore.
    122  * @ data     : [out] returned value.
     125 * @ sem_xp   : [in]  extended pointer on semaphore.
     126 * @ data     : [out] local pointer on buffer for returned value.
    123127 ********************************************************************************************/
    124128void remote_sem_get_value( xptr_t      sem_xp,

  • trunk/kernel/libk/remote_spinlock.c

    r443 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <hal_remote.h>
    2626#include <hal_irqmask.h>

  • trunk/kernel/libk/remote_spinlock.h

    r438 r457  
    2626
    2727#include <kernel_config.h>
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929#include <xlist.h>
    3030

  • trunk/kernel/libk/rwlock.c

    r438 r457  
    2323
    2424#include <kernel_config.h>
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <hal_atomic.h>
    2727#include <hal_special.h>

  • trunk/kernel/libk/rwlock.h

    r438 r457  
    2626
    2727#include <kernel_config.h>
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929#include <list.h>
    3030

  • trunk/kernel/libk/spinlock.c

    r438 r457  
    2424
    2525#include <kernel_config.h>
    26 #include <hal_types.h>
     26#include <hal_kernel_types.h>
    2727#include <hal_atomic.h>
    2828#include <hal_special.h>

  • trunk/kernel/libk/spinlock.h

    r438 r457  
    2626
    2727#include <kernel_config.h>
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929#include <list.h>
    3030

  • trunk/kernel/libk/string.c

    r337 r457  
    2323 */
    2424
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <ctype.h>
    2727#include <string.h>

  • trunk/kernel/libk/string.h

    r323 r457  
    2626#define _STRING_H_
    2727
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929
    3030

  • trunk/kernel/libk/xhtab.c

    r423 r457  
    2323
    2424#include <kernel_config.h>
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <hal_special.h>
    2727#include <hal_remote.h>

  • trunk/kernel/libk/xhtab.h