Ignore:
Timestamp:
Nov 19, 2020, 11:45:52 PM (3 years ago)
Author:
alain
Message:

1) Introduce up to 4 command lines arguments in the KSH "load" command.
These arguments are transfered to the user process through the
argc/argv mechanism, using the user space "args" vseg.

2) Introduce the named and anonymous "pipes", for inter-process communication
through the pipe() and mkfifo() syscalls.

3) Introduce the "chat" application to validate the two above mechanisms.

4) Improve printk() and assert() fonctions in printk.c.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/kernel/syscalls/syscalls.h

    r664 r670  
    3636struct mmap_attr_s;               // defined in vmm.h
    3737
    38 /******************************************************************************************
    39  * [0] This function terminates the execution of the calling user thread, and makes
    40  * the <exit_status> pointer available to any successful pthread_join() with the
    41  * terminating thread.
    42  * - If the calling thread is the main thread, it calls the sys_exit() function to delete
    43  *   completely the user process. 
    44  * - if the calling thread is not the main thread, it registers the <exit_status> pointer
    45  *   in the thread descriptor, and calls the thread_delete() function, that will set the
    46  *   THREAD_SIG_EXIT signal, set the THREAD_BLOCKED_GLOBAL bit in thread descriptor, and
    47  *   deschedules. All memory allocated to the thread is released later by the scheduler.
    48  *   If the thread is in "detached" mode, the thread_delete() function implements
    49  *   the synchonisation with the joining thread.
    50  ******************************************************************************************
    51  * @ exit_status  : pointer to be returned to joining thread if thread is attached.
    52  * @ return 0 if success / return -1 if all locks not released or illegal argument.
    53  *****************************************************************************************/
    54 int sys_thread_exit( void * exit_status );
    55 
    56 /******************************************************************************************
    57  * [1] This function calls the scheduler for the core running the calling thread.
    58  ******************************************************************************************
    59  * @ x_size   : [out] number of clusters in a row.
    60  * @ y_size   : [out] number of clusters in a column.
    61  * @ ncores   : [out] number of cores per cluster.
    62  * @ return always 0.
    63  *****************************************************************************************/
    64 int sys_thread_yield( void );
    65 
    66 /******************************************************************************************
    67  * [2] This function creates a new user thread. The <user_attr> argument is a pointer
    68  * on astructure containing the thread attributes, defined in thread.h file.
    69  ******************************************************************************************
    70  * @ trdid_ptr   : [out] pointer on buffer for created thread trdid.
    71  * @ user_attr   : [in]  pointer on thread attributes structure.
    72  * @ start_func  : [in]  pointer on start function.
    73  * @ start_args  : [in]  pointer on start function arguments.
    74  * @ return 0 if success / return -1 if failure.
    75  *****************************************************************************************/
    76 int sys_thread_create( trdid_t               * trdid_ptr,
    77                        struct pthread_attr_s * user_attr,
    78                        void                  * start_func,
    79                        void                  * start_args );
    80 
    81 /******************************************************************************************
    82  * [3] This blocking function suspend execution of the calling thread until completion
    83  * of another target thread identified by the <trdid> argument.
    84  * The target thread must be joinable (running in ATTACHED mode), and must be different
    85  * from the calling thread.
    86  * If the <exit_value> argument is not NULL, the value passed to pthread_exit() by the
    87  * target thread is stored in the location referenced by exit_value.
    88  ******************************************************************************************
    89  * @ trdid     : [in]  target thread identifier.
    90  * @ thread    : [out] buffer for exit_value returned by target thread.
    91  * @ return 0 if success / return -1 if failure.
    92  *****************************************************************************************/
    93 int sys_thread_join( trdid_t    trdid,
    94                      void    ** exit_value );
    95 
    96 /******************************************************************************************
    97  * [4] This function detach a joinable thread.
    98  ******************************************************************************************
    99  * @ trdid   : thread identifier.
    100  * @ return 0 if success / return -1 if failure.
    101  *****************************************************************************************/
    102 int sys_thread_detach( trdid_t  trdid );
    103 
    104 /******************************************************************************************
    105  * [5] This function requests a target thread identified by its <trdid> argument
    106  * to be cancelled. It calls the thread_kill() function to block the target thread
    107  * on the THREAD_BLOCKED_GLOBAL condition, and to set the THREAD_FLAG_REQ_DELETE.
    108  * The thread will be detached from its process, and the memory allocated to the thread
    109  * descriptor will be released by the scheduler at the next scheduling point.
    110  ******************************************************************************************
    111  * @ trdid   : thread identifier.
    112  * @ return 0 if success / return -1 if illegal argument.
    113  *****************************************************************************************/
    114 int sys_thread_cancel( trdid_t  trdid );
    115 
    116 /******************************************************************************************
    117  * [6] This function implement all operations on a POSIX unnamed semaphore,
    118  * that can be shared by threads running in different clusters.
    119  * The kernel structure representing a remote semaphore is in the remote_sem.h file,
    120  * and the code implementing the operations is in the remore_sem.c file.
    121  ******************************************************************************************
    122  * @ vaddr         : semaphore virtual address in user space == identifier.
    123  * @ operation     : SEM_INIT / SEM_DESTROY / SEM_GETVALUE / SEM_POST / SEM_WAIT.
    124  * @ init_value    : initial semaphore value.
    125  * @ current_value : pointer on buffer for current semaphore value.
    126  * @ return 0 if success / return -1 if failure.
    127  *****************************************************************************************/
    128 int sys_sem( void       * vaddr,
    129              uint32_t     operation,
    130              uint32_t     init_value,
    131              uint32_t   * current_value );
    132 
    133 /******************************************************************************************
    134  * [7] This function implement all operations on a POSIX condition variable.
    135  * The kernel structure representing a condvar is defined in the remote_condvar.h file,
    136  * The code implementing the operations is defined in the remote_condvar.c file.
    137  ******************************************************************************************
    138  * @ vaddr     : condvar virtual address in user space == identifier.
    139  * @ operation : operation type (see below).
    140  * @ attr      : mutex virtual address in user space == identifier.
    141  * @ return 0 if success / return -1 if failure.
    142  *****************************************************************************************/
    143 int sys_condvar( void     * condvar,
    144                  uint32_t   operation,
    145                  void     * mutex );
    146 
    147 /******************************************************************************************
    148  * [8] This function implement all operations on a POSIX barrier.
     38
     39/******************************************************************************************
     40 * This function forces the calling thread to sleep, for a fixed number of cycles.
     41 ******************************************************************************************
     42 * cycles   : number of cycles.
     43 *****************************************************************************************/
     44int sys_alarm( uint32_t cycles );
     45
     46/******************************************************************************************
     47 * This function implement all operations on a POSIX barrier.
    14948 * The kernel structure representing a barrier is defined in the remote_barrier.h file.
    15049 * The code implementting the operations is defined in the remote_barrier.c file.
    … …  
    16261
    16362/******************************************************************************************
    164  * [9] This function implement all operations on a POSIX mutex.
    165  * The kernel structure representing a barrier is defined in the remote_barrier.h file.
    166  * The code implementting the operations is defined in the remote_barrier.c file.
    167  ******************************************************************************************
    168  * @ vaddr     : mutex virtual address in user space == identifier.
    169  * @ operation : MUTEX_INIT / MUTEX_DESTROY / MUTEX_LOCK / MUTEX_UNLOCK
    170  * @ attr      : mutex attributes (non supported yet => must be 0).
    171  * @ return 0 if success / return -1 if failure.
    172  *****************************************************************************************/
    173 int sys_mutex( void     * vaddr,
    174                uint32_t   operation,
    175                uint32_t   count );
    176 
    177 /******************************************************************************************
    178  * [10] This function causes the file named <old> to be renamed as <new>.
    179  * If new exists, it is first removed.  Both old and new must be of the same type (both
    180  * must be either directories or non-directories) and must reside on the same file system.
    181  * It guarantees that an instance of <new> will always exist, even if the system should
    182  * crash in the middle of the operation.
    183  ******************************************************************************************
    184  * @ old      : old file name.
    185  * @ new      : new file name.
    186  * @ return 0 if success / return -1 if failure.
    187  *****************************************************************************************/
    188 int sys_rename( char *old,
    189                 char *new );
    190 
    191 /******************************************************************************************
    192  * [11] This function remove an existing mapping defined by the <addr> and <size>
    193  * arguments in user space. This can modify the number of vsegs:
    194  * (a) if the region is not entirely mapped in one existing vseg, it's an error.
    195  * (b) if the region has same base and size as an existing vseg, the vseg is removed.
    196  * (c) if the removed region cut the exiting vseg in two parts, it is resized.
    197  * (d) if the removed region cut the vseg in three parts, it is modified, and a new
    198  *     vseg is created with same type.
    199  * All existing VSL copies are updated.
    200 ******************************************************************************************
    201  * @ addr  : base address in user space.
    202  * @ size  : number of bytes.
    203  * @ return 0 if success / return -1 if failure.
    204  *****************************************************************************************/
    205 int sys_munmap( void     * addr,
    206                 uint32_t   size );
    207 
    208 /******************************************************************************************
    209  * [12] This function open or create an open file descriptor.
     63 * This function change the current working directory in reference process descriptor.
    21064 ******************************************************************************************
    21165 * @ pathname   : pathname (can be relative or absolute).
    212  * @ flags      : bit vector attributes (see in shared_fcntl.h file)
    213  * @ mode       : access rights.
    214  * @ return file descriptor index in fd_array if success / return -1 if failure.
    215  *****************************************************************************************/
    216 int sys_open( char       * pathname,
    217               uint32_t     flags,
    218               uint32_t     mode );
    219 
    220 /******************************************************************************************
    221  * [13] This function map physical memory (or a file) in the calling thread virtual space.
    222  * The <attr> argument is a pointer on a structure for arguments (see shared_mman.h).
    223  * The user defined virtual address (MAP_FIXED flag) is not supported.
    224  * TODO : the access rights checking is not implemented yet [AG]
    225  * TODO : the Copy on Write for MAP_PRIVATE is not implemented yet [AG]
    226  ******************************************************************************************
    227  * @ attr       : pointer on attributes structure.
    228  * @ returns 0 if success / returns -1 if failure.
    229  *****************************************************************************************/
    230 int sys_mmap( mmap_attr_t * attr );
    231 
    232 /******************************************************************************************
    233  * [14] This function read bytes from an open file identified by its file descriptor.
    234  * The file can be a regular file or character oriented device.
    235  * IRQs are enabled during this system call.
    236  ******************************************************************************************
    237  * @ file_id  : open file index in fd_array.
    238  * @ buf      : buffer virtual address in user space.
    239  * @ count    : number of bytes.
    240  * @ returns number of bytes actually read if success / returns -1 if failure.
    241  *****************************************************************************************/
    242 int sys_read( uint32_t   file_id,
    243               void     * buf,
    244               uint32_t   count );
    245 
    246 /******************************************************************************************
    247  * [15] This function writes bytes to an open file identified by its file descriptor.
    248  * The file can be a regular file or character oriented device. For a regular file,
    249  * the target inode "size" field is updated if (offset + count) is larger than the
    250  * current "size" value. The size value registered in the mappers of the parent(s)
    251  * directory are not modified and will be asynchronously updated when the file is closed.
    252  * IRQs are enabled during this system call.
    253  ******************************************************************************************
    254  * @ file_id  : open file index in fd_array.
    255  * @ buf      : buffer virtual address in user space.
    256  * @ count    : number of bytes.
    257  * @ returns number of bytes actually written if success / returns -1 if failure.
    258  *****************************************************************************************/
    259 int sys_write( uint32_t   file_id,
    260                void     * buf,
    261                uint32_t   count );
    262 
    263 /******************************************************************************************
    264  * [16] This function repositions the offset of the file descriptor identified by the
    265  * <file_id> argument, according to the operation type defined by the <whence> argument.
    266  ******************************************************************************************
    267  * @ file_id  : open file index in fd_array.
    268  * @ offset   : used to compute new offset value.
    269  * @ whence   : operation type (see below).
    270  * @ returns new offset value if success / returns -1 if failure.
    271  *****************************************************************************************/
    272 int sys_lseek( xptr_t    file_id,
    273                uint32_t  offset,
    274                uint32_t  whence );
    275 
    276 /******************************************************************************************
    277  * [17] This function release the memory allocated for the file descriptor identified by
     66 * @ return 0 if success / returns -1 if failure.
     67 *****************************************************************************************/
     68int sys_chdir( char * pathname );
     69
     70/******************************************************************************************
     71 * This function change the acces rights for the file/directory inode identified by the
     72 * <pathname> argument, as specified by the <mode> argument.
     73 ******************************************************************************************
     74 * @ pathname : pathname (can be relative or absolute).
     75 * @ mode     : acces rights.
     76 * @ return 0 if success / returns -1 if failure.
     77 *****************************************************************************************/
     78int sys_chmod( char       * pathname,
     79               uint32_t     mode );
     80
     81/******************************************************************************************
     82 * This function release the memory allocated for the file descriptor identified by
    27883 * the <file_id> argument, and remove the fd array_entry in all copies of the process
    27984 * descriptor.
    … …  
    28590
    28691/******************************************************************************************
    287  * [18] This function removes a directory entry identified by the <pathname> from the
    288  * directory, and decrement the link count of the file referenced by the link.
    289  * If the link count reduces to zero, and no process has the file open, then all resources
    290  * associated with the file are reclaimed.  If one or more process have the file open when
    291  * the last link is removed, the link is removed, but the removal of the file is delayed
    292  * until all references to it have been closed.
    293  ******************************************************************************************
    294  * @ pathname   : pathname (can be relative or absolute).
    295  * @ returns 0 if success / returns -1 if failure.
    296  *****************************************************************************************/
    297 int sys_unlink( char * pathname );
    298 
    299 /******************************************************************************************
    300  * [19] This function creates in the calling thread cluster an unnamed pipe, and two
    301  * (read and write) file descriptors.
    302  * TODO not implemented yet [AG]
    303  ******************************************************************************************
    304  * @ file_id[0] : [out] read only file descriptor index.
    305  * @ file_id[1] : [out] write only file descriptor index.
    306  * @ return 0 if success / return -1 if failure.
    307  *****************************************************************************************/
    308 int sys_pipe( uint32_t file_id[2] );
    309 
    310 /******************************************************************************************
    311  * [20] This function change the current working directory in reference process descriptor.
    312  ******************************************************************************************
    313  * @ pathname   : pathname (can be relative or absolute).
    314  * @ return 0 if success / returns -1 if failure.
    315  *****************************************************************************************/
    316 int sys_chdir( char * pathname );
    317 
    318 /******************************************************************************************
    319  * [21] This function implements the "mkdir" system call, creating a new directory in
    320  * the file system, as defined by the <pathname> argument, with the access permission
    321  * defined by the <rights> argument. All nodes but the last in the pathname must exist.
     92 * This function closes the directory identified by the <dirp> argument, and releases
     93 * all structures associated with the <dirp> pointer.
     94 ******************************************************************************************
     95 * @ dirp     : [in] user pointer on dirent array identifying the open directory.
     96 * @ return 0 if success / returns -1 if failure.
     97 *****************************************************************************************/
     98int sys_closedir( DIR * dirp );
     99
     100/******************************************************************************************
     101 * This function implement all operations on a POSIX condition variable.
     102 * The kernel structure representing a condvar is defined in the remote_condvar.h file,
     103 * The code implementing the operations is defined in the remote_condvar.c file.
     104 ******************************************************************************************
     105 * @ vaddr     : condvar virtual address in user space == identifier.
     106 * @ operation : operation type (see below).
     107 * @ attr      : mutex virtual address in user space == identifier.
     108 * @ return 0 if success / return -1 if failure.
     109 *****************************************************************************************/
     110int sys_condvar( void     * condvar,
     111                 uint32_t   operation,
     112                 void     * mutex );
     113
     114/******************************************************************************************
     115 * This debug function displays on the kernel terminal TXT0 an user defined string,
     116 * or the current state of a kernel structure, identified by the <type> argument.
     117 * The <arg0>, <arg1>, and <arg2> arguments depends on the structure type.
     118 ******************************************************************************************
     119 * type      : [in] type of display
     120 * arg0      : [in] type dependant argument.
     121 * arg1      : [in] type dependant argument.
     122 * arg2      : [in] type dependant argument.
     123 * @ return 0 if success / return -1 if illegal arguments
     124 *****************************************************************************************/
     125int sys_display( reg_t  type,
     126                 reg_t  arg0,
     127                 reg_t  arg1,
     128                 reg_t  arg2 );
     129
     130/******************************************************************************************
     131 * This function implement the "exec" system call on the kernel side.
     132 * It creates, in the same cluster as the calling thread, a new process descriptor,
     133 * and a new associated main thread descriptor, executing a new memory image defined
     134 * by the <filename> argument. This new process inherit from the old process the PID
     135 * and the PPID, as well as all open files registered in fd_array, including the TXT.
     136 * The old process descriptor, and all its threads are blocked, and marked for deletion.
     137 * Therefore the exec syscall does not return to the calling thread in case of success.
     138 * This function must be called by the main thread (thread 0 in owner cluster), of the
     139 * calling process, to destroy all process copies, and all other threads in all clusters.
     140 ******************************************************************************************
     141 * Implementation note:
     142 * It fill the calling process "exec_info" structure containing all informations required
     143 * to initialize the new process descriptor and the associated main thread. This includes:
     144 * - pathname to the new process .elf> file in VFS.
     145 * - array of string pointers defining the process arguments, and the associated strings.
     146 * - array of string pointers defining environment variables, and the associated strings.
     147 * To do this, it calls the process_exec_get_strings function, that copies all relevant
     148 * information from user space to kernel space, using functions defined in <hal_uspace.h>.
     149 * Then it calls the process_make_exec() function that returns only in case of failure.
     150 *
     151 * TODO : the <envs> argument is not supported yet and must be NULL.
     152 ******************************************************************************************
     153 * @ filename      : string pointer on .elf filename (pointer in user space)
     154 * @ user_args     : array of strings on process arguments (pointers in user space)
     155 * @ user_envs     : array of strings on environment variables (pointers in user space)
     156 * @ does not return if success / returns -1 if failure.
     157 *****************************************************************************************/
     158int sys_exec( char  * filename,
     159              char ** user_args,
     160              char ** user_envs );
     161
     162/******************************************************************************************
     163 * This function implements the "exit" system call terminating a POSIX process.
    322164 * It can be called by any thread running in any cluster.
    323  ******************************************************************************************
    324  * @ pathname  : pathname defining the new directory location in file system.
    325  * @ rights    : access rights (non used yet).
    326  * @ return 0 if success / return -1 if failure.
    327  *****************************************************************************************/
    328 int sys_mkdir( char     * pathname,
    329                uint32_t   rights );
    330 
    331 /******************************************************************************************
    332  * [22] This function creates a named FIFO file in the calling thread cluster.
    333  * The associated read and write file descriptors mut be be  explicitely created
    334  * using the sys_open() function.
    335  ******************************************************************************************
    336  * @ pathname   : pathname (can be relative or absolute).
    337  * @ mode       : access rights (as defined in chmod).
    338  * @ return 0 if success / returns -1 if failure.
    339  *****************************************************************************************/
    340 int sys_mkfifo( char     * pathname,
    341                 uint32_t   mode );
    342 
    343 /******************************************************************************************
    344  * [23] This function creates an user level directory descriptor (including the associated
    345  * array of user level dirents), and intialise it from the kernel directory mapper, that
    346  * contains all entries in this directory). The directory is identified by the <pathname>
    347  * argument. If the corresponding inode is missing in the Inode Tree, the inode is created,
    348  * but the directory must exist in the file system.
    349  * It returns a DIR pointer <dirp> on the dirent array in user space.
    350  * The calling process fd_array is NOT modified.
    351  ******************************************************************************************
    352  * @ pathname   : [in]  pathname (can be relative or absolute).
    353  * @ dirp       : [out] buffer for pointer on user directory (DIR).
    354  * @ return 0 if success / returns -1 if failure.
    355  *****************************************************************************************/
    356 int sys_opendir( char * pathname,
    357                  DIR ** dirp );
    358 
    359 /******************************************************************************************
    360  * [24] This function returns an user pointer on the dirent structure describing the
    361  * next directory entry in the directory identified by the <dirp> argument.
    362  ******************************************************************************************
    363  * @ dirp     : [in]  user pointer on dirent array identifying the open directory.
    364  * @ buffer   : [out] pointer on user buffer for a pointer on dirent in user space.
    365  * @ return O if success / returns -1 if failure.
    366  *****************************************************************************************/
    367 int sys_readdir( DIR            * dirp,
    368                  struct dirent ** buffer );
    369 
    370 /******************************************************************************************
    371  * [25] This function closes the directory identified by the <dirp> argument, and releases
    372  * all structures associated with the <dirp> pointer.
    373  ******************************************************************************************
    374  * @ dirp     : [in] user pointer on dirent array identifying the open directory.
    375  * @ return 0 if success / returns -1 if failure.
    376  *****************************************************************************************/
    377 int sys_closedir( DIR * dirp );
    378 
    379 /******************************************************************************************
    380  * [26] This function returns the pathname of the current working directory.
     165 * It uses both remote accesses to access the owner process descriptor, and the
     166 * RPC_PROCESS_SIGACTION to delete remote process copies and thread descriptors.
     167 * In the present implementation, this function implements actually the _exit():
     168 * - it does not flush open output streams.
     169 * - it does not close open streams.
     170 ******************************************************************************************
     171 * @ status   : terminaison status returned to parent process.
     172 * @ return 0 if success / return -1 if failure.
     173 *****************************************************************************************/
     174int sys_exit( uint32_t status );
     175
     176/******************************************************************************************
     177 * This generic function implements the non-standard FBF related syscalls.
     178 * The operation types mnemonics are defined in the <shared_fbf> file.
     179 * The supported operations are defined in the <almosmkh.h> & <almosmkh.c> files.
     180 * This function ckecks the syscall arguments, and call the relevant kernel function.
     181 ******************************************************************************************
     182 * @ arg0       : operation type (mnemonics defined in shared_fbf.h)
     183 * @ arg1       : depends on operation type
     184 * @ arg2       : depends on operation type
     185 * @ arg3       : depends on operation type
     186 * @ return 0 if success / return -1 if illegal argument.
     187 *****************************************************************************************/
     188int sys_fbf( reg_t   arg0,
     189             reg_t   arg1,
     190             reg_t   arg2,
     191             reg_t   arg3 );
     192
     193/******************************************************************************************
     194 * This function gives the process identified by the <pid> argument
     195 * the exclusive ownership of its TXT_TX terminal (put it in foreground).
     196 ******************************************************************************************
     197 * @ pid    : process identifier.
     198 * @ return 0 if success / return -1 if failure.
     199 *****************************************************************************************/
     200int sys_fg( pid_t   pid );
     201
     202/******************************************************************************************
     203 * This function implements the "fsync" system call.
     204 * It forces all modified pages of the file mapper identified by the <fd> argument
     205 * to be copied to the IOC device.
     206 * It can be called by any thread running in any cluster.
     207 * TODO not implemented yet.
     208 ******************************************************************************************
     209 * @ file_id   : file descriptor index in fd_array.
     210 * @ return 0 if success / return -1 if failure.
     211 *****************************************************************************************/
     212int sys_fsync( uint32_t file_id );
     213
     214/******************************************************************************************
     215 * This function implement the "fork" system call on the kernel side.
     216 * The calling process descriptor (parent process), and the associated thread descriptor
     217 * are replicated in a - likely - remote cluster, that becomes the child process owner.
     218 * The child process get a new PID, and is linked to the parent PID. The child process
     219 * inherit from its parent the memory image, and all open files (including the TXT).
     220 * The child process becomes the TXT terminal owner.
     221 * The target cluster depends on the "fork_user" flag and "fork_cxy" variable that can be
     222 * stored in the calling thread descriptor by the specific fork_place() system call.
     223 * If not, the kernel function makes a query to the DQDT to select the target cluster.
     224 ******************************************************************************************
     225 * @ if success, returns child process PID to parent, and return O to child.
     226 * @ if failure, returns -1 to parent / no child process is created.
     227 *****************************************************************************************/
     228int sys_fork( void );
     229
     230/******************************************************************************************
     231 * This function implements the non-standard "get_best_core" syscall.
     232 * It selects, in a macro-cluster specified by the <base_cxy> and <level> arguments,
     233 * the core that has the lowest load.
     234 * When an active core has been found in the target macro-cluster, it writes into the
     235 * <cxy> and <lid> buffers the cluster identifier and the core local index, and return 0.
     236 * It returns -1 in case of illegal arguments (level / cxy / lid).
     237 * It returns +1 if there is no active core in specified macro-cluster.
     238 ******************************************************************************************
     239 * @ base_cxy : [in]  any cluster identifier in macro-cluster.
     240 * @ level    : [in]  macro-cluster level in [1,2,3,4,5].
     241 * @ cxy      : [out] selected core cluster identifier.
     242 * @ lid      : [out] selected core local index in cluster.
     243 * @ return 0 if success / -1 if illegal arguments / +1 if no core in macro-clusters.
     244 *****************************************************************************************/
     245int sys_get_best_core( uint32_t   base_cxy,
     246                       uint32_t   level,
     247                       uint32_t * cxy,
     248                       uint32_t * lid );
     249
     250/******************************************************************************************
     251 * This function implement the non-standard get_config() syscall.
     252 * It returns the global hardware platform parameters in the <config> shared structure,
     253 * that is defined in the shared_almos.h file.
     254 ******************************************************************************************
     255 * @ config   : [out] pointer on the hard_config_t structure in user space.
     256 * @ return 0 if success / return -1 if illegal argument
     257 *****************************************************************************************/
     258int sys_get_config( struct hard_config_s * config );
     259
     260/******************************************************************************************
     261 * This function implements the non-standard get_core_id() syscall.
     262 * It returns in <cxy> and <lid> the calling core cluster and local index.
     263 ******************************************************************************************
     264 * @ cxy      : [out] cluster identifier (fixed format)
     265 * @ lid      : [out] core local index in cluster.
     266 * @ return 0 if success / return -1 if illegal arguments
     267 *****************************************************************************************/
     268int sys_get_core_id( uint32_t * cxy,
     269                     uint32_t * lid );
     270
     271/******************************************************************************************
     272 * This function implements the non-standard get_cycle() syscall.
     273 * It returns in a 64 bits user buffer the calling core cycles count.
     274 * It uses both the hardware register and the core descriptor cycles count to take
     275 * into account a possible harware register overflow  in 32 bits architectures.
     276 ******************************************************************************************
     277 * cycle    : [out] address of buffer in user space.
     278 * @ return 0 if success / return -1 if illegal arguments
     279 *****************************************************************************************/
     280int sys_get_cycle( uint64_t * cycle );
     281
     282/******************************************************************************************
     283 * This function returns the pathname of the current working directory.
    381284 ******************************************************************************************
    382285 * buf     : buffer addres in user space.
    … …  
    388291
    389292/******************************************************************************************
    390  * [27] This function tests whether a given file descriptor dentified by the <file_id>
     293 * This function implements the non-standard "get_nb_cores" syscall.
     294 * It writes in the <ncores> buffer the number of cores in the target cluster <cxy>.
     295 ******************************************************************************************
     296 * @ cxy      : [in]  target cluster identifier.
     297 * @ ncores   : [out] number of cores / 0 if cluster cxy undefined in architecture.
     298 * @ return 0 if success / return -1 if illegal "ncores" arguments.
     299 *****************************************************************************************/
     300int sys_get_nb_cores( uint32_t   cxy,
     301                      uint32_t * ncores );
     302
     303/******************************************************************************************
     304 * This function implements the "getpid" system call on the kernel side.
     305 ******************************************************************************************
     306 * @ returns the process PID for the calling thread.
     307 *****************************************************************************************/
     308int sys_getpid( void );
     309
     310/******************************************************************************************
     311 * This function implements the non-standard "get_thread_info" syscall.
     312 * It copies in the user structure defined by the <info> argument the values registered
     313 * in the calling thread "thread_info_t" kernel structure.
     314 ******************************************************************************************
     315 * @ info      : [out] pointer on thread_info_t structure in user space.
     316 * @ return 0 if success / return -1 if illegal argument.
     317 *****************************************************************************************/
     318int sys_get_thread_info( thread_info_t * info );
     319
     320/******************************************************************************************
     321 * This function tests whether a given file descriptor dentified by the <file_id>
    391322 * argument is an open file descriptor referring to a terminal.
    392323 ******************************************************************************************
    … …  
    397328
    398329/******************************************************************************************
    399  * [28] This function forces the calling thread to sleep, for a fixed number of cycles.
    400  ******************************************************************************************
    401  * cycles   : number of cycles.
    402  *****************************************************************************************/
    403 int sys_alarm( uint32_t cycles );
    404 
    405 /******************************************************************************************
    406  * [29] This function removes a directory file whose name is given by <pathname>.
    407  * The directory must not have any entries other than `.' and `..'.
    408  ******************************************************************************************
    409  * @ pathname   : pathname (can be relative or absolute).
    410  * @ return 0 if success / returns -1 if failure.
    411  *****************************************************************************************/
    412 int sys_rmdir( char * pathname );
    413 
    414 /******************************************************************************************
    415  * [30] This function implement the operations related to User Thread Local Storage.
    416  * It is actually implemented as an uint32_t variable in the thread descriptor.
    417  ******************************************************************************************
    418  * @ operation  : UTLS operation type as defined below.
    419  * @ value      : argument value for the UTLS_SET operation.
    420  * @ return value for the UTLS_GET and UTLS_GET_ERRNO / return -1 if failure.
    421  *****************************************************************************************/
    422 int sys_utls( uint32_t operation,
    423               uint32_t value );
    424 
    425 /******************************************************************************************
    426  * [31] This function change the acces rights for the file/dir identified by the
    427  * pathname argument.
    428  ******************************************************************************************
    429  * @ pathname   : pathname (can be relative or absolute).
    430  * @ rights     : acces rights.
    431  * @ return 0 if success / returns -1 if failure.
    432  *****************************************************************************************/
    433 int sys_chmod( char       * pathname,
    434                uint32_t     rights );
    435 
    436 /******************************************************************************************
    437  * [32] This function associate a specific signal handler to a given signal type.
    438  * The handlers for the SIGKILL and SIGSTOP signals cannot be redefined.
    439  ******************************************************************************************
    440  * @ sig_id    : index defining signal type (from 1 to 31).
    441  * @ handler   : pointer on fonction implementing the specific handler.
    442  * @ return 0 if success / returns -1 if failure.
    443  *****************************************************************************************/
    444 int sys_signal( uint32_t   sig_id,
    445                 void     * handler );
    446 
    447 /******************************************************************************************
    448  * [33] This function returns in the structure <tv>, defined in the time.h file,
    449  * the current time (in seconds & micro-seconds).
    450  * It is computed from the calling core descriptor.
    451  * The timezone is not supported.
    452  ******************************************************************************************
    453  * @ tv      : pointer on the timeval structure.
    454  * @ tz      : pointer on the timezone structure : must be NULL.       
    455  * @ return 0 if success / returns -1 if failure.
    456  *****************************************************************************************/
    457 int sys_timeofday( struct timeval  * tv,
    458                    struct timezone * tz );
    459 
    460 /******************************************************************************************
    461  * [34] This function implements the "kill" system call on the kernel side.
     330 * This function returns a non-zero value in the <is_fg> buffer when the process
     331 * identified by the <pid> argument is the current TXT owner.
     332 ******************************************************************************************
     333 * @ pid      : process identifier.
     334 * @ is_fg    : pointer on buffer.
     335 * @ return 0 if success / return -1 if failure.
     336 *****************************************************************************************/
     337int sys_is_fg( pid_t      pid,
     338               uint32_t * is_fg );
     339
     340/******************************************************************************************
     341 * This function implements the "kill" system call on the kernel side.
    462342 * It register the signal defined by the <sig_id> argument in all thread descriptors
    463343 * of a target process identified by the <pid> argument. This is done in all clusters
    … …  
    477357
    478358/******************************************************************************************
    479  * [35] This function implements the "getpid" system call on the kernel side.
     359 * This function repositions the offset of the file descriptor identified by the
     360 * <file_id> argument, according to the operation type defined by the <whence> argument.
     361 ******************************************************************************************
     362 * @ file_id  : open file index in fd_array.
     363 * @ offset   : used to compute new offset value.
     364 * @ whence   : operation type (see below).
     365 * @ returns new offset value if success / returns -1 if failure.
     366 *****************************************************************************************/
     367int sys_lseek( xptr_t    file_id,
     368               uint32_t  offset,
     369               uint32_t  whence );
     370
     371/******************************************************************************************
     372 * This function implements the "mkdir" system call, creating a new directory in
     373 * the file system, as defined by the <pathname> argument, with the access permission
     374 * defined by the <rights> argument. All nodes but the last in the pathname must exist.
     375 * It can be called by any thread running in any cluster.
     376 ******************************************************************************************
     377 * @ pathname  : pathname defining the new directory location in file system.
     378 * @ rights    : access rights (non used yet).
     379 * @ return 0 if success / return -1 if failure.
     380 *****************************************************************************************/
     381int sys_mkdir( char     * pathname,
     382               uint32_t   rights );
     383
     384/******************************************************************************************
     385 * This function creates a new inode/dentry couple of type FIFO, and registers it in
     386 * the Inode-Tree, as specified by the <pathname> and <mode> arguments.
     387 * The associated file descriptors are created later, using the sys_open() function.
     388 ******************************************************************************************
     389 * @ pathname   : pathname (can be relative or absolute).
     390 * @ mode       : access rights (as defined in chmod).
     391 * @ return 0 if success / returns -1 if failure.
     392 *****************************************************************************************/
     393int sys_mkfifo( char     * pathname,
     394                uint32_t   mode );
     395
     396/******************************************************************************************
     397 * This function map physical memory (or a file) in the calling thread virtual space.
     398 * The <attr> argument is a pointer on a structure for arguments (see shared_mman.h).
     399 * The user defined virtual address (MAP_FIXED flag) is not supported.
     400 * TODO : the access rights checking is not implemented yet [AG]
     401 * TODO : the Copy on Write for MAP_PRIVATE is not implemented yet [AG]
     402 ******************************************************************************************
     403 * @ attr       : pointer on attributes structure.
     404 * @ returns 0 if success / returns -1 if failure.
     405 *****************************************************************************************/
     406int sys_mmap( mmap_attr_t * attr );
     407
     408/******************************************************************************************
     409 * This function remove an existing mapping defined by the <addr> and <size>
     410 * arguments in user space. This can modify the number of vsegs:
     411 * (a) if the region is not entirely mapped in one existing vseg, it's an error.
     412 * (b) if the region has same base and size as an existing vseg, the vseg is removed.
     413 * (c) if the removed region cut the exiting vseg in two parts, it is resized.
     414 * (d) if the removed region cut the vseg in three parts, it is modified, and a new
     415 *     vseg is created with same type.
     416 * All existing VSL copies are updated.
     417******************************************************************************************
     418 * @ addr  : base address in user space.
     419 * @ size  : number of bytes.
     420 * @ return 0 if success / return -1 if failure.
     421 *****************************************************************************************/
     422int sys_munmap( void     * addr,
     423                uint32_t   size );
     424
     425/******************************************************************************************
     426 * This function implement all operations on a POSIX mutex.
     427 * The kernel structure representing a barrier is defined in the remote_barrier.h file.
     428 * The code implementting the operations is defined in the remote_barrier.c file.
     429 ******************************************************************************************
     430 * @ vaddr     : mutex virtual address in user space == identifier.
     431 * @ operation : MUTEX_INIT / MUTEX_DESTROY / MUTEX_LOCK / MUTEX_UNLOCK
     432 * @ attr      : mutex attributes (non supported yet => must be 0).
     433 * @ return 0 if success / return -1 if failure.
     434 *****************************************************************************************/
     435int sys_mutex( void     * vaddr,
     436               uint32_t   operation,
     437               uint32_t   count );
     438
     439/******************************************************************************************
     440 * This function creates a new file descriptor for an existing inode.
     441 * It creates a new inode if required by the flags.
     442 ******************************************************************************************
     443 * @ pathname   : pathname in the inode tree (can be relative or absolute).
     444 * @ flags      : bit vector attributes (see in shared_fcntl.h file)
     445 * @ mode       : access rights.
     446 * @ return file descriptor index in fd_array if success / return -1 if failure.
     447 *****************************************************************************************/
     448int sys_open( char       * pathname,
     449              uint32_t     flags,
     450              uint32_t     mode );
     451
     452/******************************************************************************************
     453 * This function creates an user level directory descriptor (including the associated
     454 * array of user level dirents), and intialise it from the kernel directory mapper, that
     455 * contains all entries in this directory). The directory is identified by the <pathname>
     456 * argument. If the corresponding inode is missing in the Inode Tree, the inode is created,
     457 * but the directory must exist in the file system.
     458 * It returns a DIR pointer <dirp> on the dirent array in user space.
     459 * The calling process fd_array is NOT modified.
     460 ******************************************************************************************
     461 * @ pathname   : [in]  pathname (can be relative or absolute).
     462 * @ dirp       : [out] buffer for pointer on user directory (DIR).
     463 * @ return 0 if success / returns -1 if failure.
     464 *****************************************************************************************/
     465int sys_opendir( char * pathname,
     466                 DIR ** dirp );
     467
     468/******************************************************************************************
     469 * This function creates in the calling thread cluster an unnamed pipe, implemented
     470 * as a remote_buffer_t, creates two (read and write) file descriptors, and links these
     471 * two file descriptors to the pipe.
     472 * TODO : the dynamic memory allocation in case of buffer full is not implemented.
     473 ******************************************************************************************
     474 * @ fd   : pointeur on a 2 slots array of fdid : fd[0] read / fd[1] write.
     475 * @ return 0 if success / return -1 if failure.
     476 *****************************************************************************************/
     477int sys_pipe( fdid_t * fd );
     478
     479/******************************************************************************************
     480 * This function implements the non-standard place_fork() syscall.
     481 * It can be used to specify the target cluster <cxy> for a new process created
     482 * by a subsequent fork() syscall.
     483 * WARNING: it must be called before each fork() syscall, as the placement specification
     484 *          is reset by the fork syscall.
     485 ******************************************************************************************
     486 * @ cxy    : cluster identifier.
     487 * @ return 0 if success / return -1 if failure.
     488 *****************************************************************************************/
     489int sys_place_fork( uint32_t cxy );
     490
     491/******************************************************************************************
     492 * This function read bytes from an open file identified by its file descriptor.
     493 * The file can be a regular file or character oriented device.
     494 * IRQs are enabled during this system call.
     495 ******************************************************************************************
     496 * @ file_id  : open file index in fd_array.
     497 * @ buf      : buffer virtual address in user space.
     498 * @ count    : number of bytes.
     499 * @ returns number of bytes actually read if success / returns -1 if failure.
     500 *****************************************************************************************/
     501int sys_read( uint32_t   file_id,
     502              void     * buf,
     503              uint32_t   count );
     504
     505/******************************************************************************************
     506 * This function returns an user pointer on the dirent structure describing the
     507 * next directory entry in the directory identified by the <dirp> argument.
     508 ******************************************************************************************
     509 * @ dirp     : [in]  user pointer on dirent array identifying the open directory.
     510 * @ buffer   : [out] pointer on user buffer for a pointer on dirent in user space.
     511 * @ return O if success / returns -1 if failure.
     512 *****************************************************************************************/
     513int sys_readdir( DIR            * dirp,
     514                 struct dirent ** buffer );
     515
     516/******************************************************************************************
     517 * This function causes the file named <old> to be renamed as <new>.
     518 * If new exists, it is first removed.  Both old and new must be of the same type (both
     519 * must be either directories or non-directories) and must reside on the same file system.
     520 * It guarantees that an instance of <new> will always exist, even if the system should
     521 * crash in the middle of the operation.
     522 ******************************************************************************************
     523 * @ old      : old file name.
     524 * @ new      : new file name.
     525 * @ return 0 if success / return -1 if failure.
     526 *****************************************************************************************/
     527int sys_rename( char *old,
     528                char *new );
     529
     530/******************************************************************************************
     531 * This function removes a directory file whose name is given by <pathname>.
     532 * The directory must not have any entries other than `.' and `..'.
     533 ******************************************************************************************
     534 * @ pathname   : pathname (can be relative or absolute).
     535 * @ return 0 if success / returns -1 if failure.
     536 *****************************************************************************************/
     537int sys_rmdir( char * pathname );
     538
     539/******************************************************************************************
     540 * This function implement all operations on a POSIX unnamed semaphore,
     541 * that can be shared by threads running in different clusters.
     542 * The kernel structure representing a remote semaphore is in the remote_sem.h file,
     543 * and the code implementing the operations is in the remore_sem.c file.
     544 ******************************************************************************************
     545 * @ vaddr         : semaphore virtual address in user space == identifier.
     546 * @ operation     : SEM_INIT / SEM_DESTROY / SEM_GETVALUE / SEM_POST / SEM_WAIT.
     547 * @ init_value    : initial semaphore value.
     548 * @ current_value : pointer on buffer for current semaphore value.
     549 * @ return 0 if success / return -1 if failure.
     550 *****************************************************************************************/
     551int sys_sem( void       * vaddr,
     552             uint32_t     operation,
     553             uint32_t     init_value,
     554             uint32_t   * current_value );
     555
     556/******************************************************************************************
     557 * This function associate a specific signal handler to a given signal type.
     558 * The handlers for the SIGKILL and SIGSTOP signals cannot be redefined.
    480559 ******************************************************************************************
    481  * @ returns the process PID for the calling thread.
    482  *****************************************************************************************/
    483 int sys_getpid( void );
    484 
    485 /******************************************************************************************
    486  * [36] This function implement the "fork" system call on the kernel side.
    487  * The calling process descriptor (parent process), and the associated thread descriptor
    488  * are replicated in a - likely - remote cluster, that becomes the child process owner.
    489  * The child process get a new PID, and is linked to the parent PID. The child process
    490  * inherit from its parent the memory image, and all open files (including the TXT).
    491  * The child process becomes the TXT terminal owner.
    492  * The target cluster depends on the "fork_user" flag and "fork_cxy" variable that can be
    493  * stored in the calling thread descriptor by the specific fork_place() system call.
    494  * If not, the kernel function makes a query to the DQDT to select the target cluster.
    495  ******************************************************************************************
    496  * @ if success, returns child process PID to parent, and return O to child.
    497  * @ if failure, returns -1 to parent / no child process is created.
    498  *****************************************************************************************/
    499 int sys_fork( void );
    500 
    501 /******************************************************************************************
    502  * [37] This function implement the "exec" system call on the kernel side.
    503  * It creates, in the same cluster as the calling thread, a new process descriptor,
    504  * and a new associated main thread descriptor, executing a new memory image defined
    505  * by the <filename> argument. This new process inherit from the old process the PID
    506  * and the PPID, as well as all open files (including the TXT).
    507  * The old process descriptor, and all its threads are blocked, and marked for deletion.
    508  * Therefore the exec syscall does not return to the calling thread in case of success.
    509  * This function build an exec_info_t structure containing the new process arguments,
    510  * as defined by the <arv> argument, and the new process environment variables,
    511  * as defined by the <envp>  argument.
    512  * TODO : the <argv> and <envp> arguments are not supported yet (both must be NULL).
    513  ******************************************************************************************
    514  * @ filename : string pointer on .elf filename (pointer in user space)
    515  * @ argv     : array of strings on process arguments (pointers in user space)
    516  * @ envp     : array of strings on environment variables (pointers in user space)
    517  * @ does not return if success / returns -1 if failure.
    518  *****************************************************************************************/
    519 int sys_exec( char  * filename,
    520               char ** argv,
    521               char ** envp );
    522 
    523 /******************************************************************************************
    524  * [38] This function  returns in the <stat> structure, defined in the "shared_syscalls.h"
     560 * @ sig_id    : index defining signal type (from 1 to 31).
     561 * @ handler   : pointer on fonction implementing the specific handler.
     562 * @ return 0 if success / returns -1 if failure.
     563 *****************************************************************************************/
     564int sys_signal( uint32_t   sig_id,
     565                void     * handler );
     566
     567/******************************************************************************************
     568 * This generic function implements the socket related syscalls.
     569 * The operation types mnemonics are defined in the <shared_socket> file.
     570 * The supported operations are defined in the <socket.h> & <socket.c> files.
     571 * This function ckecks the syscall arguments, and call the relevant kernel function.
     572 ******************************************************************************************
     573 * @ arg0       : operation type (mnemonics defined in shared_socket.h)
     574 * @ arg1       : depends on operation type
     575 * @ arg2       : depends on operation type
     576 * @ arg3       : depends on operation type
     577 * @ return 0 if success / return -1 if illegal argument.
     578 *****************************************************************************************/
     579int sys_socket( reg_t   arg0,
     580                reg_t   arg1,
     581                reg_t   arg2,
     582                reg_t   arg3 );
     583
     584/******************************************************************************************
     585 * This function  returns in the <stat> structure, defined in the "shared_syscalls.h"
    525586 * file, various informations on the file/directory identified by the <pathname> argument.
    526587 * TODO only the <st_ino>, <st_mode>,<st_uid>,<st_gid>,<st_size> are set.
    … …  
    534595
    535596/******************************************************************************************
    536  * [39] This blocking function waits a change of a child process state, that can be:
     597 * This function implements the "sync" system call.
     598 * It forces all modified pages in all kernel mappers to be copied to the IOC device.
     599 * It can be called by any thread running in any cluster.
     600 * TODO not implemented yet.
     601 ******************************************************************************************
     602 * @ return 0 if success / return -1 if failure.
     603 *****************************************************************************************/
     604int sys_sync( void );
     605
     606/******************************************************************************************
     607 * This function returns in the structure <tv>, defined in the time.h file,
     608 * the current time (in seconds & micro-seconds).
     609 * It is computed from the calling core descriptor.
     610 * The timezone is not supported.
     611 ******************************************************************************************
     612 * @ tv      : pointer on the timeval structure.
     613 * @ tz      : pointer on the timezone structure : must be NULL.       
     614 * @ return 0 if success / returns -1 if failure.
     615 *****************************************************************************************/
     616int sys_timeofday( struct timeval  * tv,
     617                   struct timezone * tz );
     618
     619/******************************************************************************************
     620 * This function requests a target thread identified by its <trdid> argument
     621 * to be cancelled. It calls the thread_kill() function to block the target thread
     622 * on the THREAD_BLOCKED_GLOBAL condition, and to set the THREAD_FLAG_REQ_DELETE.
     623 * The thread will be detached from its process, and the memory allocated to the thread
     624 * descriptor will be released by the scheduler at the next scheduling point.
     625 ******************************************************************************************
     626 * @ trdid   : thread identifier.
     627 * @ return 0 if success / return -1 if illegal argument.
     628 *****************************************************************************************/
     629int sys_thread_cancel( trdid_t  trdid );
     630
     631/******************************************************************************************
     632 * This function creates a new user thread. The <user_attr> argument is a pointer
     633 * on astructure containing the thread attributes, defined in thread.h file.
     634 ******************************************************************************************
     635 * @ trdid_ptr   : [out] pointer on buffer for created thread trdid.
     636 * @ user_attr   : [in]  pointer on thread attributes structure.
     637 * @ start_func  : [in]  pointer on start function.
     638 * @ start_args  : [in]  pointer on start function arguments.
     639 * @ return 0 if success / return -1 if failure.
     640 *****************************************************************************************/
     641int sys_thread_create( trdid_t               * trdid_ptr,
     642                       struct pthread_attr_s * user_attr,
     643                       void                  * start_func,
     644                       void                  * start_args );
     645
     646/******************************************************************************************
     647 * This function detach a joinable thread.
     648 ******************************************************************************************
     649 * @ trdid   : thread identifier.
     650 * @ return 0 if success / return -1 if failure.
     651 *****************************************************************************************/
     652int sys_thread_detach( trdid_t  trdid );
     653
     654/******************************************************************************************
     655 * This function terminates the execution of the calling user thread, and makes
     656 * the <exit_status> pointer available to any successful pthread_join() with the
     657 * terminating thread.
     658 * - If the calling thread is the main thread, it calls the sys_exit() function to delete
     659 *   completely the user process. 
     660 * - if the calling thread is not the main thread, it registers the <exit_status> pointer
     661 *   in the thread descriptor, and calls the thread_delete() function, that will set the
     662 *   THREAD_SIG_EXIT signal, set the THREAD_BLOCKED_GLOBAL bit in thread descriptor, and
     663 *   deschedules. All memory allocated to the thread is released later by the scheduler.
     664 *   If the thread is in "detached" mode, the thread_delete() function implements
     665 *   the synchonisation with the joining thread.
     666 ******************************************************************************************
     667 * @ exit_status  : [out] pointer to be returned to joining thread if thread is attached.
     668 * @ return 0 if success / return -1 if all locks not released or illegal argument.
     669 *****************************************************************************************/
     670int sys_thread_exit( void * exit_status );
     671
     672/******************************************************************************************
     673 * This blocking function suspend execution of the calling thread until completion
     674 * of another target thread identified by the <trdid> argument.
     675 * The target thread must be joinable (running in ATTACHED mode), and must be different
     676 * from the calling thread.
     677 * If the <exit_value> argument is not NULL, the value passed to pthread_exit() by the
     678 * target thread is stored in the location referenced by exit_value.
     679 ******************************************************************************************
     680 * @ trdid     : [in]  target thread identifier.
     681 * @ thread    : [out] buffer for exit_value returned by target thread.
     682 * @ return 0 if success / return -1 if failure.
     683 *****************************************************************************************/
     684int sys_thread_join( trdid_t    trdid,
     685                     void    ** exit_value );
     686
     687/******************************************************************************************
     688 * This function block the calling thread on the THREAD_BLOCKED_GLOBAL condition,
     689 * and deschedule.
     690 ******************************************************************************************
     691 * @ return 0 if success / returns -1 if failure.
     692 *****************************************************************************************/
     693int sys_thread_sleep( void );
     694
     695/******************************************************************************************
     696 * This function unblock the thread identified by its <trdid> from the
     697 * THREAD_BLOCKED_GLOBAL condition.
     698 ******************************************************************************************
     699 * @ trdid  : target thread identifier.
     700 * @ return 0 if success / return -1 if failure.
     701 *****************************************************************************************/
     702int sys_thread_wakeup( trdid_t trdid );
     703
     704/******************************************************************************************
     705 * This function calls the scheduler for the core running the calling thread.
     706 ******************************************************************************************
     707 * @ x_size   : [out] number of clusters in a row.
     708 * @ y_size   : [out] number of clusters in a column.
     709 * @ ncores   : [out] number of cores per cluster.
     710 * @ return always 0.
     711 *****************************************************************************************/
     712int sys_thread_yield( void );
     713
     714/******************************************************************************************
     715 * This debug function is used to activate / desactivate the context switches trace
     716 * for a core identified by the <cxy> and <lid> arguments.
     717 * It can be called by any other thread in the same process.
     718 ******************************************************************************************
     719 * @ active     : activate trace if true / desactivate trace if false.
     720 * @ cxy        : cluster identifier.
     721 * @ lid        : core local index.
     722 * @ returns O if success / returns -1 if failure.
     723 *****************************************************************************************/
     724int sys_trace( bool_t   active,
     725               cxy_t    cxy,
     726               lid_t    lid );
     727
     728/******************************************************************************************
     729 * This function implement the operations related to User Thread Local Storage.
     730 * It is actually implemented as an uint32_t variable in the thread descriptor.
     731 ******************************************************************************************
     732 * @ operation  : UTLS operation type as defined below.
     733 * @ value      : argument value for the UTLS_SET operation.
     734 * @ return value for the UTLS_GET and UTLS_GET_ERRNO / return -1 if failure.
     735 *****************************************************************************************/
     736int sys_utls( uint32_t operation,
     737              uint32_t value );
     738
     739/******************************************************************************************
     740 * This function removes a directory entry identified by the <pathname> from the
     741 * directory, and decrement the link count of the file referenced by the link.
     742 * If the link count reduces to zero, and no process has the file open, then all resources
     743 * associated with the file are reclaimed.  If one or more process have the file open when
     744 * the last link is removed, the link is removed, but the removal of the file is delayed
     745 * until all references to it have been closed.
     746 ******************************************************************************************
     747 * @ pathname   : pathname (can be relative or absolute).
     748 * @ returns 0 if success / returns -1 if failure.
     749 *****************************************************************************************/
     750int sys_unlink( char * pathname );
     751
     752/******************************************************************************************
     753 * This blocking function waits a change of a child process state, that can be:
    537754 * - a termination of child following a process_make_exit().
    538755 * - a termination of child following a process_make_kill().
    … …  
    558775
    559776/******************************************************************************************
    560  * [40] This function implement the non-standard get_config() syscall.
    561  * It returns the global hardware platform parameters in the <config> shared structure,
    562  * that is defined in the shared_almos.h file.
    563  ******************************************************************************************
    564  * @ config   : [out] pointer on the hard_config_t structure in user space.
    565  * @ return 0 if success / return -1 if illegal argument
    566  *****************************************************************************************/
    567 int sys_get_config( struct hard_config_s * config );
    568 
    569 /******************************************************************************************
    570  * [41] This function implements the non-standard get_core_id() syscall.
    571  * It returns in <cxy> and <lid> the calling core cluster and local index.
    572  ******************************************************************************************
    573  * @ cxy      : [out] cluster identifier (fixed format)
    574  * @ lid      : [out] core local index in cluster.
    575  * @ return 0 if success / return -1 if illegal arguments
    576  *****************************************************************************************/
    577 int sys_get_core_id( uint32_t * cxy,
    578                      uint32_t * lid );
    579 
    580 /******************************************************************************************
    581  * [42] This function implements the non-standard get_cycle() syscall.
    582  * It returns in a 64 bits user buffer the calling core cycles count.
    583  * It uses both the hardware register and the core descriptor cycles count to take
    584  * into account a possible harware register overflow  in 32 bits architectures.
    585  ******************************************************************************************
    586  * cycle    : [out] address of buffer in user space.
    587  * @ return 0 if success / return -1 if illegal arguments
    588  *****************************************************************************************/
    589 int sys_get_cycle( uint64_t * cycle );
    590 
    591 /******************************************************************************************
    592  * [43] This debug function displays on the kernel terminal TXT0 an user defined string,
    593  * or the current state of a kernel structure, identified by the <type> argument.
    594  * The <arg0>, <arg1>, and <arg2> arguments depends on the structure type.
    595  ******************************************************************************************
    596  * type      : [in] type of display
    597  * arg0      : [in] type dependant argument.
    598  * arg1      : [in] type dependant argument.
    599  * arg2      : [in] type dependant argument.
    600  * @ return 0 if success / return -1 if illegal arguments
    601  *****************************************************************************************/
    602 int sys_display( reg_t  type,
    603                  reg_t  arg0,
    604                  reg_t  arg1,
    605                  reg_t  arg2 );
    606 
    607 /******************************************************************************************
    608  * [44] This function implements the non-standard place_fork() syscall.
    609  * It can be used to specify the target cluster <cxy> for a new process created
    610  * by a subsequent fork() syscall.
    611  * WARNING: it must be called before each fork() syscall, as the placement specification
    612  *          is reset by the fork syscall.
    613  ******************************************************************************************
    614  * @ cxy    : cluster identifier.
    615  * @ return 0 if success / return -1 if failure.
    616  *****************************************************************************************/
    617 int sys_place_fork( uint32_t cxy );
    618 
    619 /******************************************************************************************
    620  * [45] This function block the calling thread on the THREAD_BLOCKED_GLOBAL condition,
    621  * and deschedule.
    622  ******************************************************************************************
    623  * @ return 0 if success / returns -1 if failure.
    624  *****************************************************************************************/
    625 int sys_thread_sleep( void );
    626 
    627 /******************************************************************************************
    628  * [46] This function unblock the thread identified by its <trdid> from the
    629  * THREAD_BLOCKED_GLOBAL condition.
    630  ******************************************************************************************
    631  * @ trdid  : target thread identifier.
    632  * @ return 0 if success / return -1 if failure.
    633  *****************************************************************************************/
    634 int sys_thread_wakeup( trdid_t trdid );
    635 
    636 /******************************************************************************************
    637  * [47] This debug function is used to activate / desactivate the context switches trace
    638  * for a core identified by the <cxy> and <lid> arguments.
    639  * It can be called by any other thread in the same process.
    640  ******************************************************************************************
    641  * @ active     : activate trace if true / desactivate trace if false.
    642  * @ cxy        : cluster identifier.
    643  * @ lid        : core local index.
    644  * @ returns O if success / returns -1 if failure.
    645  *****************************************************************************************/
    646 int sys_trace( bool_t   active,
    647                cxy_t    cxy,
    648                lid_t    lid );
    649 
    650 /******************************************************************************************
    651  * [48] This function gives the process identified by the <pid> argument
    652  * the exclusive ownership of its TXT_TX terminal (put it in foreground).
    653  ******************************************************************************************
    654  * @ pid    : process identifier.
    655  * @ return 0 if success / return -1 if failure.
    656  *****************************************************************************************/
    657 int sys_fg( pid_t   pid );
    658 
    659 /******************************************************************************************
    660  * [49] This function returns a non-zero value in the <is_fg> buffer when the process
    661  * identified by the <pid> argument is the current TXT owner.
    662  ******************************************************************************************
    663  * @ pid      : process identifier.
    664  * @ is_fg    : pointer on buffer.
    665  * @ return 0 if success / return -1 if failure.
    666  *****************************************************************************************/
    667 int sys_is_fg( pid_t      pid,
    668                uint32_t * is_fg );
    669 
    670 /******************************************************************************************
    671  * [50] This function implements the "exit" system call terminating a POSIX process.
    672  * It can be called by any thread running in any cluster.
    673  * It uses both remote accesses to access the owner process descriptor, and the
    674  * RPC_PROCESS_SIGACTION to delete remote process copies and thread descriptors.
    675  * In the present implementation, this function implements actually the _exit():
    676  * - it does not flush open output streams.
    677  * - it does not close open streams.
    678  ******************************************************************************************
    679  * @ status   : terminaison status returned to parent process.
    680  * @ return 0 if success / return -1 if failure.
    681  *****************************************************************************************/
    682 int sys_exit( uint32_t status );
    683 
    684 /******************************************************************************************
    685  * [51] This function implements the "sync" system call.
    686  * It forces all modified pages in all kernel mappers to be copied to the IOC device.
    687  * It can be called by any thread running in any cluster.
    688  * TODO not implemented yet.
    689  ******************************************************************************************
    690  * @ return 0 if success / return -1 if failure.
    691  *****************************************************************************************/
    692 int sys_sync( void );
    693 
    694 /******************************************************************************************
    695  * [52] This function implements the "fsync" system call.
    696  * It forces all modified pages of the file mapper identified by the <fd> argument
    697  * to be copied to the IOC device.
    698  * It can be called by any thread running in any cluster.
    699  * TODO not implemented yet.
    700  ******************************************************************************************
    701  * @ file_id   : file descriptor index in fd_array.
    702  * @ return 0 if success / return -1 if failure.
    703  *****************************************************************************************/
    704 int sys_fsync( uint32_t file_id );
    705 
    706 /******************************************************************************************
    707  * [53] This function implements the non-standard "get_best_core" syscall.
    708  * It selects, in a macro-cluster specified by the <base_cxy> and <level> arguments,
    709  * the core that has the lowest load.
    710  * When an active core has been found in the target macro-cluster, it writes into the
    711  * <cxy> and <lid> buffers the cluster identifier and the core local index, and return 0.
    712  * It returns -1 in case of illegal arguments (level / cxy / lid).
    713  * It returns +1 if there is no active core in specified macro-cluster.
    714  ******************************************************************************************
    715  * @ base_cxy : [in]  any cluster identifier in macro-cluster.
    716  * @ level    : [in]  macro-cluster level in [1,2,3,4,5].
    717  * @ cxy      : [out] selected core cluster identifier.
    718  * @ lid      : [out] selected core local index in cluster.
    719  * @ return 0 if success / -1 if illegal arguments / +1 if no core in macro-clusters.
    720  *****************************************************************************************/
    721 int sys_get_best_core( uint32_t   base_cxy,
    722                        uint32_t   level,
    723                        uint32_t * cxy,
    724                        uint32_t * lid );
    725 
    726 /******************************************************************************************
    727  * [54] This function implements the non-standard "get_nb_cores" syscall.
    728  * It writes in the <ncores> buffer the number of cores in the target cluster <cxy>.
    729  ******************************************************************************************
    730  * @ cxy      : [in]  target cluster identifier.
    731  * @ ncores   : [out] number of cores / 0 if cluster cxy undefined in architecture.
    732  * @ return 0 if success / return -1 if illegal "ncores" arguments.
    733  *****************************************************************************************/
    734 int sys_get_nb_cores( uint32_t   cxy,
    735                       uint32_t * ncores );
    736 
    737 /******************************************************************************************
    738  * [55] This function implements the non-standard "get_thread_info" syscall.
    739  * It copies in the user structure defined by the <info> argument the values registered
    740  * in the calling thread "thread_info_t" kernel structure.
    741  ******************************************************************************************
    742  * @ info      : [out] pointer on thread_info_t structure in user space.
    743  * @ return 0 if success / return -1 if illegal argument.
    744  *****************************************************************************************/
    745 int sys_get_thread_info( thread_info_t * info );
    746 
    747 /******************************************************************************************
    748  * [56] This generic function implements the non-standard FBF related syscalls.
    749  * The operation types mnemonics are defined in the <shared_fbf> file.
    750  * The supported operations are defined in the <almosmkh.h> & <almosmkh.c> files.
    751  * This function ckecks the syscall arguments, and call the relevant kernel function.
    752  ******************************************************************************************
    753  * @ arg0       : operation type (mnemonics defined in shared_fbf.h)
    754  * @ arg1       : depends on operation type
    755  * @ arg2       : depends on operation type
    756  * @ arg3       : depends on operation type
    757  * @ return 0 if success / return -1 if illegal argument.
    758  *****************************************************************************************/
    759 int sys_fbf( reg_t   arg0,
    760              reg_t   arg1,
    761              reg_t   arg2,
    762              reg_t   arg3 );
    763 
    764 /******************************************************************************************
    765  * [57] This generic function implements the socket related syscalls.
    766  * The operation types mnemonics are defined in the <shared_socket> file.
    767  * The supported operations are defined in the <socket.h> & <socket.c> files.
    768  * This function ckecks the syscall arguments, and call the relevant kernel function.
    769  ******************************************************************************************
    770  * @ arg0       : operation type (mnemonics defined in shared_socket.h)
    771  * @ arg1       : depends on operation type
    772  * @ arg2       : depends on operation type
    773  * @ arg3       : depends on operation type
    774  * @ return 0 if success / return -1 if illegal argument.
    775  *****************************************************************************************/
    776 int sys_socket( reg_t   arg0,
    777                 reg_t   arg1,
    778                 reg_t   arg2,
    779                 reg_t   arg3 );
     777 * This function writes bytes to an open file identified by its file descriptor.
     778 * The file can be a regular file or character oriented device. For a regular file,
     779 * the target inode "size" field is updated if (offset + count) is larger than the
     780 * current "size" value. The size value registered in the mappers of the parent(s)
     781 * directory are not modified and will be asynchronously updated when the file is closed.
     782 * IRQs are enabled during this system call.
     783 ******************************************************************************************
     784 * @ file_id  : open file index in fd_array.
     785 * @ buf      : buffer virtual address in user space.
     786 * @ count    : number of bytes.
     787 * @ returns number of bytes actually written if success / returns -1 if failure.
     788 *****************************************************************************************/
     789int sys_write( uint32_t   file_id,
     790               void     * buf,
     791               uint32_t   count );
     792
    780793
    781794#endif  // _SYSCALLS_H_
Note: See TracChangeset for help on using the changeset viewer.