source: trunk/kernel/syscalls/syscalls.h @ 619

Last change on this file since 619 was 619, checked in by alain, 5 years ago

1) Fix a bug in KSH : after the "load" command,

the [ksh] prompt is now printed after completion
of the loaded application.

2) Fix a bug in vmm_handle_cow() : the copy-on-write

use now a hal_remote_memcpy() to replicate the page content.
File size: 40.0 KB
RevLine 
[1]1/*
[407]2 * syscalls.h - Kernel side services for syscall handling.
[1]3 *
[457]4 * Author     Alain Greiner (2016,2017,2018)
[1]5 *
6 * Copyright (c) UPMC Sorbonne Universites
7 *
8 * This file is part of ALMOS-MKH.
9 *
10 * ALMOS-MKH is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; version 2.0 of the License.
13 *
14 * ALMOS-MKH is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17 * General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with ALMOS-MKH; if not, write to the Free Software Foundation,
21 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22 */
23
[16]24#ifndef _SYSCALLS_H_
25#define _SYSCALLS_H_
[1]26
[457]27#include <hal_kernel_types.h>
[407]28#include <shared_syscalls.h>
[23]29
[407]30/**   Forward declarations  *****/
[23]31
32struct thread_s;                  // defined in thread.h
33struct pthread_attr_s;            // defined in thread.h
34struct vfs_stat_s;                // defined in vfs.h
35struct vfs_dirent_s;              // defined in vfs.h
36struct mmap_attr_s;               // defined in vmm.h
37
[407]38/******************************************************************************************
39 * [0] This function terminates the execution of the calling user thread,
[23]40 * and makes the exit_value pointer available to any successful pthread_join() with the
41 * terminating thread.
[409]42 * It actually set the THREAD_SIG_EXIT signal, set the THREAD_BLOCKED_GLOBAL bit in the
43 * thread descriptor and deschedule.
44 * The thread will be detached from its process, and the memory allocated to the thread
45 * descriptor will be released later by the scheduler.
[407]46 ******************************************************************************************
[409]47 * @ exit_vallue  : pointer to be returned to joining thread if thread is attached.
48 * @ return 0 if success / return -1 if all locks not released or illegal argument.
[407]49 *****************************************************************************************/
[23]50int sys_thread_exit( void * exit_value );
[16]51
[407]52/******************************************************************************************
53 * [1] This function calls the scheduler for the core running the calling thread.
54 ******************************************************************************************
55 * @ x_size   : [out] number of clusters in a row.
56 * @ y_size   : [out] number of clusters in a column.
57 * @ ncores   : [out] number of cores per cluster.
58 * @ return always 0.
59 *****************************************************************************************/
[479]60int sys_thread_yield( void );
[16]61
[407]62/******************************************************************************************
[23]63 * [2] This function creates a new user thread. The <user_attr> argument is a pointer
64 * on astructure containing the thread attributes, defined in thread.h file.
[407]65 ******************************************************************************************
[566]66 * @ trdid_ptr   : [out] pointer on buffer for created thread trdid.
[23]67 * @ user_attr   : [in]  pointer on thread attributes structure.
68 * @ start_func  : [in]  pointer on start function.
69 * @ start_args  : [in]  pointer on start function arguments.
70 * @ return 0 if success / return -1 if failure.
[407]71 *****************************************************************************************/
[566]72int sys_thread_create( trdid_t               * trdid_ptr,
73                       struct pthread_attr_s * user_attr,
74                       void                  * start_func,
75                       void                  * start_args );
[16]76
[407]77/******************************************************************************************
[23]78 * [3] This blocking function suspend execution of the calling thread until completion
79 * of another target thread identified by the <trdid> argument.
[421]80 * The target thread must be joinable (running in ATTACHED mode), and must be different
81 * from the calling thread.
[23]82 * If the <exit_value> argument is not NULL, the value passed to pthread_exit() by the
83 * target thread is stored in the location referenced by exit_value.
[407]84 ******************************************************************************************
[23]85 * @ trdid     : [in]  target thread identifier.
86 * @ thread    : [out] buffer for exit_value returned by target thread.
87 * @ return 0 if success / return -1 if failure.
[407]88 *****************************************************************************************/
[23]89int sys_thread_join( trdid_t    trdid,
90                     void    ** exit_value );
[16]91
[407]92/******************************************************************************************
[23]93 * [4] This function detach a joinable thread.
[407]94 ******************************************************************************************
[409]95 * @ trdid   : thread identifier.
[23]96 * @ return 0 if success / return -1 if failure.
[407]97 *****************************************************************************************/
[23]98int sys_thread_detach( trdid_t  trdid );
[16]99
[407]100/******************************************************************************************
[409]101 * [5] This function requests a target thread identified by its <trdid> argument
[436]102 * to be cancelled. It calls the thread_kill() function to block the target thread
103 * on the THREAD_BLOCKED_GLOBAL condition, and to set the THREAD_FLAG_REQ_DELETE.
[409]104 * The thread will be detached from its process, and the memory allocated to the thread
[436]105 * descriptor will be released by the scheduler at the next scheduling point.
[409]106 ******************************************************************************************
107 * @ trdid   : thread identifier.
108 * @ return 0 if success / return -1 if illegal argument.
[407]109 *****************************************************************************************/
[409]110int sys_thread_cancel( trdid_t  trdid );
[16]111
[407]112/******************************************************************************************
[23]113 * [6] This function implement all operations on a POSIX unnamed semaphore,
114 * that can be shared by threads running in different clusters.
115 * The kernel structure representing a remote semaphore is in the remote_sem.h file,
116 * and the code implementing the operations is in the remore_sem.c file.
[407]117 ******************************************************************************************
[457]118 * @ vaddr         : semaphore virtual address in user space == identifier.
119 * @ operation     : SEM_INIT / SEM_DESTROY / SEM_GETVALUE / SEM_POST / SEM_WAIT.
120 * @ init_value    : initial semaphore value.
121 * @ current_value : pointer on buffer for current semaphore value.
[23]122 * @ return 0 if success / return -1 if failure.
[407]123 *****************************************************************************************/
[23]124int sys_sem( void       * vaddr,
125             uint32_t     operation,
[457]126             uint32_t     init_value,
127             uint32_t   * current_value );
[16]128
[407]129/******************************************************************************************
[23]130 * [7] This function implement all operations on a POSIX condition variable.
[566]131 * The kernel structure representing a condvar is defined in the remote_condvar.h file,
132 * The code implementing the operations is defined in the remote_condvar.c file.
[407]133 ******************************************************************************************
[23]134 * @ vaddr     : condvar virtual address in user space == identifier.
135 * @ operation : operation type (see below).
136 * @ attr      : mutex virtual address in user space == identifier.
137 * @ return 0 if success / return -1 if failure.
[407]138 *****************************************************************************************/
[23]139int sys_condvar( void     * condvar,
140                 uint32_t   operation,
141                 void     * mutex );
[16]142
[407]143/******************************************************************************************
[23]144 * [8] This function implement all operations on a POSIX barrier.
145 * The kernel structure representing a barrier is defined in the remote_barrier.h file.
146 * The code implementting the operations is defined in the remote_barrier.c file.
[407]147 ******************************************************************************************
[619]148 * @ vaddr     : barrier address in user space == identifier.
[23]149 * @ operation : BARRIER_INIT / BARRIER_DESTROY / BARRIER_WAIT.
[619]150 * @ count     : number of expected threads (only used by BARRIER_INIT).
151 * @ attr      : barrier attributes address in user space (only used by BARRIER_INIT).
[23]152 * @ return 0 if success / return -1 if failure.
[407]153 *****************************************************************************************/
[619]154int sys_barrier( intptr_t   vaddr,
[23]155                 uint32_t   operation,
[619]156                 uint32_t   count,
157                 intptr_t   attr );
[16]158
[407]159/******************************************************************************************
[23]160 * [9] This function implement all operations on a POSIX mutex.
161 * The kernel structure representing a barrier is defined in the remote_barrier.h file.
162 * The code implementting the operations is defined in the remote_barrier.c file.
[407]163 ******************************************************************************************
[23]164 * @ vaddr     : mutex virtual address in user space == identifier.
165 * @ operation : MUTEX_INIT / MUTEX_DESTROY / MUTEX_LOCK / MUTEX_UNLOCK
166 * @ attr      : mutex attributes (non supported yet => must be 0).
167 * @ return 0 if success / return -1 if failure.
[407]168 *****************************************************************************************/
[23]169int sys_mutex( void     * vaddr,
170               uint32_t   operation,
171               uint32_t   count );
[16]172
[407]173/******************************************************************************************
[610]174 * [10] This function causes the file named <old> to be renamed as <new>.
175 * If new exists, it is first removed.  Both old and new must be of the same type (both
176 * must be either directories or non-directories) and must reside on the same file system.
177 * It guarantees that an instance of <new> will always exist, even if the system should
178 * crash in the middle of the operation.
[407]179 ******************************************************************************************
[610]180 * @ old      : old file name.
181 * @ new      : new file name.
182 * @ return 0 if success / return -1 if failure.
[407]183 *****************************************************************************************/
[610]184int sys_rename( char *old,
185                char *new );
[16]186
[407]187/******************************************************************************************
[408]188 * [11] This function remove an existing mapping defined by the <addr> and <size>
[407]189 * arguments in user space.
190 ******************************************************************************************
191 * @ addr  : base address in user space.
192 * # size  : number of bytes.
[23]193 * @ return 0 if success / return -1 if failure.
[407]194 *****************************************************************************************/
195int sys_munmap( void     * addr,
196                uint32_t   size );
[16]197
[407]198/******************************************************************************************
199 * [12] This function open or create an open file descriptor.
200 ******************************************************************************************
[23]201 * @ pathname   : pathname (can be relative or absolute).
[445]202 * @ flags      : bit vector attributes (see in shared_fcntl.h file)
[23]203 * @ mode       : access rights.
204 * @ return file descriptor index in fd_array if success / return -1 if failure.
[407]205 *****************************************************************************************/
[566]206int sys_open( char       * pathname,
[506]207              uint32_t     flags,
208              uint32_t     mode );
[16]209
[407]210/******************************************************************************************
211 * [13] This function map physical memory (or a file) in the calling thread virtual space.
212 * The <attr> argument is a pointer on a structure for arguments (see shared_syscalls.h).
[594]213 * The user defined virtual address (MAP_FIXED flag) is not supported.
214 * TODO : the access rights checking is not implemented yet [AG]
215 * TODO : the Copy on Write for MAP_PRIVATE is not implemented yet [AG]
[407]216 ******************************************************************************************
217 * @ attr       : pointer on attributes structure.
218 * @ return 0 if success / return -1 if failure.
219 *****************************************************************************************/
220int sys_mmap( mmap_attr_t * attr );
[23]221
[407]222/******************************************************************************************
[23]223 * [14] This function read bytes from an open file identified by its file descriptor.
[407]224 * The file can be a regular file or character oriented device.
[408]225 * IRQs are enabled during this system call.
[407]226 ******************************************************************************************
[23]227 * @ file_id  : open file index in fd_array.
228 * @ buf      : buffer virtual address in user space.
229 * @ count    : number of bytes.
230 * @ return number of bytes actually read if success / returns -1 if failure.
[407]231 *****************************************************************************************/
[23]232int sys_read( uint32_t   file_id,
233              void     * buf,
234              uint32_t   count );
[16]235
[407]236/******************************************************************************************
[23]237 * [15] This function writes bytes to an open file identified by its file descriptor.
[407]238 * The file can be a regular file or character oriented device.
[408]239 * IRQs are enabled during this system call.
[407]240 ******************************************************************************************
[23]241 * @ file_id  : open file index in fd_array.
242 * @ buf      : buffer virtual address in user space.
243 * @ count    : number of bytes.
244 * @ return number of bytes actually written if success / returns -1 if failure.
[407]245 *****************************************************************************************/
[23]246int sys_write( uint32_t   file_id,
247               void     * buf,
248               uint32_t   count );
[16]249
[407]250/******************************************************************************************
251 * [16] This function repositions the offset of the file descriptor identified by <file_id>,
252 * according to the operation type defined by the <whence> argument.
253 ******************************************************************************************
[23]254 * @ file_id  : open file index in fd_array.
[407]255 * @ offset   : used to compute new offset value.
[23]256 * @ whence   : operation type (see below).
257 * @ return 0 if success / returns -1 if failure.
[407]258 *****************************************************************************************/
[23]259int sys_lseek( xptr_t    file_id,
260               uint32_t  offset,
261               uint32_t  whence );
[16]262
[407]263/******************************************************************************************
[23]264 * [17] This function release the memory allocated for the file descriptor identified by
265 * the <file_id> argument, and remove the fd array_entry in all copies of the process
266 * descriptor.
[407]267 ******************************************************************************************
[23]268  file_id   : file descriptor index in fd_array.
269 * @ return 0 if success / returns -1 if failure.
[407]270 *****************************************************************************************/
[23]271int sys_close( uint32_t file_id );
[16]272
[407]273/******************************************************************************************
274 * [18] This function removes a directory entry identified by the <pathname> from the
[23]275 * directory, and decrement the link count of the file referenced by the link.
276 * If the link count reduces to zero, and no process has the file open, then all resources
277 * associated with the file are reclaimed.  If one or more process have the file open when
278 * the last link is removed, the link is removed, but the removal of the file is delayed
279 * until all references to it have been closed.
[407]280 ******************************************************************************************
[23]281 * @ pathname   : pathname (can be relative or absolute).
282 * @ return 0 if success / returns -1 if failure.
[407]283 *****************************************************************************************/
[566]284int sys_unlink( char * pathname );
[16]285
[407]286/******************************************************************************************
[23]287 * [19] This function creates in the calling thread cluster an unnamed pipe, and two
288 * (read and write) file descriptors.
[594]289 * TODO not implemented yet [AG]
[407]290 ******************************************************************************************
[23]291 * @ file_id[0] : [out] read only file descriptor index.
292 * @ file_id[1] : [out] write only file descriptor index.
293 * @ return 0 if success / return -1 if failure.
[407]294 *****************************************************************************************/
[23]295int sys_pipe( uint32_t file_id[2] );
[16]296
[407]297/******************************************************************************************
[23]298 * [20] This function change the current working directory in reference process descriptor.
[407]299 ******************************************************************************************
[23]300 * @ pathname   : pathname (can be relative or absolute).
301 * @ return 0 if success / returns -1 if failure.
[407]302 *****************************************************************************************/
[566]303int sys_chdir( char * pathname );
[16]304
[407]305/******************************************************************************************
[610]306 * [21] This function implements the "mkdir" system call, creating a new directory in
307 * the file system, as defined by the <pathname> argument, with the access permission
308 * defined by the <rights> argument. All nodes but the last in the pathname must exist.
309 * It can be called by any thread running in any cluster.
[407]310 ******************************************************************************************
[610]311 * @ pathname  : pathname defining the new directory location in file system.
312 * @ rights    : access rights (non used yet).
313 * @ return 0 if success / return -1 if failure.
[407]314 *****************************************************************************************/
[610]315int sys_mkdir( char     * pathname,
316               uint32_t   rights );
[16]317
[407]318/******************************************************************************************
[23]319 * [22] This function creates a named FIFO file in the calling thread cluster.
320 * The associated read and write file descriptors mut be be  explicitely created
[407]321 * using the sys_open() function.
322 ******************************************************************************************
[23]323 * @ pathname   : pathname (can be relative or absolute).
324 * @ mode       : access rights (as defined in chmod).
325 * @ return 0 if success / returns -1 if failure.
[407]326 *****************************************************************************************/
[23]327int sys_mkfifo( char     * pathname,
328                uint32_t   mode );
[16]329
[407]330/******************************************************************************************
331 * [23] This function open a directory, that must exist in the file system, returning
[611]332 * a DIR pointer on the dirent array in user space.
[407]333 ******************************************************************************************
[611]334 * @ pathname   : [in]  pathname (can be relative or absolute).
[407]335 * @ dirp       : [out] buffer for pointer on user directory (DIR).
[23]336 * @ return 0 if success / returns -1 if failure.
[407]337 *****************************************************************************************/
338int sys_opendir( char * pathname,
339                 DIR ** dirp );
[16]340
[407]341/******************************************************************************************
342 * [24] This function returns an user pointer on the dirent structure describing the
343 * next directory entry in the directory identified by the <dirp> argument.
344 ******************************************************************************************
[611]345 * @ dirp     : [in]  user pointer on dirent array identifying the open directory.
346 * @ buffer   : [out] pointer on user buffer for a pointer on dirent in user space.
[407]347 * @ return O if success / returns -1 if failure.
348 *****************************************************************************************/
349int sys_readdir( DIR            * dirp,
[611]350                 struct dirent ** buffer );
[407]351
352/******************************************************************************************
353 * [25] This function closes the directory identified by the <dirp> argument, and releases
354 * all structures associated with the <dirp> pointer.
355 ******************************************************************************************
[611]356 * @ dirp     : [in] user pointer on dirent array identifying the open directory.
[23]357 * @ return 0 if success / returns -1 if failure.
[407]358 *****************************************************************************************/
359int sys_closedir( DIR * dirp );
[16]360
[407]361/******************************************************************************************
[23]362 * [26] This function returns the pathname of the current working directory.
[407]363 ******************************************************************************************
[23]364 * buf     : buffer addres in user space.
365 * nbytes  : user buffer size in bytes.
366 * @ return 0 if success / returns -1 if failure.
[407]367 *****************************************************************************************/
[23]368int sys_getcwd( char     * buf,
369                uint32_t   nbytes );
[16]370
[407]371/******************************************************************************************
[437]372 * [27] This function tests whether a given file descriptor dentified by the <file_id>
373 * argument is an open file descriptor referring to a terminal.
374 ******************************************************************************************
375 * @ file_id   : file descriptor index
376 * @ return 1 if it is a TXT device / return 0 if it is not a TXT device.
[407]377 *****************************************************************************************/
[437]378int sys_isatty( uint32_t file_id );
[16]379
[407]380/******************************************************************************************
[23]381 * [28] This function forces the calling thread to sleep, for a fixed number of cycles.
[407]382 ******************************************************************************************
[23]383 * cycles   : number of cycles.
[407]384 *****************************************************************************************/
[23]385int sys_alarm( uint32_t cycles );
[16]386
[407]387/******************************************************************************************
388 * [29] This function removes a directory file whose name is given by <pathname>.
389 * The directory must not have any entries other than `.' and `..'.
390 ******************************************************************************************
[23]391 * @ pathname   : pathname (can be relative or absolute).
392 * @ return 0 if success / returns -1 if failure.
[407]393 *****************************************************************************************/
[566]394int sys_rmdir( char * pathname );
[16]395
[407]396/******************************************************************************************
[23]397 * [30] This function implement the operations related to User Thread Local Storage.
398 * It is actually implemented as an uint32_t variable in the thread descriptor.
[407]399 ******************************************************************************************
[23]400 * @ operation  : UTLS operation type as defined below.
401 * @ value      : argument value for the UTLS_SET operation.
402 * @ return value for the UTLS_GET and UTLS_GET_ERRNO / return -1 if failure.
[407]403 *****************************************************************************************/
[23]404int sys_utls( uint32_t operation,
405              uint32_t value );
[16]406
[407]407/******************************************************************************************
[23]408 * [31] This function change the acces rights for the file/dir identified by the
409 * pathname argument.
[407]410 ******************************************************************************************
[23]411 * @ pathname   : pathname (can be relative or absolute).
412 * @ rights     : acces rights.
413 * @ return 0 if success / returns -1 if failure.
[407]414 *****************************************************************************************/
[566]415int sys_chmod( char       * pathname,
[506]416               uint32_t     rights );
[16]417
[407]418/******************************************************************************************
[23]419 * [32] This function associate a specific signal handler to a given signal type.
[584]420 * The handlers for the SIGKILL and SIGSTOP signals cannot be redefined.
[407]421 ******************************************************************************************
[23]422 * @ sig_id    : index defining signal type (from 1 to 31).
423 * @ handler   : pointer on fonction implementing the specific handler.
424 * @ return 0 if success / returns -1 if failure.
[407]425 *****************************************************************************************/
[23]426int sys_signal( uint32_t   sig_id,
427                void     * handler );
[16]428
[407]429/******************************************************************************************
[23]430 * [33] This function returns in the structure <tv>, defined in the time.h file,
431 * the current time (in seconds & micro-seconds).
432 * It is computed from the calling core descriptor.
433 * The timezone is not supported.
[407]434 ******************************************************************************************
[23]435 * @ tv      : pointer on the timeval structure.
436 * @ tz      : pointer on the timezone structure : must be NULL.       
437 * @ return 0 if success / returns -1 if failure.
[407]438 *****************************************************************************************/
[50]439int sys_timeofday( struct timeval  * tv,
440                   struct timezone * tz );
[16]441
[407]442/******************************************************************************************
[433]443 * [34] This function implements the "kill" system call on the kernel side.
[23]444 * It register the signal defined by the <sig_id> argument in all thread descriptors
445 * of a target process identified by the <pid> argument. This is done in all clusters
446 * containing threads for the target process.
447 * It can be executed by any thread running in any cluster, as this function uses
[407]448 * remote access to traverse the list of process copies stored in the owner cluster,
[23]449 * and the RPC_SIGNAL_RISE to signal the remote threads.
[421]450 * This function does nothing for (sig_id == 0). This can be used to check process pid.
451 * TODO : This first implementation supports only SIGKILL / SIGSTOP / SIGCONT values.
[407]452 ******************************************************************************************
[16]453 * @ pid      : target process identifier.
[433]454 * @ sig_id   : index defining the signal type.
[23]455 * @ return 0 if success / returns -1 if failure.
[407]456 *****************************************************************************************/
[16]457int sys_kill( pid_t    pid,
[23]458              uint32_t sig_id );
[16]459
[407]460/******************************************************************************************
[433]461 * [35] This function implements the "getpid" system call on the kernel side.
[407]462 ******************************************************************************************
463 * @ returns the process PID for the calling thread.
464 *****************************************************************************************/
[479]465int sys_getpid( void );
[1]466
[407]467/******************************************************************************************
[433]468 * [36] This function implement the "fork" system call on the kernel side.
469 * The calling process descriptor (parent process), and the associated thread descriptor
470 * are replicated in a - likely - remote cluster, that becomes the child process owner.
471 * The child process get a new PID, and is linked to the parent PID. The child process
472 * inherit from its parent the memory image, and all open files (including the TXT).
473 * The child process becomes the TXT terminal owner.
[1]474 * The target cluster depends on the "fork_user" flag and "fork_cxy" variable that can be
475 * stored in the calling thread descriptor by the specific fork_place() system call.
[433]476 * If not, the kernel function makes a query to the DQDT to select the target cluster.
[407]477 ******************************************************************************************
478 * @ if success, returns child process PID to parent, and return O to child.
479 * @ if failure, returns -1 to parent / no child process is created.
480 *****************************************************************************************/
[479]481int sys_fork( void );
[1]482
[407]483/******************************************************************************************
[433]484 * [37] This function implement the "exec" system call on the kernel side.
485 * It creates, in the same cluster as the calling thread, a new process descriptor,
486 * and a new associated main thread descriptor, executing a new memory image defined
487 * by the <filename> argument. This new process inherit from the old process the PID
488 * and the PPID, as well as all open files (including the TXT).
489 * The old process descriptor, and all its threads are blocked, and marked for deletion.
490 * Therefore the exec syscall does not return to the calling thread in case of success.
491 * This function build an exec_info_t structure containing the new process arguments,
492 * as defined by the <arv> argument, and the new process environment variables,
493 * as defined by the <envp>  argument.
494 * TODO : the <argv> and <envp> arguments are not supported yet (both must be NULL).
[407]495 ******************************************************************************************
496 * @ filename : string pointer on .elf filename (pointer in user space)
497 * @ argv     : array of strings on process arguments (pointers in user space)
498 * @ envp     : array of strings on environment variables (pointers in user space)
[433]499 * @ does not return if success / returns -1 if failure.
[407]500 *****************************************************************************************/
[566]501int sys_exec( char  * filename,
502              char ** argv,
503              char ** envp );
[1]504
[407]505/******************************************************************************************
506 * [38] This function  returns in the <stat> structure, defined in the "shared_syscalls.h"
507 * file, various informations on the file/directory identified by the <pathname> argument.
[594]508 * TODO only the <st_ino>, <st_mode>,<st_uid>,<st_gid>,<st_size> are set.
[407]509 ******************************************************************************************
510 * @ pathname  : user pointer on file pathname.
511 * @ stat      : user pointer on the stat structure.
[23]512 * @ returns O if success / returns -1 if failure.
[407]513 *****************************************************************************************/
[566]514int sys_stat( char        * pathname,
[407]515              struct stat * stat );
[1]516
[407]517/******************************************************************************************
[433]518 * [39] This blocking function waits a change of a child process state, that can be:
519 * - a termination of child following a process_make_exit().
520 * - a termination of child following a process_make_kill().
[421]521 * - a blocking of child following a SIGSTOP signal.
[433]522 * In case of a multi-thread process, this function must be called by the main thread
523 * runningin the reference cluster.
524 * When a change has been observed, it returns the PID of the child process, and stores
525 * in the <status> argument relevant information on the child state change.
[421]526 * The following macros can be used to extract information from status:
527 * - WIFEXITED(status)   : is true if the child process terminated with an exit().
[435]528 * - WIFSIGNALED(status) : is true if the child process killed by a signal.
[421]529 * - WIFSTOPPED(status)  : is true if the child process is stopped by a signal.
530 * - WEXITSTATUS(status) : returns the low-order 8 bits of the exit() argument.
531 * If a parent process terminates without waiting for all child processes to terminate,
532 * the remaining child processes are attached to the init process.
[433]533 * WARNING: negative values for the <pid> argument are not supported.
[421]534 ******************************************************************************************
[433]535 * @ searched_pid : searched child process identifier.
536 * @ status       : [out] child termination status.
537 * @ return child PID if success / return -1 if searched PID not found.
[407]538 *****************************************************************************************/
[421]539int sys_wait( uint32_t * status );
[1]540
[407]541/******************************************************************************************
[584]542 * [40] This function implement the non-standard get_config() syscall.
543 * It returns in <x_size>, <y_size>, <ncores> the hardware platform parameters.
[407]544 ******************************************************************************************
545 * @ x_size   : [out] number of clusters in a row.
546 * @ y_size   : [out] number of clusters in a column.
547 * @ ncores   : [out] number of cores per cluster.
548 * @ return 0 if success / return -1 if illegal arguments
549 *****************************************************************************************/
550int sys_get_config( uint32_t * x_size,
551                    uint32_t * y_size,
552                    uint32_t * ncores );
[1]553
[407]554/******************************************************************************************
[584]555 * [41] This function implements the non-standard get_core() syscall.
556 * It returns in <cxy> and <lid> the calling core cluster and local index.
[407]557 ******************************************************************************************
558 * @ cxy      : [out] cluster identifier (fixed format)
559 * @ lid      : [out] core local index in cluster.
560 * @ return 0 if success / return -1 if illegal arguments
561 *****************************************************************************************/
562int sys_get_core( uint32_t * cxy,
563                  uint32_t * lid );
[1]564
[407]565/******************************************************************************************
[584]566 * [42] This function implements the non-standard get_cycle() syscall.
567 * It returns in a 64 bits user buffer the calling core cycles count.
[407]568 * It uses both the hardware register and the core descriptor cycles count to take
569 * into account a possible harware register overflow  in 32 bits architectures.
570 ******************************************************************************************
571 * cycle    : [out] address of buffer in user space.
572 * @ return 0 if success / return -1 if illegal arguments
573 *****************************************************************************************/
574int sys_get_cycle( uint64_t * cycle );
575
576/******************************************************************************************
[421]577 * [43] This debug function displays on the kernel terminal TXT0 an user defined string,
578 * or the current state of a kernel structure, identified by the <type> argument.
[611]579 * The <arg0>, <arg1>, and <arg2> arguments depends on the structure type:
[435]580 * - DISPLAY_STRING          : an user defined string
581 * - DISPLAY_VMM             : VSL and GPT for a process identified by <pid>.
582 * - DISPLAY_SCHED           : all threads allocated to a scheduler <cxy> & <lid>.
583 * - DISPLAY_CLUSTER_PROCESS : all processes registered in a cluster identified by <cxy>. 
584 * - DISPLAY_TXT_PROCESS     : all processes registered in a cluster identified by <cxy>. 
585 * - DISPLAY_VFS             : all files registered in the VFS cache.
586 * - DISPLAY_CHDEV           : all registered channel devices.
[611]587 * - DISPLAY_DQDT            : all DQDT nodes curren values.
588 * - DISPLAY_BUSYLOCKS       : all busylocks taken by one thread.
589 * - DISPLAY_MAPPER          : one page of a given mapper.
[407]590 ******************************************************************************************
[435]591 * type      : [in] type of display
[421]592 * arg0      : [in] type dependant argument.
593 * arg1      : [in] type dependant argument.
[611]594 * arg2      : [in] type dependant argument.
[407]595 * @ return 0 if success / return -1 if illegal arguments
596 *****************************************************************************************/
[421]597int sys_display( reg_t  type,
598                 reg_t  arg0,
[611]599                 reg_t  arg1,
600                 reg_t  arg2 );
[407]601
602/******************************************************************************************
[584]603 * [44] This function implements the non-standard place_fork() syscall.
604 * It can be used to specify the target cluster <cxy> for a new process created
605 * by a subsequent fork() syscall.
606 * WARNING: it must be called before each fork() syscall, as the placement specification
607 *          is reset by the fork syscall.
[457]608 ******************************************************************************************
609 * @ cxy    : cluster identifier.
610 * @ return 0 if success / return -1 if failure.
611 *****************************************************************************************/
[584]612int sys_place_fork( uint32_t cxy );
[457]613
614/******************************************************************************************
[407]615 * [45] This function block the calling thread on the THREAD_BLOCKED_GLOBAL condition,
616 * and deschedule.
617 ******************************************************************************************
618 * @ return 0 if success / returns -1 if failure.
619 *****************************************************************************************/
[479]620int sys_thread_sleep( void );
[407]621
622/******************************************************************************************
623 * [46] This function unblock the thread identified by its <trdid> from the
624 * THREAD_BLOCKED_GLOBAL condition.
625 ******************************************************************************************
626 * @ trdid  : target thread identifier.
627 * @ return 0 if success / return -1 if failure.
628 *****************************************************************************************/
[506]629int sys_thread_wakeup( trdid_t trdid );
[407]630
[421]631/******************************************************************************************
[443]632 * [47] This debug function is used to activate / desactivate the context switches trace
633 * for a core identified by the <cxy> and <lid> arguments.
[421]634 * It can be called by any other thread in the same process.
635 ******************************************************************************************
[443]636 * @ active     : activate trace if true / desactivate trace if false.
637 * @ cxy        : cluster identifier.
638 * @ lid        : core local index.
[421]639 * @ returns O if success / returns -1 if failure.
640 *****************************************************************************************/
[443]641int sys_trace( bool_t   active,
642               cxy_t    cxy, 
643               lid_t    lid );
[407]644
[421]645/******************************************************************************************
646 * [48] This function gives the process identified by the <pid> argument
647 * the exclusive ownership of its TXT_TX terminal (put it in foreground).
648 ******************************************************************************************
649 * @ pid    : process identifier.
650 * @ return 0 if success / return -1 if failure.
651 *****************************************************************************************/
652int sys_fg( pid_t   pid );
653
[445]654/******************************************************************************************
[457]655 * [49] This function returns a non-zero value in the <is_fg> buffer when the process
656 * identified by the <pid> argument is the current TXT owner.
[445]657 ******************************************************************************************
[457]658 * @ pid      : process identifier.
659 * @ is_fg    : pointer on buffer.
[445]660 * @ return 0 if success / return -1 if failure.
661 *****************************************************************************************/
[457]662int sys_is_fg( pid_t      pid,
663               uint32_t * is_fg );
[421]664
[610]665/******************************************************************************************
666 * [50] This function implements the exit system call terminating a POSIX process.
667 * It can be called by any thread running in any cluster.
668 * It uses both remote accesses to access the owner process descriptor, and the
669 * RPC_PROCESS_SIGACTION to delete remote process and thread descriptors.
670 * In the present implementation, this function implements actually the _exit():
671 * - it does not flush open output streams.
672 * - it does not close open streams.
673 ******************************************************************************************
674 * @ status   : terminaison status.
675 *****************************************************************************************/
676int sys_exit( uint32_t status );
677
[16]678#endif  // _SYSCALLS_H_
Note: See TracBrowser for help on using the repository browser.