Incorporated from BSD 4.4-Lite.
[kopensolaris-gnu/glibc.git] / hurd / hurd.h
1 /* Copyright (C) 1993, 1994 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 Library General Public License as
6 published by the Free Software Foundation; either version 2 of the
7 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 Library General Public License for more details.
13
14 You should have received a copy of the GNU Library General Public
15 License along with the GNU C Library; see the file COPYING.LIB.  If
16 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
17 Cambridge, MA 02139, 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 #define __hurd_fail(err)        (errno = (err), -1)
46 \f
47 /* Basic ports and info, initialized by startup.  */
48
49 extern struct hurd_port *_hurd_ports;
50 extern unsigned int _hurd_nports;
51 extern volatile mode_t _hurd_umask;
52
53 /* Shorthand macro for referencing _hurd_ports (see <hurd/port.h>).  */
54
55 #define __USEPORT(which, expr) \
56   HURD_PORT_USE (&_hurd_ports[INIT_PORT_##which], (expr))
57
58
59 /* Base address and size of the initial stack set up by the exec server.
60    If using cthreads, this stack is deallocated in startup.
61    Not locked.  */
62
63 extern vm_address_t _hurd_stack_base;
64 extern vm_size_t _hurd_stack_size;
65
66 /* Initial file descriptor table we were passed at startup.  If we are
67    using a real dtable, these are turned into that and then cleared at
68    startup.  If not, these are never changed after startup.  Not locked.  */
69
70 extern mach_port_t *_hurd_init_dtable;
71 extern mach_msg_type_number_t _hurd_init_dtablesize;
72 \f
73 /* Miscellaneous library state.  */
74
75
76 /* Current process IDs.  */
77
78 extern pid_t _hurd_pid, _hurd_ppid, _hurd_pgrp;
79 extern int _hurd_orphaned;
80 \f
81 /* Unix `data break', for brk and sbrk.
82    If brk and sbrk are not used, this info will not be initialized or used.  */
83
84
85 /* Data break.  This is what `sbrk (0)' returns.  */
86
87 extern vm_address_t _hurd_brk;
88
89 /* End of allocated space.  This is generally `round_page (_hurd_brk)'.  */
90
91 extern vm_address_t _hurd_data_end;
92
93 /* This mutex locks _hurd_brk and _hurd_data_end.  */
94
95 extern struct mutex _hurd_brk_lock;
96
97 /* Set the data break to NEWBRK; _hurd_brk_lock must
98    be held, and is released on return.  */
99
100 extern int _hurd_set_brk (vm_address_t newbrk);
101 \f
102 #define __need_FILE
103 #include <stdio.h>
104
105 /* Calls to get and set basic ports.  */
106
107 extern error_t _hurd_ports_get (int which, mach_port_t *result);
108 extern error_t _hurd_ports_set (int which, mach_port_t newport);
109
110 extern process_t getproc (void);
111 extern file_t getcwdir (void), getcrdir (void);
112 extern auth_t getauth (void);
113 extern mach_port_t getcttyid ();
114 extern int setproc (process_t);
115 extern int setcwdir (file_t), setcrdir (file_t);
116 extern int setcttyid (mach_port_t);
117
118 /* Does reauth with the proc server and fd io servers.  */
119 extern int __setauth (auth_t), setauth (auth_t);
120
121
122 /* Split FILE into a directory and a name within the directory.  Look up a
123    port for the directory and store it in *DIR; store in *NAME a pointer
124    into FILE where the name within directory begins.  The directory lookup
125    uses CRDIR for the root directory and CWDIR for the current directory.
126    Returns zero on success or an error code.  */
127
128 extern error_t __hurd_path_split (file_t crdir, file_t cwdir,
129                                   const char *file,
130                                   file_t *dir, char **name);
131 extern error_t hurd_path_split (file_t crdir, file_t cwdir,
132                                 const char *file,
133                                 file_t *dir, char **name);
134
135 /* Open a port to FILE with the given FLAGS and MODE (see <fcntl.h>).
136    The file lookup uses CRDIR for the root directory and CWDIR for the
137    current directory.  If successful, returns zero and store the port
138    to FILE in *PORT; otherwise returns an error code. */
139
140 extern error_t __hurd_path_lookup (file_t crdir, file_t cwdir,
141                                    const char *file,
142                                    int flags, mode_t mode,
143                                    file_t *port);
144 extern error_t hurd_path_lookup (file_t crdir, file_t cwdir,
145                                  const char *filename,
146                                  int flags, mode_t mode,
147                                  file_t *port);
148
149 /* Process the values returned by `dir_pathtrans' et al, and loop doing
150    `dir_pathtrans' calls until one returns FS_RETRY_NONE.  CRDIR is the
151    root directory used for things like symlinks to absolute file names; the
152    other arguments should be those just passed to and/or returned from
153    `dir_pathtrans', `fsys_getroot', or `file_invoke_translator'.  This
154    function consumes the reference in *RESULT even if it returns an error.  */
155
156 extern error_t __hurd_path_lookup_retry (file_t crdir,
157                                          enum retry_type doretry,
158                                          char retryname[1024],
159                                          int flags, mode_t mode,
160                                          file_t *result);
161 extern error_t hurd_path_lookup_retry (file_t crdir,
162                                        enum retry_type doretry,
163                                        char retryname[1024],
164                                        int flags, mode_t mode,
165                                        file_t *result);
166
167
168 /* Split FILE into a directory and a name within the directory.  The
169    directory lookup uses the current root and working directory.  If
170    successful, stores in *NAME a pointer into FILE where the name
171    within directory begins and returns a port to the directory;
172    otherwise sets `errno' and returns MACH_PORT_NULL.  */
173
174 extern file_t __path_split (const char *file, char **name);
175 extern file_t path_split (const char *file, char **name);
176
177 /* Open a port to FILE with the given FLAGS and MODE (see <fcntl.h>).
178    The file lookup uses the current root and working directory.
179    Returns a port to the file if successful; otherwise sets `errno'
180    and returns MACH_PORT_NULL.  */
181
182 extern file_t __path_lookup (const char *file, int flags, mode_t mode);
183 extern file_t path_lookup (const char *file, int flags, mode_t mode);
184
185 /* Invoke any translator set on the node FILE represents, and return in
186    *TRANSLATED a port to the translated node.  FLAGS are as for
187    `dir_pathtrans' et al, but the returned port will not necessarily have
188    any more access rights than FILE does.  */
189
190 extern error_t __hurd_invoke_translator (file_t file, int flags,
191                                          file_t *translated);
192 extern error_t hurd_invoke_translator (file_t file, int flags,
193                                        file_t *translated);
194
195
196 /* Open a file descriptor on a port.  FLAGS are as for `open'; flags
197    affected by io_set_openmodes are not changed by this.  If successful,
198    this consumes a user reference for PORT (which will be deallocated on
199    close).  */
200
201 extern int openport (io_t port, int flags);
202
203 /* Open a stream on a port.  MODE is as for `fopen'.
204    If successful, this consumes a user reference for PORT
205    (which will be deallocated on fclose).  */
206
207 extern FILE *fopenport (io_t port, const char *mode);
208 extern FILE *__fopenport (io_t port, const char *mode);
209
210
211 /* Execute a file, replacing TASK's current program image.  */
212
213 extern error_t _hurd_exec (task_t task,
214                            file_t file,
215                            char *const argv[],
216                            char *const envp[]);
217
218
219 /* Inform the proc server we have exitted with STATUS, and kill the
220    task thoroughly.  This function never returns, no matter what.  */
221
222 extern void _hurd_exit (int status) __attribute__ ((noreturn));
223
224
225 /* Initialize the library data structures from the
226    ints and ports passed to us by the exec server.
227    Then vm_deallocate PORTARRAY and INTARRAY.  */
228
229 extern void _hurd_init (int flags, char **argv,
230                         mach_port_t *portarray, size_t portarraysize,
231                         int *intarray, size_t intarraysize);
232
233 /* Do startup handshaking with the proc server.  */
234
235 extern void _hurd_proc_init (char **argv);
236
237
238 /* Return the socket server for sockaddr domain DOMAIN.  */
239
240 extern socket_t _hurd_socket_server (int domain);
241
242 /* Send a `sig_post' RPC to process number PID.  If PID is zero,
243    send the message to all processes in the current process's process group.
244    If PID is < -1, send SIG to all processes in process group - PID.
245    SIG and REFPORT are passed along in the request message.  */
246
247 extern error_t _hurd_sig_post (pid_t pid, int sig, mach_port_t refport);
248 extern error_t hurd_sig_post (pid_t pid, int sig, mach_port_t refport);
249
250 /* Fetch the host privileged port and device master port from the proc
251    server.  They are fetched only once and then cached in the
252    variables below.  A special program that gets them from somewhere
253    other than the proc server (such as a bootstrap filesystem) can set
254    these variables to install the ports.  */
255
256 extern kern_return_t get_privileged_ports (host_priv_t *host_priv_ptr,
257                                            device_t *device_master_ptr);
258 extern mach_port_t _hurd_host_priv, _hurd_device_master;
259
260 /* Return the PID of the task whose control port is TASK.
261    On error, sets `errno' and returns -1.  */
262
263 extern pid_t __task2pid (task_t task), task2pid (task_t task);
264
265 /* Return the task control port of process PID.
266    On error, sets `errno' and returns MACH_PORT_NULL.  */
267
268 extern task_t __pid2task (pid_t pid), pid2task (pid_t pid);
269
270
271 /* Return the io server port for file descriptor FD.
272    This adds a Mach user reference to the returned port.
273    On error, sets `errno' and returns MACH_PORT_NULL.  */
274
275 extern io_t __getdport (int fd), getdport (int fd);
276
277
278 #endif  /* hurd.h */