source: trunk/libs/mini-libc/unistd.h @ 677

Last change on this file since 677 was 677, checked in by alain, 3 years ago

Introduce the fgetc() and fputc() functions.

File size: 13.3 KB
RevLine 
[449]1/*
2 * unistd.h - User level <unistd> library definition.
3 *
4 * Author     Alain Greiner (2016,2017,2018)
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 _UNISTD_H_
25#define _UNISTD_H_
26
27/*****************************************************************************************
[589]28 * This file defines the user level <unistd> library.
[449]29 * All these functions make a system call to access the kernel structures.
30 * The user/kernel shared structures and mnemonics are defined in
31 * the <syscalls/shared_include/shared_unistd.h> file.
32 ****************************************************************************************/
33
34#include <shared_unistd.h>
35
36/*****************************************************************************************
[677]37 * This function implements the <alarm> system call.
38 * It sets a timer to deliver the signal SIGALRM to the calling process,
[589]39 * after the specified number of seconds.
40 * If an alarm has already been set with alarm() but has not been delivered,
41 * another call to alarm() will supersede the prior call.
42 * The request alarm(0) cancels the current alarm and the signal will not be delivered.
43 *****************************************************************************************
44 * @ seconds   : number of seconds.
45 * @ returns the amount of time left on the timer from a previous call to alarm().
46 *   If no alarm is currently set, the return value is 0.
47 ****************************************************************************************/
48unsigned alarm( unsigned seconds );
49
50/*****************************************************************************************
[677]51 * This function implements the <chdir> system call.
[626]52 * It changes the current working directory in the reference process descriptor.
[589]53 *****************************************************************************************
54 * @ pathname   : pathname (can be relative or absolute).
55 * @ return 0 if success / returns -1 if failure.
56 ****************************************************************************************/
57int chdir( const char * pathname );
58
59/*****************************************************************************************
[677]60 * This function implements the <close> system call.
[626]61 * It releases the memory allocated for the file identified by the <fd> argument,
62 * and remove the fd array_entry in all process descriptor copies.
[589]63 *****************************************************************************************
64 * @ fd   : file descriptor index in fd_array.
65 * @ return 0 if success / returns -1 if failure.
66 ****************************************************************************************/
67int close( int fd );
68
69/*****************************************************************************************
[677]70 * This function implement the <exec> system call.
[589]71 * It creates, in the same cluster as the calling thread, a new process descriptor,
72 * and a new associated main thread descriptor, executing a new memory image defined
73 * by the <filename> argument. This new process inherit from the old process the PID
74 * and the PPID, as well as all open files (including the TXT).
75 * The old process descriptor, and all its threads are blocked, and marked for deletion.
76 * Therefore the exec syscall does not return to the calling thread in case of success.
77 * This function build an exec_info_t structure containing the new process arguments,
78 * as defined by the <arv> argument, and the new process environment variables,
79 * as defined by the <envp>  argument.
[677]80 * TODO : the <envs> argument is not supported yet (must be NULL).
[589]81 *****************************************************************************************
82 * @ filename : string pointer on .elf filename (virtual pointer in user space)
[677]83 * @ args     : array of pointers on process arguments (strings in user space)
84 * @ envs     : array of pointers on environment variables (strings in user space)
[589]85 * @ does not return if success / returns -1 if failure.
86 ****************************************************************************************/
87int execve( char  * filename,
[677]88            char ** args,
89            char ** envs );
[589]90
91/*****************************************************************************************
[677]92 * This function implement the <fork> system call.
[589]93 * The calling process descriptor (parent process), and the associated thread descriptor
94 * are replicated in a - likely - remote cluster, that becomes the new process owner.
95 * The child process get a new PID is linked to the parent PID. The child process inherit
96 * from the parent process the memory image, and all open files (including the TXT).
97 * The child process becomes the TXT terminal owner.
98 * The target cluster depends on the "fork_user" flag and "fork_cxy" variable that can be
99 * stored in the calling thread descriptor by the specific fork_place() system call.
100 * If not, the kernel function makes a query to the DQDT to select the target cluster.
101 *****************************************************************************************
102 * @ if success, returns child process PID to parent, and return O to child.
103 * @ if failure, returns -1 to parent / no child process is created.
104 ****************************************************************************************/
105int fork( void );
106
107/*****************************************************************************************
[677]108 * This function implements the <fsync> system call.
[626]109 * It causes all the modified data and attributes of file identified by the <fd> argument
110 * to be copied from the file mapper and file descriptor to the IOC device.
[449]111 *****************************************************************************************
[626]112 * @ fd   : file descriptor index in fd_array.
113 * @ return 0 if success / returns -1 if failure.
114 ****************************************************************************************/
115int fsync( int fd );
116
117/*****************************************************************************************
[677]118 * This function implements the <getcwd> system call.
[626]119 * It returns the pathname of the current working directory.
120 *****************************************************************************************
[449]121 * buf     : buffer addres in user space.
122 * nbytes  : user buffer size in bytes.
123 * @ return 0 if success / returns -1 if failure.
124 ****************************************************************************************/
125int getcwd( char       * buf,
126            unsigned int nbytes );
127
128/*****************************************************************************************
[677]129 * This function implements the <getpid> system call.
[626]130 * It returns the process identifier.
[589]131 *****************************************************************************************
132 * @ returns the process PID for the calling thread process.
[449]133 ****************************************************************************************/
[589]134int getpid( void );
[449]135
136/*****************************************************************************************
[677]137 * This function implements the <isatty> system call.
[626]138 * It test whether a file descriptor refers to a terminal.
[589]139 *****************************************************************************************
140 * @ fd   : file descriptor index in fd_array.
141 * @ returns 1 if fd is an open file descriptor referring to a terminal / 0 otherwise.
[449]142 ****************************************************************************************/
[589]143int isatty( int fd );
[449]144
145/*****************************************************************************************
[677]146 * This function implements the <lseek> system call.
[626]147 * It repositions the offset of the file descriptor identified by <fd>,
[449]148 * according to the operation type defined by the <whence> argument.
149 *****************************************************************************************
150 * @ fd       : open file index in fd_array.
151 * @ offset   : used to compute new offset value.
[589]152 * @ whence   : operation type (SEEK_SET / SEEK_CUR / SEEK_END)
[650]153 * @ return new offset value if success / returns -1 if failure.
[449]154 ****************************************************************************************/
155int lseek( int           fd,
156           unsigned int  offset,
157           int           whence );
158
159/*****************************************************************************************
[677]160 * This function implements the <pause> system call.
[626]161 * It stops the calling process until a signal is received.
[449]162 *****************************************************************************************
163 * @ return 0 if success / returns -1 if failure.
164 ****************************************************************************************/
[589]165int pause( void );
[449]166
167/*****************************************************************************************
[677]168 * This function implements the <pipe> system call.
[626]169 * It creates in the calling thread cluster an unnamed pipe, and two (read and write)
170 * file descriptors to access this pipe. The argument is a pointer a fd[] array.
[449]171 *****************************************************************************************
[677]172 * @ fd[0] : [out] buffer for read only file descriptor index.
173 * @ fd[1] : [out] buffer for write only file descriptor index.
[449]174 * @ return 0 if success / return -1 if failure.
175 ****************************************************************************************/
176int pipe( int fd[2] );
177
178/*****************************************************************************************
[677]179 * This function implements the <read> system call.
[626]180 * It reads bytes from an open file identified by the <fd> file descriptor.
[589]181 * This file can be a regular file or a character oriented device.
[449]182 *****************************************************************************************
[677]183 * @ fd       : file index in fd_array.
[589]184 * @ buf      : buffer virtual address in user space.
185 * @ count    : number of bytes.
186 * @ return number of bytes actually read if success / returns -1 if failure.
[449]187 ****************************************************************************************/
[589]188int read( int            fd,
189          void         * buf,
190          unsigned int   count );
[449]191
192/*****************************************************************************************
[677]193 * This function implements the <rmdir> system call.
[626]194 * It removes a directory file whose name is given by <pathname>.
195 * The directory must not contain any entries other than `.' and `..'.
[449]196 *****************************************************************************************
197 * @ pathname   : pathname (can be relative or absolute).
198 * @ return 0 if success / returns -1 if failure.
199 ****************************************************************************************/
200int rmdir( char * pathname ); 
201
202/*****************************************************************************************
[677]203 * This function implements the <sync> system call.
[626]204 * It forces all kernel mappers (file caches) to be copied to the IOC device.
205 ****************************************************************************************/
206void sync( void );
207
208/*****************************************************************************************
[677]209 * This function implements the <unlink> system call.
[626]210 * It removes a directory entry identified by the <pathname> from the parent directory,
211 * and decrement the link count of the file referenced by the link.
[589]212 * If the link count reduces to zero, and no process has the file open, then all resources
213 * associated with the file are released.  If one or more process have the file open when
214 * the last link is removed, the link is removed, but the removal of the file is delayed
215 * until all references to it have been closed.
216 *****************************************************************************************
217 * @ pathname   : pathname (can be relative or absolute).
218 * @ return 0 if success / returns -1 if failure.
[449]219 ****************************************************************************************/
[589]220int unlink( const char * pathname );
[449]221
222/*****************************************************************************************
[677]223 * This function implements the <write> system call.
[626]224 * It writes bytes to an open file identified by the <fd> file descriptor.
[589]225 * This file can be a regular file or character oriented device.
226 *****************************************************************************************
[677]227 * @ fd       : file index in fd_array.
[589]228 * @ buf      : buffer virtual address in user space.
229 * @ count    : number of bytes.
230 * @ return number of bytes actually written if success / returns -1 if failure.
[449]231 ****************************************************************************************/
[589]232int write( int            fd,
233           const void   * buf,
234           unsigned int   count );
[449]235
236#endif
Note: See TracBrowser for help on using the repository browser.