2001-08-21 Roland McGrath <roland@frob.com>
[platform/upstream/glibc.git] / hurd / hurd.h
1 /* Copyright (C) 1993,94,95,96,97,98,99,2001 Free Software Foundation, Inc.
2    This file is part of the GNU C Library.
3
4    The GNU C Library is free software; you can redistribute it and/or
5    modify it under the terms of the GNU Lesser General Public
6    License as published by the Free Software Foundation; either
7    version 2.1 of the License, or (at your option) any later version.
8
9    The GNU C Library is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12    Lesser General Public License for more details.
13
14    You should have received a copy of the GNU Lesser General Public
15    License along with the GNU C Library; if not, write to the Free
16    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
17    02111-1307 USA.  */
18
19 #ifndef _HURD_H
20
21 #define _HURD_H 1
22 #include <features.h>
23
24
25 /* Get types, macros, constants and function declarations
26    for all Mach microkernel interaction.  */
27 #include <mach.h>
28 #include <mach/mig_errors.h>
29
30 /* Get types and constants necessary for Hurd interfaces.  */
31 #include <hurd/hurd_types.h>
32
33 /* Get MiG stub declarations for commonly used Hurd interfaces.  */
34 #include <hurd/auth.h>
35 #include <hurd/process.h>
36 #include <hurd/fs.h>
37 #include <hurd/io.h>
38
39 /* Get `struct hurd_port' and related definitions implementing lightweight
40    user references for ports.  These are used pervasively throughout the C
41    library; this is here to avoid putting it in nearly every source file.  */
42 #include <hurd/port.h>
43
44 #include <errno.h>
45
46 #ifndef _HURD_H_EXTERN_INLINE
47 #define _HURD_H_EXTERN_INLINE extern __inline
48 #endif
49
50 _HURD_H_EXTERN_INLINE int
51 __hurd_fail (error_t err)
52 {
53   switch (err)
54     {
55     case EMACH_SEND_INVALID_DEST:
56     case EMIG_SERVER_DIED:
57       /* The server has disappeared!  */
58       err = EIEIO;
59       break;
60
61     case KERN_NO_SPACE:
62       err = ENOMEM;
63       break;
64     case KERN_INVALID_ARGUMENT:
65       err = EINVAL;
66       break;
67
68     case 0:
69       return 0;
70     default:
71     }
72
73   errno = err;
74   return -1;
75 }
76 \f
77 /* Basic ports and info, initialized by startup.  */
78
79 extern int _hurd_exec_flags;    /* Flags word passed in exec_startup.  */
80 extern struct hurd_port *_hurd_ports;
81 extern unsigned int _hurd_nports;
82 extern volatile mode_t _hurd_umask;
83 extern sigset_t _hurdsig_traced;
84
85 /* Shorthand macro for internal library code referencing _hurd_ports (see
86    <hurd/port.h>).  */
87
88 #define __USEPORT(which, expr) \
89   HURD_PORT_USE (&_hurd_ports[INIT_PORT_##which], (expr))
90
91 /* Function version of __USEPORT: calls OPERATE with a send right.  */
92
93 extern error_t _hurd_ports_use (int which, error_t (*operate) (mach_port_t));
94
95
96 /* Base address and size of the initial stack set up by the exec server.
97    If using cthreads, this stack is deallocated in startup.
98    Not locked.  */
99
100 extern vm_address_t _hurd_stack_base;
101 extern vm_size_t _hurd_stack_size;
102
103 /* Initial file descriptor table we were passed at startup.  If we are
104    using a real dtable, these are turned into that and then cleared at
105    startup.  If not, these are never changed after startup.  Not locked.  */
106
107 extern mach_port_t *_hurd_init_dtable;
108 extern mach_msg_type_number_t _hurd_init_dtablesize;
109 \f
110 /* Current process IDs.  */
111
112 extern pid_t _hurd_pid, _hurd_ppid, _hurd_pgrp;
113 extern int _hurd_orphaned;
114
115 /* This variable is incremented every time the process IDs change.  */
116 extern unsigned int _hurd_pids_changed_stamp;
117
118 /* This condition is broadcast every time the process IDs change.  */
119 extern struct condition _hurd_pids_changed_sync;
120 \f
121 /* Unix `data break', for brk and sbrk.
122    If brk and sbrk are not used, this info will not be initialized or used.  */
123
124
125 /* Data break.  This is what `sbrk (0)' returns.  */
126
127 extern vm_address_t _hurd_brk;
128
129 /* End of allocated space.  This is generally `round_page (_hurd_brk)'.  */
130
131 extern vm_address_t _hurd_data_end;
132
133 /* This mutex locks _hurd_brk and _hurd_data_end.  */
134
135 extern struct mutex _hurd_brk_lock;
136
137 /* Set the data break to NEWBRK; _hurd_brk_lock must
138    be held, and is released on return.  */
139
140 extern int _hurd_set_brk (vm_address_t newbrk);
141 \f
142 #define __need_FILE
143 #include <stdio.h>
144
145 /* Calls to get and set basic ports.  */
146
147 extern error_t _hurd_ports_get (unsigned int which, mach_port_t *result);
148 extern error_t _hurd_ports_set (unsigned int which, mach_port_t newport);
149
150 extern process_t getproc (void);
151 extern file_t getcwdir (void), getcrdir (void);
152 extern auth_t getauth (void);
153 extern mach_port_t getcttyid (void);
154 extern int setproc (process_t);
155 extern int setcwdir (file_t), setcrdir (file_t);
156 extern int setcttyid (mach_port_t);
157
158 /* Does reauth with the proc server and fd io servers.  */
159 extern int __setauth (auth_t), setauth (auth_t);
160
161
162 /* Modify a port cell by looking up a directory name.
163    This verifies that it is a directory and that we have search permission.  */
164 extern int _hurd_change_directory_port_from_name (struct hurd_port *portcell,
165                                                   const char *name);
166 /* Same thing, but using an open file descriptor.
167    Also verifies that it is a directory and that we have search permission.  */
168 extern int _hurd_change_directory_port_from_fd (struct hurd_port *portcell,
169                                                 int fd);
170
171
172
173 /* Get and set the effective UID set.  */
174 extern int geteuids (int __n, uid_t *__uidset);
175 extern int seteuids (int __n, const uid_t *__uidset);
176
177
178 /* Split FILE into a directory and a name within the directory.  The
179    directory lookup uses the current root and working directory.  If
180    successful, stores in *NAME a pointer into FILE where the name
181    within directory begins and returns a port to the directory;
182    otherwise sets `errno' and returns MACH_PORT_NULL.  */
183
184 extern file_t __file_name_split (const char *file, char **name);
185 extern file_t file_name_split (const char *file, char **name);
186
187 /* Split DIRECTORY into a parent directory and a name within the directory.
188    This is the same as file_name_split, but ignores trailing slashes.  */
189
190 extern file_t __directory_name_split (const char *file, char **name);
191 extern file_t directory_name_split (const char *file, char **name);
192
193 /* Open a port to FILE with the given FLAGS and MODE (see <fcntl.h>).
194    The file lookup uses the current root and working directory.
195    Returns a port to the file if successful; otherwise sets `errno'
196    and returns MACH_PORT_NULL.  */
197
198 extern file_t __file_name_lookup (const char *file, int flags, mode_t mode);
199 extern file_t file_name_lookup (const char *file, int flags, mode_t mode);
200
201 /* Open a port to FILE with the given FLAGS and MODE (see <fcntl.h>).  The
202    file lookup uses the current root directory, but uses STARTDIR as the
203    "working directory" for file relative names.  Returns a port to the file
204    if successful; otherwise sets `errno' and returns MACH_PORT_NULL.  */
205
206 extern file_t __file_name_lookup_under (file_t startdir, const char *file,
207                                         int flags, mode_t mode);
208 extern file_t file_name_lookup_under (file_t startdir, const char *file,
209                                       int flags, mode_t mode);
210
211
212 /* Lookup FILE_NAME and return the node opened with FLAGS & MODE
213    (see hurd_file_name_lookup for details), but a simple file name (without
214    any directory prefixes) will be consecutively prefixed with the pathnames
215    in the `:' separated list PATH until one succeeds in a successful lookup.
216    If none succeed, then the first error that wasn't ENOENT is returned, or
217    ENOENT if no other errors were returned.  If PREFIXED_NAME is non-NULL,
218    then if the result is looked up directly, *PREFIXED_NAME is set to NULL, and
219    if it is looked up using a prefix from PATH, *PREFIXED_NAME is set to
220    malloc'd storage containing the prefixed name.  */
221 extern file_t file_name_path_lookup (const char *file_name, const char *path,
222                                      int flags, mode_t mode,
223                                      char **prefixed_name);
224
225
226
227 /* Open a file descriptor on a port.  FLAGS are as for `open'; flags
228    affected by io_set_openmodes are not changed by this.  If successful,
229    this consumes a user reference for PORT (which will be deallocated on
230    close).  */
231
232 extern int openport (io_t port, int flags);
233
234 /* Open a stream on a port.  MODE is as for `fopen'.
235    If successful, this consumes a user reference for PORT
236    (which will be deallocated on fclose).  */
237
238 extern FILE *fopenport (io_t port, const char *mode);
239 extern FILE *__fopenport (io_t port, const char *mode);
240
241
242 /* Execute a file, replacing TASK's current program image.  */
243
244 extern error_t _hurd_exec (task_t task,
245                            file_t file,
246                            char *const argv[],
247                            char *const envp[]);
248
249
250 /* Inform the proc server we have exited with STATUS, and kill the
251    task thoroughly.  This function never returns, no matter what.  */
252
253 extern void _hurd_exit (int status) __attribute__ ((noreturn));
254
255
256 /* Initialize the library data structures from the
257    ints and ports passed to us by the exec server.
258    Then vm_deallocate PORTARRAY and INTARRAY.  */
259
260 extern void _hurd_init (int flags, char **argv,
261                         mach_port_t *portarray, size_t portarraysize,
262                         int *intarray, size_t intarraysize);
263
264 /* Do startup handshaking with the proc server, and initialize library data
265    structures that require proc server interaction.  This includes
266    initializing signals; see _hurdsig_init in <hurd/signal.h>.  */
267
268 extern void _hurd_proc_init (char **argv,
269                              const int *intarray, size_t intarraysize);
270
271
272 /* Return the socket server for sockaddr domain DOMAIN.  If DEAD is
273    nonzero, remove the old cached port and always do a fresh lookup.
274
275    It is assumed that a socket server will stay alive during a complex socket
276    operation involving several RPCs.  But a socket server may die during
277    long idle periods between socket operations.  Callers should first pass
278    zero for DEAD; if the first socket RPC tried on the returned port fails
279    with MACH_SEND_INVALID_DEST or MIG_SERVER_DIED (indicating the server
280    went away), the caller should call _hurd_socket_server again with DEAD
281    nonzero and retry the RPC on the new socket server port.  */
282
283 extern socket_t _hurd_socket_server (int domain, int dead);
284
285 /* Send a `sig_post' RPC to process number PID.  If PID is zero,
286    send the message to all processes in the current process's process group.
287    If PID is < -1, send SIG to all processes in process group - PID.
288    SIG and REFPORT are passed along in the request message.  */
289
290 extern error_t _hurd_sig_post (pid_t pid, int sig, mach_port_t refport);
291 extern error_t hurd_sig_post (pid_t pid, int sig, mach_port_t refport);
292
293 /* Fetch the host privileged port and device master port from the proc
294    server.  They are fetched only once and then cached in the
295    variables below.  A special program that gets them from somewhere
296    other than the proc server (such as a bootstrap filesystem) can set
297    these variables to install the ports.  */
298
299 extern kern_return_t __get_privileged_ports (host_priv_t *host_priv_ptr,
300                                              device_t *device_master_ptr);
301 extern kern_return_t get_privileged_ports (host_priv_t *host_priv_ptr,
302                                            device_t *device_master_ptr);
303 extern mach_port_t _hurd_host_priv, _hurd_device_master;
304
305 /* Return the PID of the task whose control port is TASK.
306    On error, sets `errno' and returns -1.  */
307
308 extern pid_t __task2pid (task_t task), task2pid (task_t task);
309
310 /* Return the task control port of process PID.
311    On error, sets `errno' and returns MACH_PORT_NULL.  */
312
313 extern task_t __pid2task (pid_t pid), pid2task (pid_t pid);
314
315 /* Return the current thread's thread port.  This is a cheap operation (no
316    system call), but it relies on Hurd signal state being set up.  */
317 extern thread_t hurd_thread_self (void);
318
319
320 /* Cancel pending operations on THREAD.  If it is doing an interruptible RPC,
321    that RPC will now return EINTR; otherwise, the "cancelled" flag will be
322    set, causing the next `hurd_check_cancel' call to return nonzero or the
323    next interruptible RPC to return EINTR (whichever is called first).  */
324 extern error_t hurd_thread_cancel (thread_t thread);
325
326 /* Test and clear the calling thread's "cancelled" flag.  */
327 extern int hurd_check_cancel (void);
328
329
330 /* Return the io server port for file descriptor FD.
331    This adds a Mach user reference to the returned port.
332    On error, sets `errno' and returns MACH_PORT_NULL.  */
333
334 extern io_t __getdport (int fd), getdport (int fd);
335
336
337 #include <stdarg.h>
338
339 /* Write formatted output to PORT, a Mach port supporting the i/o protocol,
340    according to the format string FORMAT, using the argument list in ARG.  */
341 int vpprintf (io_t port, const char *format, va_list arg);
342
343
344 #endif  /* hurd.h */