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

Last change on this file since 423 was 421, checked in by alain, 7 years ago

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