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