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