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

Last change on this file since 437 was 437, checked in by alain, 6 years ago

Fix various bugs
File size: 36.5 KB
RevLine 
[1]1/*
[407]2 * syscalls.h - Kernel side services for syscall handling.
[1]3 *
[23]4 * Author     Alain Greiner (2016,2017)
[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
[23]27#include <hal_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 *****************************************************************************************/
60int sys_thread_yield();
[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 ******************************************************************************************
[23]66 * @ new_thread  : [out] local pointer on created thread descriptor.
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 *****************************************************************************************/
[23]72int sys_thread_create( struct thread_s        * new_thread,
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 ******************************************************************************************
[23]118 * @ vaddr     : semaphore virtual address in user space == identifier.
119 * @ operation : SEM_INIT / SEM_DESTROY / SEM_GETVALUE / SEM_POST / SEM_WAIT.
120 * @ value     : pointer on in/out argument in user space.
121 * @ return 0 if success / return -1 if failure.
[407]122 *****************************************************************************************/
[23]123int sys_sem( void       * vaddr,
124             uint32_t     operation,
125             uint32_t   * value );
[16]126
[407]127/******************************************************************************************
[23]128 * [7] This function implement all operations on a POSIX condition variable.
129 * The kernel structure representing a cond_var is defined in the remote_cv.h file,
130 * The code implementing the operations is defined in the remote_cv.c file.
[407]131 ******************************************************************************************
[23]132 * @ vaddr     : condvar virtual address in user space == identifier.
133 * @ operation : operation type (see below).
134 * @ attr      : mutex virtual address in user space == identifier.
135 * @ return 0 if success / return -1 if failure.
[407]136 *****************************************************************************************/
[23]137int sys_condvar( void     * condvar,
138                 uint32_t   operation,
139                 void     * mutex );
[16]140
[407]141/******************************************************************************************
[23]142 * [8] This function implement all operations on a POSIX barrier.
143 * The kernel structure representing a barrier is defined in the remote_barrier.h file.
144 * The code implementting the operations is defined in the remote_barrier.c file.
[407]145 ******************************************************************************************
[23]146 * @ vaddr     : barrier virtual address in user space == identifier.
147 * @ operation : BARRIER_INIT / BARRIER_DESTROY / BARRIER_WAIT.
148 * @ count     : number of expected threads (only used by BARRIER_INIT operation).
149 * @ return 0 if success / return -1 if failure.
[407]150 *****************************************************************************************/
[23]151int sys_barrier( void     * vaddr,
152                 uint32_t   operation,
153                 uint32_t   count );
[16]154
[407]155/******************************************************************************************
[23]156 * [9] This function implement all operations on a POSIX mutex.
157 * The kernel structure representing a barrier is defined in the remote_barrier.h file.
158 * The code implementting the operations is defined in the remote_barrier.c file.
[407]159 ******************************************************************************************
[23]160 * @ vaddr     : mutex virtual address in user space == identifier.
161 * @ operation : MUTEX_INIT / MUTEX_DESTROY / MUTEX_LOCK / MUTEX_UNLOCK
162 * @ attr      : mutex attributes (non supported yet => must be 0).
163 * @ return 0 if success / return -1 if failure.
[407]164 *****************************************************************************************/
[23]165int sys_mutex( void     * vaddr,
166               uint32_t   operation,
167               uint32_t   count );
[16]168
[407]169/******************************************************************************************
[408]170 * [10] This function implement the exit system call terminating a POSIX process.
[433]171 * In the present implementation, this function implements actually the _exit():
172 * - it does not flush open ourput steams.
173 * - it does not close open streams.
[407]174 ******************************************************************************************
[408]175 * @ status   : terminaison status (not used in present implementation).
[407]176 *****************************************************************************************/
[409]177int sys_exit( uint32_t status );
[16]178
[407]179/******************************************************************************************
[408]180 * [11] This function remove an existing mapping defined by the <addr> and <size>
[407]181 * arguments in user space.
182 ******************************************************************************************
183 * @ addr  : base address in user space.
184 * # size  : number of bytes.
[23]185 * @ return 0 if success / return -1 if failure.
[407]186 *****************************************************************************************/
187int sys_munmap( void     * addr,
188                uint32_t   size );
[16]189
[407]190/******************************************************************************************
191 * [12] This function open or create an open file descriptor.
192 ******************************************************************************************
[23]193 * @ pathname   : pathname (can be relative or absolute).
194 * @ flags      : bit vector attributes (see below).
195 * @ mode       : access rights.
196 * @ return file descriptor index in fd_array if success / return -1 if failure.
[407]197 *****************************************************************************************/
[23]198int sys_open( char    * pathname,
199              uint32_t  flags,
200              uint32_t  mode );
[16]201
[407]202/******************************************************************************************
203 * [13] This function map physical memory (or a file) in the calling thread virtual space.
204 * The <attr> argument is a pointer on a structure for arguments (see shared_syscalls.h).
205 ******************************************************************************************
206 * @ attr       : pointer on attributes structure.
207 * @ return 0 if success / return -1 if failure.
208 *****************************************************************************************/
209int sys_mmap( mmap_attr_t * attr );
[23]210
[407]211/******************************************************************************************
[23]212 * [14] This function read bytes from an open file identified by its file descriptor.
[407]213 * The file can be a regular file or character oriented device.
[408]214 * IRQs are enabled during this system call.
[407]215 ******************************************************************************************
[23]216 * @ file_id  : open file index in fd_array.
217 * @ buf      : buffer virtual address in user space.
218 * @ count    : number of bytes.
219 * @ return number of bytes actually read if success / returns -1 if failure.
[407]220 *****************************************************************************************/
[23]221int sys_read( uint32_t   file_id,
222              void     * buf,
223              uint32_t   count );
[16]224
[407]225/******************************************************************************************
[23]226 * [15] This function writes bytes to an open file identified by its file descriptor.
[407]227 * The file can be a regular file or character oriented device.
[408]228 * IRQs are enabled during this system call.
[407]229 ******************************************************************************************
[23]230 * @ file_id  : open file index in fd_array.
231 * @ buf      : buffer virtual address in user space.
232 * @ count    : number of bytes.
233 * @ return number of bytes actually written if success / returns -1 if failure.
[407]234 *****************************************************************************************/
[23]235int sys_write( uint32_t   file_id,
236               void     * buf,
237               uint32_t   count );
[16]238
[407]239/******************************************************************************************
240 * [16] This function repositions the offset of the file descriptor identified by <file_id>,
241 * according to the operation type defined by the <whence> argument.
242 ******************************************************************************************
[23]243 * @ file_id  : open file index in fd_array.
[407]244 * @ offset   : used to compute new offset value.
[23]245 * @ whence   : operation type (see below).
246 * @ return 0 if success / returns -1 if failure.
[407]247 *****************************************************************************************/
[23]248int sys_lseek( xptr_t    file_id,
249               uint32_t  offset,
250               uint32_t  whence );
[16]251
[407]252/******************************************************************************************
[23]253 * [17] This function release the memory allocated for the file descriptor identified by
254 * the <file_id> argument, and remove the fd array_entry in all copies of the process
255 * descriptor.
[407]256 ******************************************************************************************
[23]257  file_id   : file descriptor index in fd_array.
258 * @ return 0 if success / returns -1 if failure.
[407]259 *****************************************************************************************/
[23]260int sys_close( uint32_t file_id );
[16]261
[407]262/******************************************************************************************
263 * [18] This function removes a directory entry identified by the <pathname> from the
[23]264 * directory, and decrement the link count of the file referenced by the link.
265 * If the link count reduces to zero, and no process has the file open, then all resources
266 * associated with the file are reclaimed.  If one or more process have the file open when
267 * the last link is removed, the link is removed, but the removal of the file is delayed
268 * until all references to it have been closed.
[407]269 ******************************************************************************************
[23]270 * @ pathname   : pathname (can be relative or absolute).
271 * @ return 0 if success / returns -1 if failure.
[407]272 *****************************************************************************************/
[23]273int sys_unlink( char * pathname );
[16]274
[407]275/******************************************************************************************
[23]276 * [19] This function creates in the calling thread cluster an unnamed pipe, and two
277 * (read and write) file descriptors.
[407]278 * TODO not implemented yet...
279 ******************************************************************************************
[23]280 * @ file_id[0] : [out] read only file descriptor index.
281 * @ file_id[1] : [out] write only file descriptor index.
282 * @ return 0 if success / return -1 if failure.
[407]283 *****************************************************************************************/
[23]284int sys_pipe( uint32_t file_id[2] );
[16]285
[407]286/******************************************************************************************
[23]287 * [20] This function change the current working directory in reference process descriptor.
[407]288 ******************************************************************************************
[23]289 * @ pathname   : pathname (can be relative or absolute).
290 * @ return 0 if success / returns -1 if failure.
[407]291 *****************************************************************************************/
[23]292int sys_chdir( char * pathname );
[16]293
[407]294/******************************************************************************************
[23]295 * [21] This function creates a new directory in file system.
[407]296 ******************************************************************************************
[23]297 * @ pathname   : pathname (can be relative or absolute).
298 * @ mode       : access rights (as defined in chmod).
299 * @ return 0 if success / returns -1 if failure.
[407]300 *****************************************************************************************/
[279]301int sys_mkdir( char    * pathname,
[23]302               uint32_t  mode );
[16]303
[407]304/******************************************************************************************
[23]305 * [22] This function creates a named FIFO file in the calling thread cluster.
306 * The associated read and write file descriptors mut be be  explicitely created
[407]307 * using the sys_open() function.
308 ******************************************************************************************
[23]309 * @ pathname   : pathname (can be relative or absolute).
310 * @ mode       : access rights (as defined in chmod).
311 * @ return 0 if success / returns -1 if failure.
[407]312 *****************************************************************************************/
[23]313int sys_mkfifo( char     * pathname,
314                uint32_t   mode );
[16]315
[407]316/******************************************************************************************
317 * [23] This function open a directory, that must exist in the file system, returning
318 * a DIR pointer on the directory in user space.
319 ******************************************************************************************
[23]320 * @ pathname   : pathname (can be relative or absolute).
[407]321 * @ dirp       : [out] buffer for pointer on user directory (DIR).
[23]322 * @ return 0 if success / returns -1 if failure.
[407]323 *****************************************************************************************/
324int sys_opendir( char * pathname,
325                 DIR ** dirp );
[16]326
[407]327/******************************************************************************************
328 * [24] This function returns an user pointer on the dirent structure describing the
329 * next directory entry in the directory identified by the <dirp> argument.
330 ******************************************************************************************
331 * @ dirp     : user pointer identifying the searched directory.
332 * @ dentp    : [out] buffer for pointer on user direntory entry (dirent).
333 * @ return O if success / returns -1 if failure.
334 *****************************************************************************************/
335int sys_readdir( DIR            * dirp,
336                 struct dirent ** dentp );
337
338/******************************************************************************************
339 * [25] This function closes the directory identified by the <dirp> argument, and releases
340 * all structures associated with the <dirp> pointer.
341 ******************************************************************************************
342 * @ dirp     : user pointer identifying the directory.
[23]343 * @ return 0 if success / returns -1 if failure.
[407]344 *****************************************************************************************/
345int sys_closedir( DIR * dirp );
[16]346
[407]347/******************************************************************************************
[23]348 * [26] This function returns the pathname of the current working directory.
[407]349 ******************************************************************************************
[23]350 * buf     : buffer addres in user space.
351 * nbytes  : user buffer size in bytes.
352 * @ return 0 if success / returns -1 if failure.
[407]353 *****************************************************************************************/
[23]354int sys_getcwd( char     * buf,
355                uint32_t   nbytes );
[16]356
[407]357/******************************************************************************************
[437]358 * [27] This function tests whether a given file descriptor dentified by the <file_id>
359 * argument is an open file descriptor referring to a terminal.
360 ******************************************************************************************
361 * @ file_id   : file descriptor index
362 * @ return 1 if it is a TXT device / return 0 if it is not a TXT device.
[407]363 *****************************************************************************************/
[437]364int sys_isatty( uint32_t file_id );
[16]365
[407]366/******************************************************************************************
[23]367 * [28] This function forces the calling thread to sleep, for a fixed number of cycles.
[407]368 ******************************************************************************************
[23]369 * cycles   : number of cycles.
[407]370 *****************************************************************************************/
[23]371int sys_alarm( uint32_t cycles );
[16]372
[407]373/******************************************************************************************
374 * [29] This function removes a directory file whose name is given by <pathname>.
375 * The directory must not have any entries other than `.' and `..'.
376 ******************************************************************************************
[23]377 * @ pathname   : pathname (can be relative or absolute).
378 * @ return 0 if success / returns -1 if failure.
[407]379 *****************************************************************************************/
[23]380int sys_rmdir( char * pathname ); 
[16]381
[407]382/******************************************************************************************
[23]383 * [30] This function implement the operations related to User Thread Local Storage.
384 * It is actually implemented as an uint32_t variable in the thread descriptor.
[407]385 ******************************************************************************************
[23]386 * @ operation  : UTLS operation type as defined below.
387 * @ value      : argument value for the UTLS_SET operation.
388 * @ return value for the UTLS_GET and UTLS_GET_ERRNO / return -1 if failure.
[407]389 *****************************************************************************************/
[23]390int sys_utls( uint32_t operation,
391              uint32_t value );
[16]392
[407]393/******************************************************************************************
[23]394 * [31] This function change the acces rights for the file/dir identified by the
395 * pathname argument.
[407]396 ******************************************************************************************
[23]397 * @ pathname   : pathname (can be relative or absolute).
398 * @ rights     : acces rights.
399 * @ return 0 if success / returns -1 if failure.
[407]400 *****************************************************************************************/
[23]401int sys_chmod( char     * pathname,
402               uint32_t   rights );
[16]403
[407]404/******************************************************************************************
[23]405 * [32] This function associate a specific signal handler to a given signal type.
406 * Tee handlers for the SIGKILL and SIGSTOP signals cannot be redefined.
[407]407 ******************************************************************************************
[23]408 * @ sig_id    : index defining signal type (from 1 to 31).
409 * @ handler   : pointer on fonction implementing the specific handler.
410 * @ return 0 if success / returns -1 if failure.
[407]411 *****************************************************************************************/
[23]412int sys_signal( uint32_t   sig_id,
413                void     * handler );
[16]414
[407]415/******************************************************************************************
[23]416 * [33] This function returns in the structure <tv>, defined in the time.h file,
417 * the current time (in seconds & micro-seconds).
418 * It is computed from the calling core descriptor.
419 * The timezone is not supported.
[407]420 ******************************************************************************************
[23]421 * @ tv      : pointer on the timeval structure.
422 * @ tz      : pointer on the timezone structure : must be NULL.       
423 * @ return 0 if success / returns -1 if failure.
[407]424 *****************************************************************************************/
[50]425int sys_timeofday( struct timeval  * tv,
426                   struct timezone * tz );
[16]427
[407]428/******************************************************************************************
[433]429 * [34] This function implements the "kill" system call on the kernel side.
[23]430 * It register the signal defined by the <sig_id> argument in all thread descriptors
431 * of a target process identified by the <pid> argument. This is done in all clusters
432 * containing threads for the target process.
433 * It can be executed by any thread running in any cluster, as this function uses
[407]434 * remote access to traverse the list of process copies stored in the owner cluster,
[23]435 * and the RPC_SIGNAL_RISE to signal the remote threads.
[421]436 * This function does nothing for (sig_id == 0). This can be used to check process pid.
437 * TODO : This first implementation supports only SIGKILL / SIGSTOP / SIGCONT values.
[407]438 ******************************************************************************************
[16]439 * @ pid      : target process identifier.
[433]440 * @ sig_id   : index defining the signal type.
[23]441 * @ return 0 if success / returns -1 if failure.
[407]442 *****************************************************************************************/
[16]443int sys_kill( pid_t    pid,
[23]444              uint32_t sig_id );
[16]445
[407]446/******************************************************************************************
[433]447 * [35] This function implements the "getpid" system call on the kernel side.
[407]448 ******************************************************************************************
449 * @ returns the process PID for the calling thread.
450 *****************************************************************************************/
[1]451int sys_getpid();
452
[407]453/******************************************************************************************
[433]454 * [36] This function implement the "fork" system call on the kernel side.
455 * The calling process descriptor (parent process), and the associated thread descriptor
456 * are replicated in a - likely - remote cluster, that becomes the child process owner.
457 * The child process get a new PID, and is linked to the parent PID. The child process
458 * inherit from its parent the memory image, and all open files (including the TXT).
459 * The child process becomes the TXT terminal owner.
[1]460 * The target cluster depends on the "fork_user" flag and "fork_cxy" variable that can be
461 * stored in the calling thread descriptor by the specific fork_place() system call.
[433]462 * If not, the kernel function makes a query to the DQDT to select the target cluster.
[407]463 ******************************************************************************************
464 * @ if success, returns child process PID to parent, and return O to child.
465 * @ if failure, returns -1 to parent / no child process is created.
466 *****************************************************************************************/
[1]467int sys_fork();
468
[407]469/******************************************************************************************
[433]470 * [37] This function implement the "exec" system call on the kernel side.
471 * It creates, in the same cluster as the calling thread, a new process descriptor,
472 * and a new associated main thread descriptor, executing a new memory image defined
473 * by the <filename> argument. This new process inherit from the old process the PID
474 * and the PPID, as well as all open files (including the TXT).
475 * The old process descriptor, and all its threads are blocked, and marked for deletion.
476 * Therefore the exec syscall does not return to the calling thread in case of success.
477 * This function build an exec_info_t structure containing the new process arguments,
478 * as defined by the <arv> argument, and the new process environment variables,
479 * as defined by the <envp>  argument.
480 * TODO : the <argv> and <envp> arguments are not supported yet (both must be NULL).
[407]481 ******************************************************************************************
482 * @ filename : string pointer on .elf filename (pointer in user space)
483 * @ argv     : array of strings on process arguments (pointers in user space)
484 * @ envp     : array of strings on environment variables (pointers in user space)
[433]485 * @ does not return if success / returns -1 if failure.
[407]486 *****************************************************************************************/
[1]487int sys_exec( char  * filename,
488              char ** argv,
489              char ** envp );
490
[407]491/******************************************************************************************
492 * [38] This function  returns in the <stat> structure, defined in the "shared_syscalls.h"
493 * file, various informations on the file/directory identified by the <pathname> argument.
494 ******************************************************************************************
495 * @ pathname  : user pointer on file pathname.
496 * @ stat      : user pointer on the stat structure.
[23]497 * @ returns O if success / returns -1 if failure.
[407]498 *****************************************************************************************/
499int sys_stat( const char  * pathname,
500              struct stat * stat );
[1]501
[407]502/******************************************************************************************
[433]503 * [39] This blocking function waits a change of a child process state, that can be:
504 * - a termination of child following a process_make_exit().
505 * - a termination of child following a process_make_kill().
[421]506 * - a blocking of child following a SIGSTOP signal.
[433]507 * In case of a multi-thread process, this function must be called by the main thread
508 * runningin the reference cluster.
509 * When a change has been observed, it returns the PID of the child process, and stores
510 * in the <status> argument relevant information on the child state change.
[421]511 * The following macros can be used to extract information from status:
512 * - WIFEXITED(status)   : is true if the child process terminated with an exit().
[435]513 * - WIFSIGNALED(status) : is true if the child process killed by a signal.
[421]514 * - WIFSTOPPED(status)  : is true if the child process is stopped by a signal.
515 * - WEXITSTATUS(status) : returns the low-order 8 bits of the exit() argument.
516 * If a parent process terminates without waiting for all child processes to terminate,
517 * the remaining child processes are attached to the init process.
[433]518 * WARNING: negative values for the <pid> argument are not supported.
[421]519 ******************************************************************************************
[433]520 * @ searched_pid : searched child process identifier.
521 * @ status       : [out] child termination status.
522 * @ return child PID if success / return -1 if searched PID not found.
[407]523 *****************************************************************************************/
[421]524int sys_wait( uint32_t * status );
[1]525
[407]526/******************************************************************************************
527 * [40] This function returns the hardware platform parameters.
528 ******************************************************************************************
529 * @ x_size   : [out] number of clusters in a row.
530 * @ y_size   : [out] number of clusters in a column.
[421]531 * @ y_width  : [out] number of bits in Y field for CXY.
[407]532 * @ ncores   : [out] number of cores per cluster.
533 * @ return 0 if success / return -1 if illegal arguments
534 *****************************************************************************************/
535int sys_get_config( uint32_t * x_size,
536                    uint32_t * y_size,
[421]537                    uint32_t * y_width,
[407]538                    uint32_t * ncores );
[1]539
[407]540/******************************************************************************************
541 * [41] This function returns the calling core cluster and local index.
542 ******************************************************************************************
543 * @ cxy      : [out] cluster identifier (fixed format)
544 * @ lid      : [out] core local index in cluster.
545 * @ return 0 if success / return -1 if illegal arguments
546 *****************************************************************************************/
547int sys_get_core( uint32_t * cxy,
548                  uint32_t * lid );
[1]549
[407]550/******************************************************************************************
551 * [42] This function returns in a 64 bits user buffer the calling core cycles count.
552 * It uses both the hardware register and the core descriptor cycles count to take
553 * into account a possible harware register overflow  in 32 bits architectures.
554 ******************************************************************************************
555 * cycle    : [out] address of buffer in user space.
556 * @ return 0 if success / return -1 if illegal arguments
557 *****************************************************************************************/
558int sys_get_cycle( uint64_t * cycle );
559
560/******************************************************************************************
[421]561 * [43] This debug function displays on the kernel terminal TXT0 an user defined string,
562 * or the current state of a kernel structure, identified by the <type> argument.
[435]563 * The <arg0> and <arg1> arguments depends on the structure type:
564 * - DISPLAY_STRING          : an user defined string
565 * - DISPLAY_VMM             : VSL and GPT for a process identified by <pid>.
566 * - DISPLAY_SCHED           : all threads allocated to a scheduler <cxy> & <lid>.
567 * - DISPLAY_CLUSTER_PROCESS : all processes registered in a cluster identified by <cxy>. 
568 * - DISPLAY_TXT_PROCESS     : all processes registered in a cluster identified by <cxy>. 
569 * - DISPLAY_VFS             : all files registered in the VFS cache.
570 * - DISPLAY_CHDEV           : all registered channel devices.
[407]571 ******************************************************************************************
[435]572 * type      : [in] type of display
[421]573 * arg0      : [in] type dependant argument.
574 * arg1      : [in] type dependant argument.
[407]575 * @ return 0 if success / return -1 if illegal arguments
576 *****************************************************************************************/
[421]577int sys_display( reg_t  type,
578                 reg_t  arg0,
579                 reg_t  arg1 );
[407]580
581/******************************************************************************************
582 * [45] This function block the calling thread on the THREAD_BLOCKED_GLOBAL condition,
583 * and deschedule.
584 ******************************************************************************************
585 * @ return 0 if success / returns -1 if failure.
586 *****************************************************************************************/
587int sys_thread_sleep();
588
589/******************************************************************************************
590 * [46] This function unblock the thread identified by its <trdid> from the
591 * THREAD_BLOCKED_GLOBAL condition.
592 ******************************************************************************************
593 * @ trdid  : target thread identifier.
594 * @ return 0 if success / return -1 if failure.
595 *****************************************************************************************/
596int sys_thread_wakeup();
597
[421]598/******************************************************************************************
599 * [47] This non-standard function is used to activate / desactivate the trace for a thread
600 * identified by the <trdid> and <pid> arguments.
601 * It can be called by any other thread in the same process.
602 ******************************************************************************************
603 * @ operation  : operation type as defined below.
604 * @ pid        : process identifier.
605 * @ trdid      : thread identifier.
606 * @ returns O if success / returns -1 if failure.
607 *****************************************************************************************/
608int sys_trace( uint32_t operation,
609               pid_t    pid, 
610               uint32_t trdid );
[407]611
[421]612/******************************************************************************************
613 * [48] This function gives the process identified by the <pid> argument
614 * the exclusive ownership of its TXT_TX terminal (put it in foreground).
615 ******************************************************************************************
616 * @ pid    : process identifier.
617 * @ return 0 if success / return -1 if failure.
618 *****************************************************************************************/
619int sys_fg( pid_t   pid );
620
621
[16]622#endif  // _SYSCALLS_H_
Note: See TracBrowser for help on using the repository browser.