Changeset 457 for trunk/kernel


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/kernel
Files:
154 edited

Legend:

Unmodified
Added
Removed

  • 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

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

  • trunk/kernel/libk/xlist.h

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

  • trunk/kernel/mm/kcm.c

    r438 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 <list.h>

  • trunk/kernel/mm/kcm.h

    r437 r457  
    2727
    2828#include <list.h>
    29 #include <hal_types.h>
     29#include <hal_kernel_types.h>
    3030#include <spinlock.h>
    3131#include <page.h>

  • trunk/kernel/mm/khm.c

    r315 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 <spinlock.h>

  • trunk/kernel/mm/khm.h

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

  • trunk/kernel/mm/kmem.c

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

  • trunk/kernel/mm/kmem.h

    r188 r457  
    2727#define _KMEM_H_
    2828
    29 #include <hal_types.h>
     29#include <hal_kernel_types.h>
    3030#include <kcm.h>
    3131

  • trunk/kernel/mm/mapper.c

    r440 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 <hal_uspace.h>

  • trunk/kernel/mm/mapper.h

    r440 r457  
    2626#define _MAPPER_H_
    2727
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929#include <hal_atomic.h>
    3030#include <xlist.h>

  • trunk/kernel/mm/page.c

    r436 r457  
    2323 */
    2424
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <hal_special.h>
    2727#include <hal_atomic.h>

  • trunk/kernel/mm/page.h

    r433 r457  
    2727
    2828#include <kernel_config.h>
    29 #include <hal_types.h>
     29#include <hal_kernel_types.h>
    3030#include <spinlock.h>
    3131#include <list.h>

  • trunk/kernel/mm/ppm.c

    r438 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 <printk.h>

  • trunk/kernel/mm/ppm.h

    r433 r457  
    2626#define _PPM_H_
    2727
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929#include <list.h>
    3030#include <spinlock.h>

  • trunk/kernel/mm/vmm.c

    r443 r457  
    2525
    2626#include <kernel_config.h>
    27 #include <hal_types.h>
     27#include <hal_kernel_types.h>
    2828#include <hal_special.h>
    2929#include <hal_gpt.h>
    … …  
    170170    vmm->stack_mgr.bitmap   = 0;
    171171    vmm->stack_mgr.vpn_base = CONFIG_VMM_STACK_BASE;
     172    spinlock_init( &vmm->stack_mgr.lock );
    172173
    173174    // initialize MMAP allocator
    … …  
    175176    vmm->mmap_mgr.vpn_size        = CONFIG_VMM_STACK_BASE - CONFIG_VMM_HEAP_BASE;
    176177    vmm->mmap_mgr.first_free_vpn  = CONFIG_VMM_HEAP_BASE;
     178    spinlock_init( &vmm->mmap_mgr.lock );
     179
    177180    uint32_t i;
    178181    for( i = 0 ; i < 32 ; i++ ) list_root_init( &vmm->mmap_mgr.zombi_list[i] );
    … …  
    201204    gpt_t * gpt = &vmm->gpt;
    202205
    203     printk("\n***** VSL and GPT for process %x in cluster %x\n\n", process->pid , local_cxy );
     206    printk("\n***** VSL and GPT(%x) for process %x in cluster %x\n\n",
     207    process->vmm.gpt.ptr , process->pid , local_cxy );
    204208
    205209    // get lock protecting the vseg list

  • trunk/kernel/mm/vmm.h

    r440 r457  
    2727#define _VMM_H_
    2828
    29 #include <hal_types.h>
     29#include <hal_kernel_types.h>
    3030#include <bits.h>
    3131#include <list.h>

  • trunk/kernel/mm/vseg.c

    r453 r457  
    2424 */
    2525
    26 #include <hal_types.h>
     26#include <hal_kernel_types.h>
    2727#include <hal_special.h>
    2828#include <hal_remote.h>
    … …  
    171171    switch (vseg->type)
    172172    {
    173         case VSEG_TYPE_DATA: {
     173        case VSEG_TYPE_DATA:
     174        {
    174175            vseg->cxy = 0xffff;
    175176            break;
    176177        }
    177178        case VSEG_TYPE_CODE:
    178         case VSEG_TYPE_STACK: {
     179        case VSEG_TYPE_STACK:
     180        {
    179181            vseg->cxy = local_cxy;
    180182            break;
    … …  
    182184        case VSEG_TYPE_ANON:
    183185        case VSEG_TYPE_FILE:
    184         case VSEG_TYPE_REMOTE: {
     186        case VSEG_TYPE_REMOTE:
     187        {
    185188            vseg->cxy = (cxy_t) hal_remote_lw( XPTR(cxy, &ptr->cxy) );
    186189            break;
    187190        }
    188         default: {
     191        default:
     192        {
    189193            assert( false, __FUNCTION__, "Illegal vseg type" );
    190194            break;

  • trunk/kernel/mm/vseg.h

    r454 r457  
    2727#define _VSEG_H_
    2828
    29 #include <hal_types.h>
     29#include <hal_kernel_types.h>
    3030#include <spinlock.h>
    3131#include <vfs.h>

  • trunk/kernel/syscalls/shared_include/shared_pthread.h

    r445 r457  
    2929 ******************************************************************************************/
    3030
    31 typedef unsigned int      sem_t;
    3231typedef unsigned int      pthread_cond_t;
    3332typedef unsigned int      pthread_condattr_t;
    … …  
    5655    PT_ATTR_CORE_DEFINED    = 0x0004,  /*! user defined core index in cluster             */
    5756};
    58 
    59 /*******************************************************************************************
    60  * This enum defines the operation mnemonics for operations on POSIX unnamed semaphores.
    61  ******************************************************************************************/
    62 
    63 typedef enum
    64 {
    65         SEM_INIT,
    66         SEM_DESTROY,
    67         SEM_GETVALUE,
    68         SEM_WAIT,
    69         SEM_POST,
    70 }
    71 sem_operation_t;
    7257
    7358/*******************************************************************************************

  • trunk/kernel/syscalls/shared_include/syscalls_numbers.h

    r444 r457  
    6262    SYS_TRACE          = 47,
    6363    SYS_FG             = 48,
    64     SYS_UNDEFINED_49   = 49,   ///
     64    SYS_IS_FG          = 49,
    6565
    6666        SYSCALLS_NR        = 50,

  • trunk/kernel/syscalls/sys_alarm.c

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

  • trunk/kernel/syscalls/sys_barrier.c

    r440 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/syscalls/sys_chdir.c

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

  • trunk/kernel/syscalls/sys_chmod.c

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

  • trunk/kernel/syscalls/sys_close.c

    r124 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 <vfs.h>

  • trunk/kernel/syscalls/sys_closedir.c

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

  • trunk/kernel/syscalls/sys_condvar.c

    r440 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/syscalls/sys_creat.c

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

  • trunk/kernel/syscalls/sys_display.c

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

  • trunk/kernel/syscalls/sys_exec.c

    r441 r457  
    2323
    2424#include <kernel_config.h>
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <hal_uspace.h>
    2727#include <errno.h>
    … …  
    152152// It build an exec_info_t structure containing all informations
    153153// required to initialize the new process descriptor and the associated thread.
    154 // It includes the process main() arguments, the environment variables,
     154// It includes the new process main() arguments, the environment variables,
    155155// and the pathname to the new process .elf file.
    156156// It calls the process_exec_get_strings() functions to copy the main() arguments and
    157157// the environment variables from user buffers to the exec_info_t structure, allocate
    158158// and call the process_make_exec() function.
    159 // As it must destroy all parent process copies, and all parent threads in all clusters,
    160 // the process_make_exec() function must be executed in the parent owner cluster,
    161 // and this sys_exec() function uses a RPC to access the owner cluster if required.
     159// As it must destroy all process copies, and all othert threads in all clusters,
     160// the process_make_exec() function must be executed in the owner cluster.
    162161//
    163162// TODO : the args & envs arguments are not supported yet : both must be NULL  [AG]
    … …  
    187186    "args not supported yet\n" );
    188187
    189     // get owner cluster
    190 
    191188    // check pathname length
    192189    if( hal_strlen_from_uspace( pathname ) >= CONFIG_VFS_MAX_PATH_LENGTH )
    … …  
    205202#if DEBUG_SYS_EXEC
    206203uint64_t      tm_start;
    207 uint64_t      tm_end;
    208204tm_start = hal_get_cycles();
    209205if( DEBUG_SYS_EXEC < tm_start )
    210206printk("\n[DBG] %s : thread %x in process %x enter for path <%s> / cycle = %d\n",
    211 __FUNCTION__, this, pid, exec_info.path, (uint32_t)tm_start );
     207__FUNCTION__, this->trdid, pid, exec_info.path, (uint32_t)tm_start );
    212208#endif
    213209
    … …  
    220216#if DEBUG_SYSCALLS_ERROR
    221217printk("\n[ERROR] in %s : thread %x in process %x cannot access args\n",
    222 __FUNCTION__ , this, pid );
     218__FUNCTION__ , this->trdid, pid );
    223219#endif
    224220            this->errno = EINVAL;
    … …  
    235231#if DEBUG_SYCALLS_ERROR
    236232printk("\n[ERROR] in %s : thread %x in process %x cannot access envs\n",
    237 __FUNCTION__ , this, pid );
     233__FUNCTION__ , this->trdid, pid );
    238234#endif
    239235            this->errno = EINVAL;
    … …  
    250246#if DEBUG_SYSCALLS_ERROR
    251247printk("\n[ERROR] in %s : thread %x in process %x cannot create process for <%s>\n",
    252 __FUNCTION__, this, pid, exec_info.path );
     248__FUNCTION__, this->trdid, pid, exec_info.path );
    253249#endif
    254250        this->errno = error;
    … …  
    256252    }
    257253
    258 #if DEBUG_SYS_EXEC
    259 tm_end = hal_get_cycles();
    260 if( DEBUG_SYS_EXEC < tm_end )
    261 printk("\n[DBG] %s : thread %x in process %x exit / cost = %d / cycle %d\n",
    262 __FUNCTION__, this, pid, (uint32_t)(tm_end - tm_start), (uint32_t)tm_end );
    263 #endif
    264 
    265     // In case of success, this calling thread deschedules, causing suicide,
    266     // because a new process descriptor and its associated main thread
    267     // have been created by the process_make_exec() function, and the
    268     // BLOCKED_GLOBAL & FLAG_REQ_DELETE bits have been set for the calling thread.
    269     sched_yield( "old process suicide in sys_exec()" );
     254    assert( false , __FUNCTION__, "we should not execute this code" );
    270255
    271256    return 0; 

  • trunk/kernel/syscalls/sys_exit.c

    r446 r457  
    2323
    2424#include <kernel_config.h>
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <hal_irqmask.h>
    2727#include <errno.h>
    … …  
    5959tm_start = hal_get_cycles();
    6060if( DEBUG_SYS_EXIT < tm_start )
    61 printk("\n[DBG] %s : thread %x enter / process %x / status %x / cycle %d\n",
    62 __FUNCTION__ , this, pid , status , (uint32_t)tm_start );
     61printk("\n[DBG] %s : thread %x in process %x enter / status %x / cycle %d\n",
     62__FUNCTION__, this->trdid, process->pid , status , (uint32_t)tm_start );
    6363#endif
    6464
    … …  
    7070#if (DEBUG_SYS_EXIT & 1)
    7171if( DEBUG_SYS_EXIT < tm_start )
    72 printk("\n[DBG] %s : thread %x get owner process %x in cluster %x\n",
    73 __FUNCTION__ , this, owner_ptr, owner_cxy );
     72printk("\n[DBG] %s : thread %x in process %x get owner process %x in cluster %x\n",
     73__FUNCTION__, this->trdid, process->pid, owner_ptr, owner_cxy );
    7474#endif
    7575
    76     // get pointer on the process main thread
     76    // get local pointer on the process main thread
    7777    main_ptr  = hal_remote_lpt( XPTR( owner_cxy , &owner_ptr->th_tbl[0] ) );
    7878
    … …  
    8484#if (DEBUG_SYS_EXIT & 1)
    8585if( DEBUG_SYS_EXIT < tm_start )
    86 printk("\n[DBG] %s : thread %x get parent process %x in cluster %x\n",
    87 __FUNCTION__ , this, parent_ptr, parent_cxy );
     86printk("\n[DBG] %s : thread %x in process %x get parent process %x in cluster %x\n",
     87__FUNCTION__, this->trdid, process->pid, parent_ptr, parent_cxy );
    8888#endif
    8989
    … …  
    9999
    100100#if( DEBUG_SYS_EXIT & 1)
    101 if( tm_start > DEBUG_SYS_EXIT )
    102 printk("\n[DBG] %s : thread %x removed process %x from TXT list\n",
    103 __FUNCTION__ , this, pid );
     101if( DEBUG_SYS_EXIT < tm_start )
     102printk("\n[DBG] %s : thread %x in process %x detached process from TXT\n",
     103__FUNCTION__, this->trdid, process->pid );
    104104#endif
    105105
    … …  
    107107    // but the main thread and this calling thread
    108108    hal_enable_irq( &save_sr );
    109     process_sigaction( pid , DELETE_ALL_THREADS );
     109    process_sigaction( process->pid , DELETE_ALL_THREADS );
    110110    hal_restore_irq( save_sr );
    111111
    112112#if( DEBUG_SYS_EXIT & 1)
    113 if( tm_start > DEBUG_SYS_EXIT )
    114 printk("\n[DBG] %s : thread %x deleted threads for process %x\n",
    115 __FUNCTION__ , this, pid );
     113if( DEBUG_SYS_EXIT < tm_start )
     114printk("\n[DBG] %s : thread %x in process %x deleted all threads but itself\n",
     115__FUNCTION__, this->trdid, process->pid );
    116116#endif
    117117
    … …  
    122122#if( DEBUG_SYS_EXIT & 1)
    123123if( tm_start > DEBUG_SYS_EXIT )
    124 printk("\n[DBG] %s : calling thread %x marked iself for delete in process %x\n",
    125 __FUNCTION__ , this, pid );
     124printk("\n[DBG] %s : thread %x in process %x marked iself for delete\n",
     125__FUNCTION__, this->trdid, process->pid );
    126126#endif
    127127        thread_delete( XPTR( local_cxy , this ) , pid , true );
    … …  
    133133#if( DEBUG_SYS_EXIT & 1)
    134134if( tm_start > DEBUG_SYS_EXIT )
    135 printk("\n[DBG] %s : thread %x blocked main thread for process %x\n",
    136 __FUNCTION__, this , pid );
     135printk("\n[DBG] %s : thread %x in process %x blocked main thread\n",
     136__FUNCTION__, this->trdid, process->pid );
    137137#endif
    138138
    … …  
    144144#if( DEBUG_SYS_EXIT & 1)
    145145if( tm_start > DEBUG_SYS_EXIT )
    146 printk("\n[DBG] %s : thread %x set exit status in process %x / term_state %x\n",
    147 __FUNCTION__ , this, pid, term_state );
     146printk("\n[DBG] %s : thread %x in process %x set exit status %x in owner process\n",
     147__FUNCTION__, this->trdid, process->pid, term_state );
    148148#endif
    149149
    150     // take the children lock and unblock the parent process main thread
     150    // unblock the parent process main thread
    151151    remote_spinlock_lock( children_lock_xp );
    152152    thread_unblock( parent_main_xp , THREAD_BLOCKED_WAIT );
    … …  
    155155#if( DEBUG_SYS_EXIT & 1)
    156156if( tm_start > DEBUG_SYS_EXIT )
    157 printk("\n[DBG] %s : thread %x in cluster %x unblock parent main thread %x in cluster %x\n",
    158 __FUNCTION__ , this, local_cxy, parent_main_ptr, parent_cxy );
     157printk("\n[DBG] %s : thread %x in process %x unblock parent main thread in process %x\n",
     158__FUNCTION__ , this->trdid, process->pid,
     159hal_remote_lw( XPTR( parent_cxy , &parent_ptr->pid) ) );
    159160#endif
    160161
    … …  
    164165tm_end = hal_get_cycles();
    165166if( DEBUG_SYS_EXIT < tm_end )
    166 printk("\n[DBG] %s : thread %x exit / process %x / status %x / cost = %d / cycle %d\n",
    167 __FUNCTION__, this, pid, status, (uint32_t)(tm_end - tm_start), (uint32_t)tm_end );
     167printk("\n[DBG] %s : thread %x in process %x exit / status %x / cost = %d / cycle %d\n",
     168__FUNCTION__, this->trdid, process->pid, status,
     169(uint32_t)(tm_end - tm_start), (uint32_t)tm_end );
    168170#endif
    169171

  • trunk/kernel/syscalls/sys_fg.c

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

  • trunk/kernel/syscalls/sys_fork.c

    r440 r457  
    2323
    2424#include <kernel_config.h>
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <hal_context.h>
    2727#include <hal_switch.h>
    … …  
    7070tm_start = hal_get_cycles();
    7171if( DEBUG_SYS_FORK < tm_start )
    72 printk("\n[DBG] %s : parent_thread %x enter / parent_pid %x / cycle =  %d\n",
    73 __FUNCTION__, parent_thread_ptr, parent_pid, (uint32_t)tm_start );
     72printk("\n[DBG] %s : thread %x in process %x enter / cycle =  %d\n",
     73__FUNCTION__, parent_thread_ptr->trdid, parent_pid, (uint32_t)tm_start );
    7474#endif
    7575
    … …  
    106106#if (DEBUG_SYS_FORK & 1 )
    107107if( DEBUG_SYS_FORK < tm_start )
    108 printk("\n[DBG] %s : parent_thread %x selected cluster %x\n",
    109 __FUNCTION__, parent_thread_ptr, child_cxy );
     108printk("\n[DBG] %s : thread %x in process %x selected cluster %x\n",
     109__FUNCTION__, parent_thread_ptr->trdid, parent_pid, child_cxy );
    110110#endif
    111111
    … …  
    165165tm_end = hal_get_cycles();
    166166if( DEBUG_SYS_FORK < tm_end )
    167 printk("\n[DBG] %s : parent_thread %x on cluster %x exit / cost = %d / cycle %d\n",
    168 __FUNCTION__, parent_thread_ptr, parent_cxy, (uint32_t)(tm_end - tm_start), (uint32_t)tm_end );
     167printk("\n[DBG] %s : process %x exit / cost = %d / cycle %d\n",
     168__FUNCTION__, parent_pid, (uint32_t)(tm_end - tm_start), (uint32_t)tm_end );
    169169#endif
    170 
    171170        return child_pid;
    172171    }
    … …  
    177176tm_end = hal_get_cycles();
    178177if( DEBUG_SYS_FORK < tm_end )
    179 printk("\n[DBG] %s : child_thread %x on cluster %x exit / cost = %d / cycle %d\n",
    180 __FUNCTION__, child_thread_ptr, child_cxy, (uint32_t)(tm_end - tm_start), (uint32_t)tm_end );
     178printk("\n[DBG] %s : process %x exit / cost = %d / cycle %d\n",
     179__FUNCTION__, child_pid, (uint32_t)(tm_end - tm_start), (uint32_t)tm_end );
    181180#endif
    182 
    183181        return 0;
    184182    }

  • trunk/kernel/syscalls/sys_get_config.c

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

  • trunk/kernel/syscalls/sys_get_core.c

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

  • trunk/kernel/syscalls/sys_get_cycle.c

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

  • trunk/kernel/syscalls/sys_getcwd.c

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

  • trunk/kernel/syscalls/sys_isatty.c

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

  • trunk/kernel/syscalls/sys_kill.c

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

  • trunk/kernel/syscalls/sys_lseek.c

    r23 r457  
    2222
    2323#include <kernel_config.h>
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <hal_uspace.h>
    2626#include <errno.h>

  • trunk/kernel/syscalls/sys_mkdir.c

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

  • trunk/kernel/syscalls/sys_mkfifo.c

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

  • trunk/kernel/syscalls/sys_mmap.c

    r440 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/kernel/syscalls/sys_munmap.c

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

  • trunk/kernel/syscalls/sys_mutex.c

    r440 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/syscalls/sys_open.c

    r407 r457  
    2323
    2424#include <kernel_config.h>
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <hal_uspace.h>
    2727#include <errno.h>

  • trunk/kernel/syscalls/sys_opendir.c

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

  • trunk/kernel/syscalls/sys_pipe.c

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

  • trunk/kernel/syscalls/sys_read.c

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

  • trunk/kernel/syscalls/sys_readdir.c

    r407 r457  
    2323
    2424#include <kernel_config.h>
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <hal_uspace.h>
    2727#include <errno.h>

  • trunk/kernel/syscalls/sys_rmdir.c

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

  • trunk/kernel/syscalls/sys_sem.c

    r440 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <hal_uspace.h>
     26#include <shared_semaphore.h>
    2627#include <errno.h>
    2728#include <thread.h>
    … …  
    3132#include <syscalls.h>
    3233
     34#if DEBUG_SYS_SEM
     35//////////////////////////////////////////////////
     36static char * sys_sem_op_str( uint32_t operation )
     37{
     38        if     ( operation == SEM_INIT     ) return "INIT";
     39        else if( operation == SEM_WAIT     ) return "WAIT";
     40        else if( operation == SEM_POST     ) return "POST";
     41        else if( operation == SEM_GETVALUE ) return "GETVALUE";
     42        else if( operation == SEM_DESTROY  ) return "DESTROY";
     43        else                                 return "undefined";
     44}
     45#endif
     46
    3347//////////////////////////////////
    34 int sys_sem( void         * vaddr,        // semaphore virtual  address
    35              uint32_t       operation,    // requested operation type
    36              uint32_t     * value )       // pointer on in/out argument
     48int sys_sem( void         * vaddr,            // semaphore virtual  address
     49             uint32_t       operation,        // requested operation type
     50             uint32_t       init_value,       // initial value
     51             uint32_t     * current_value )   // pointer on current value buffer
    3752{
    38         uint32_t         data;   
    3953        vseg_t         * vseg;
    4054    error_t          error;
     55    uint32_t         current;     // semaphore current value
     56    xptr_t           sem_xp;      // extended pointer on semaphore
    4157
    4258    thread_t       * this    = CURRENT_THREAD;
    4359    process_t      * process = this->process;
     60
     61#if DEBUG_SYS_SEM
     62uint64_t    tm_start;
     63uint64_t    tm_end;
     64tm_start = hal_get_cycles();
     65if( DEBUG_SYS_SEM < tm_start )
     66printk("\n[DBG] %s : thread %x in process %x enter for %s / cycle %d\n",
     67__FUNCTION__, this->trdid, process->pid, sys_sem_op_str( operation ), (uint32_t)tm_start );
     68#endif
    4469
    4570    // check vaddr in user vspace
    … …  
    4974
    5075#if DEBUG_SYSCALLS_ERROR
    51 printk("\n[ERROR] in %s : unmapped semaphore %x / thread %x / process %x\n",
    52 __FUNCTION__ , (intptr_t)vaddr, this->trdid, process->pid );
    53 vmm_display( process , false );
    54 #endif
    55         this->errno = EINVAL;
    56         return -1;
    57     }
    58 
    59     // check value in user vspace
    60         error = vmm_get_vseg( process , (intptr_t)value , &vseg );
    61         if( error )
    62     {
    63 
    64 #if DEBUG_SYSCALLS_ERROR
    65 printk("\n[ERROR] in %s : unmapped value %x / thread %x / process %x\n",
     76printk("\n[ERROR] in %s : unmapped semaphore pointer %x / thread %x in process %x\n",
    6677__FUNCTION__ , (intptr_t)vaddr, this->trdid, process->pid );
    6778vmm_display( process , false );
    … …  
    7788            case SEM_INIT:
    7889        {
    79             // get argument
    80                     hal_copy_from_uspace( &data , value , sizeof(uint32_t) );
    81 
    82             // call init function
    83             error = remote_sem_create( (intptr_t)vaddr , data );
     90            // call relevant kernel function to initialize semaphore
     91            error = remote_sem_create( (intptr_t)vaddr ,
     92                                       init_value,
     93                                       XPTR( local_cxy , &sem_xp ) );
    8494
    8595            if ( error )
    8696            {
    87                 printk("\n[ERROR] in %s : cannot create semaphore = %x\n",
    88                        __FUNCTION__ , (intptr_t)value );
    89                 this->errno = error;
    90                 return -1;
    91             }
     97
     98#if DEBUG_SYSCALLS_ERROR
     99printk("\n[ERROR] in %s : cannot create semaphore / thread %x in process %x\n",
     100__FUNCTION__, this->trdid, process->pid );
     101#endif
     102                this->errno = ENOMEM;
     103                return -1;
     104            }
     105
    92106            break;
    93107        }
    … …  
    95109        case SEM_GETVALUE:
    96110        {
    97             // get extended pointer on remote semaphore
    98             xptr_t sem_xp = remote_sem_from_vaddr( (intptr_t)vaddr );
    99 
    100             if( sem_xp == XPTR_NULL )     // user error
    101             {
    102 
    103 #if DEBUG_SYSCALLS_ERROR
    104 printk("\n[ERROR] in %s : semaphore %x not registered / thread %x / process %x\n",
    105 __FUNCTION__ , (intptr_t)value, this->trdid, process->pid );
    106 #endif
    107                 this->errno = EINVAL;
    108                 return -1;
    109             }
    110             else                          // success
    111             {
    112                 // get semaphore current value
    113                         remote_sem_get_value( sem_xp , &data );
     111            // check current_value buffer in user vspace
     112                error = vmm_get_vseg( process , (intptr_t)current_value , &vseg );
     113            if( error )
     114            {
     115
     116#if DEBUG_SYSCALLS_ERROR
     117printk("\n[ERROR] in %s : unmapped buffer for current value %x / thread %x in process %x\n",
     118__FUNCTION__ , (intptr_t)current_value, this->trdid, process->pid );
     119vmm_display( process , false );
     120#endif
     121                this->errno = EINVAL;
     122                return -1;
     123            }
     124
     125            // get extended pointer on remote semaphore
     126            sem_xp = remote_sem_from_vaddr( (intptr_t)vaddr );
     127
     128            // check semaphore registered
     129            if( sem_xp == XPTR_NULL )
     130            {
     131
     132#if DEBUG_SYSCALLS_ERROR
     133printk("\n[ERROR] in %s : semaphore %x not registered / thread %x in process %x\n",
     134__FUNCTION__ , (intptr_t)vaddr, this->trdid, process->pid );
     135#endif
     136                this->errno = EINVAL;
     137                return -1;
     138            }
     139
     140            // call relevant kernel function to get semaphore current value
     141                    remote_sem_get_value( sem_xp , &current );
    114142 
    115                 // return value to user
    116                 hal_copy_to_uspace( value , &data , sizeof(uint32_t) );
    117             }
     143            // return value to user
     144            hal_copy_to_uspace( current_value , &current , sizeof(uint32_t) );
     145
    118146            break;
    119147        }
    … …  
    122150        { 
    123151            // get extended pointer on remote semaphore
    124             xptr_t sem_xp = remote_sem_from_vaddr( (intptr_t)vaddr );
    125 
    126             if( sem_xp == XPTR_NULL )     // user error
    127             {
    128 
    129 #if DEBUG_SYSCALLS_ERROR
    130 printk("\n[ERROR] in %s : semaphore %x not registered / thread %x / process %x\n",
    131 __FUNCTION__ , (intptr_t)value, this->trdid, process->pid );
    132 #endif
    133                 this->errno = EINVAL;
    134                 return -1;
    135             }
    136             else                          // success
    137             {
    138                 // wait semaphore available
    139                 remote_sem_wait( sem_xp );
    140             }
     152            sem_xp = remote_sem_from_vaddr( (intptr_t)vaddr );
     153
     154            // check semaphore registered
     155            if( sem_xp == XPTR_NULL )
     156            {
     157
     158#if DEBUG_SYSCALLS_ERROR
     159printk("\n[ERROR] in %s : semaphore %x not registered / thread %x in process %x\n",
     160__FUNCTION__ , (intptr_t)vaddr, this->trdid, process->pid );
     161#endif
     162                this->errno = EINVAL;
     163                return -1;
     164            }
     165
     166            // call relevant kernel function to wait semaphore available
     167            remote_sem_wait( sem_xp );
     168           
    141169            break;
    142170        }
    … …  
    145173        {
    146174            // get extended pointer on remote semaphore
    147             xptr_t sem_xp = remote_sem_from_vaddr( (intptr_t)vaddr );
    148 
    149             if( sem_xp == XPTR_NULL )     // user error
    150             {
    151 
    152 #if DEBUG_SYSCALLS_ERROR
    153 printk("\n[ERROR] in %s : semaphore %x not registered / thread %x / process %x\n",
    154 __FUNCTION__ , (intptr_t)value, this->trdid, process->pid );
    155 #endif
    156                 this->errno = EINVAL;
    157                 return -1;
    158             }
    159             else                          // success
    160             {
    161                 // release semaphore
    162                 remote_sem_post( sem_xp );
    163             }
     175            sem_xp = remote_sem_from_vaddr( (intptr_t)vaddr );
     176
     177            // check semaphore registered
     178            if( sem_xp == XPTR_NULL )
     179            {
     180
     181#if DEBUG_SYSCALLS_ERROR
     182printk("\n[ERROR] in %s : semaphore %x not registered / thread %x in process %x\n",
     183__FUNCTION__ , (intptr_t)vaddr, this->trdid, process->pid );
     184#endif
     185                this->errno = EINVAL;
     186                return -1;
     187            }
     188
     189            // call relevant kernel function to release semaphore
     190            remote_sem_post( sem_xp );
     191
    164192                        break;
    165193        }
    … …  
    168196        {
    169197            // get extended pointer on remote semaphore
    170             xptr_t sem_xp = remote_sem_from_vaddr( (intptr_t)vaddr );
    171 
    172             if( sem_xp == XPTR_NULL )     // user error
    173             {
    174 
    175 #if DEBUG_SYSCALLS_ERROR
    176 printk("\n[ERROR] in %s : semaphore %x not registered / thread %x / process %x\n",
    177 __FUNCTION__ , (intptr_t)value, this->trdid, process->pid );
    178 #endif
    179                 this->errno = EINVAL;
    180                 return -1;
    181             }
    182             else                          // success
    183             {
    184                 // destroy semaphore
    185                 remote_sem_destroy( sem_xp );
    186             }
     198            sem_xp = remote_sem_from_vaddr( (intptr_t)vaddr );
     199
     200            // check semaphore registered
     201            if( sem_xp == XPTR_NULL )
     202            {
     203
     204#if DEBUG_SYSCALLS_ERROR
     205printk("\n[ERROR] in %s : semaphore %x not registered / thread %x in process %x\n",
     206__FUNCTION__ , (intptr_t)vaddr, this->trdid, process->pid );
     207#endif
     208                this->errno = EINVAL;
     209                return -1;
     210            }
     211
     212            // destroy semaphore
     213            remote_sem_destroy( sem_xp );
     214
    187215            break;
    188216            }   
    … …  
    190218            default:  // undefined operation                       
    191219        {
    192             printk("\n[PANIC] in %s : illegal operation type\n", __FUNCTION__ );
    193             hal_core_sleep();
     220
     221#if DEBUG_SYSCALLS_ERROR
     222printk("\n[ERROR] in %s : undefined operation type %d / thread %x in process %x\n",
     223__FUNCTION__ , operation, this->trdid, process->pid );
     224#endif
     225            this->errno = EINVAL;
     226            return -1;
    194227        }
    195228        }
    196229
     230    hal_fence();
     231
     232#if DEBUG_SYS_SEM
     233tm_end = hal_get_cycles();
     234if( DEBUG_SYS_SEM < tm_end )
     235{
     236    cxy_t          sem_cxy = GET_CXY( sem_xp );
     237    remote_sem_t * sem_ptr = GET_PTR( sem_xp );
     238    uint32_t       value   = hal_remote_lw( XPTR( sem_cxy , &sem_ptr->count ) );
     239    printk("\n[DBG] %s : thread %x in process %x exit for %s / value %d / cost = %d / cycle %d\n",
     240    __FUNCTION__, this->trdid, process->pid, sys_sem_op_str( operation ), value,
     241    (uint32_t)(tm_end - tm_start), (uint32_t)tm_end );
     242}
     243#endif
     244
    197245    return 0;
    198246

  • trunk/kernel/syscalls/sys_signal.c

    r435 r457  
    2323 */
    2424
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <errno.h>
    2727#include <thread.h>

  • trunk/kernel/syscalls/sys_stat.c

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

  • trunk/kernel/syscalls/sys_thread_cancel.c

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

  • trunk/kernel/syscalls/sys_thread_create.c

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

  • trunk/kernel/syscalls/sys_thread_detach.c

    r23 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/syscalls/sys_thread_exit.c

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

  • trunk/kernel/syscalls/sys_thread_join.c

    r438 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/syscalls/sys_thread_wakeup.c

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

  • trunk/kernel/syscalls/sys_thread_yield.c

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

  • trunk/kernel/syscalls/sys_timeofday.c

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

  • trunk/kernel/syscalls/sys_trace.c

    r443 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/syscalls/sys_unlink.c

    r407 r457  
    2121 */
    2222
    23 #include <hal_types.h>
     23#include <hal_kernel_types.h>
    2424#include <hal_uspace.h>
    2525#include <vfs.h>

  • trunk/kernel/syscalls/sys_utls.c

    r23 r457  
    2323 */
    2424
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <errno.h>
    2727#include <thread.h>

  • trunk/kernel/syscalls/sys_wait.c

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

  • trunk/kernel/syscalls/sys_write.c

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

  • trunk/kernel/syscalls/syscalls.h

    r445 r457  
    22 * syscalls.h - Kernel side services for syscall handling.
    33 *
    4  * Author     Alain Greiner (2016,2017)
     4 * Author     Alain Greiner (2016,2017,2018)
    55 *
    66 * Copyright (c) UPMC Sorbonne Universites
    … …  
    2525#define _SYSCALLS_H_
    2626
    27 #include <hal_types.h>
     27#include <hal_kernel_types.h>
    2828#include <shared_syscalls.h>
    2929
    … …  
    116116 * and the code implementing the operations is in the remore_sem.c file.
    117117 ******************************************************************************************
    118  * @ vaddr     : semaphore virtual address in user space == identifier.
    119  * @ operation : SEM_INIT / SEM_DESTROY / SEM_GETVALUE / SEM_POST / SEM_WAIT.
    120  * @ value     : pointer on in/out argument in user space.
     118 * @ vaddr         : semaphore virtual address in user space == identifier.
     119 * @ operation     : SEM_INIT / SEM_DESTROY / SEM_GETVALUE / SEM_POST / SEM_WAIT.
     120 * @ init_value    : initial semaphore value.
     121 * @ current_value : pointer on buffer for current semaphore value.
    121122 * @ return 0 if success / return -1 if failure.
    122123 *****************************************************************************************/
    123124int sys_sem( void       * vaddr,
    124125             uint32_t     operation,
    125              uint32_t   * value );
     126             uint32_t     init_value,
     127             uint32_t   * current_value );
    126128
    127129/******************************************************************************************
    … …  
    584586
    585587/******************************************************************************************
     588 * [44] TBD
     589 ******************************************************************************************
     590 * @ cxy    : cluster identifier.
     591 * @ lid    : core local index.
     592 * @ return 0 if success / return -1 if failure.
     593 *****************************************************************************************/
     594int sys_place( uint32_t cxy,
     595               uint32_t lid );
     596
     597/******************************************************************************************
    586598 * [45] This function block the calling thread on the THREAD_BLOCKED_GLOBAL condition,
    587599 * and deschedule.
    … …  
    624636
    625637/******************************************************************************************
    626  * [49] TBD
    627  ******************************************************************************************
    628  * @ cxy    : cluster identifier.
    629  * @ lid    : core local index.
    630  * @ return 0 if success / return -1 if failure.
    631  *****************************************************************************************/
    632 int sys_place( uint32_t cxy,
    633                uint32_t lid );
     638 * [49] This function returns a non-zero value in the <is_fg> buffer when the process
     639 * identified by the <pid> argument is the current TXT owner.
     640 ******************************************************************************************
     641 * @ pid      : process identifier.
     642 * @ is_fg    : pointer on buffer.
     643 * @ return 0 if success / return -1 if failure.
     644 *****************************************************************************************/
     645int sys_is_fg( pid_t      pid,
     646               uint32_t * is_fg );
    634647
    635648#endif  // _SYSCALLS_H_
Note: See TracChangeset for help on using the changeset viewer.