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

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

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