4401eb62e96c0dee247bdfdf00c6df9b9b64b2d8
[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 #include <hurd/msg.h>
39
40 #define __spin_lock(lockaddr) /* no-op XXX */
41 #define __spin_unlock(lockaddr) /* no-op XXX */
42
43 #define __mutex_lock(lockaddr) /* no-op XXX */
44 #define __mutex_unlock(lockaddr) /* no-op XXX */
45
46 /* Get `struct hurd_port' and related definitions implementing lightweight
47    user references for ports.  These are used pervasively throughout the C
48    library; this is here to avoid putting it in nearly every source file.  */
49 #include <hurd/port.h>
50
51 #include <errno.h>
52 #define __hurd_fail(err)        (errno = (err), -1)
53 \f
54 /* Basic ports and info, initialized by startup.  */
55
56 extern struct hurd_port *_hurd_ports;
57 extern unsigned int _hurd_nports;
58 extern volatile mode_t _hurd_umask;
59
60 /* Shorthand macro for referencing _hurd_ports (see <hurd/port.h>).  */
61
62 #define __USEPORT(which, expr) \
63   HURD_PORT_USE (&_hurd_ports[INIT_PORT_##which], (expr))
64
65
66 /* Base address and size of the initial stack set up by the exec server.
67    If using cthreads, this stack is deallocated in startup.
68    Not locked.  */
69
70 extern vm_address_t _hurd_stack_base;
71 extern vm_size_t _hurd_stack_size;
72
73 /* Initial file descriptor table we were passed at startup.  If we are
74    using a real dtable, these are turned into that and then cleared at
75    startup.  If not, these are never changed after startup.  Not locked.  */
76
77 extern mach_port_t *_hurd_init_dtable;
78 extern mach_msg_type_number_t _hurd_init_dtablesize;
79 \f
80 /* Miscellaneous library state.  */
81
82
83 /* Current process IDs.  */
84
85 extern pid_t _hurd_pid, _hurd_ppid, _hurd_pgrp;
86 extern int _hurd_orphaned;
87 #ifdef noteven
88 extern struct mutex _hurd_pid_lock; /* Locks above.  */
89 #endif
90 \f
91 /* Unix `data break', for brk and sbrk.
92    If brk and sbrk are not used, this info will not be initialized or used.  */
93
94
95 /* Data break.  This is what `sbrk (0)' returns.  */
96
97 extern vm_address_t _hurd_brk;
98
99 /* End of allocated space.  This is generally `round_page (_hurd_brk)'.  */
100
101 extern vm_address_t _hurd_data_end;
102
103 /* This mutex locks _hurd_brk and _hurd_data_end.  */
104
105 #ifdef noteven
106 extern struct mutex _hurd_brk_lock;
107 #endif
108
109 /* Set the data resource limit (RLIM_DATA).  */
110
111 extern int _hurd_set_data_limit (const struct rlimit *);
112
113 /* Set the data break to NEWBRK; _hurd_brk_lock must
114    be held, and is released on return.  */
115
116 extern int _hurd_set_brk (vm_address_t newbrk);
117 \f
118 /* Calls to get and set basic ports.  */
119
120 extern process_t getproc (void);
121 extern file_t getccdir (void), getcwdir (void), getcrdir (void);
122 extern auth_t getauth (void);
123 extern int setproc (process_t);
124 extern int setcwdir (file_t), setcrdir (file_t);
125
126 /* Does reauth with the proc server and fd io servers.  */
127 extern int __setauth (auth_t), setauth (auth_t);
128
129
130 /* Split FILE into a directory and a name within the directory.  Look up a
131    port for the directory and store it in *DIR; store in *NAME a pointer
132    into FILE where the name within directory begins.  The directory lookup
133    uses CRDIR for the root directory and CWDIR for the current directory.
134    Returns zero on success or an error code.  */
135
136 extern error_t __hurd_path_split (file_t crdir, file_t cwdir,
137                                   const char *file,
138                                   file_t *dir, char **name);
139 extern error_t hurd_path_split (file_t crdir, file_t cwdir,
140                                 const char *file,
141                                 file_t *dir, char **name);
142
143 /* Open a port to FILE with the given FLAGS and MODE (see <fcntl.h>).
144    The file lookup uses CRDIR for the root directory and CWDIR for the
145    current directory.  If successful, returns zero and store the port
146    to FILE in *PORT; otherwise returns an error code. */
147
148 extern error_t __hurd_path_lookup (file_t crdir, file_t cwdir,
149                                    const char *file,
150                                    int flags, mode_t mode,
151                                    file_t *port);
152 extern error_t hurd_path_lookup (file_t crdir, file_t cwdir,
153                                  const char *filename,
154                                  int flags, mode_t mode,
155                                  file_t *port);
156
157 /* Split FILE into a directory and a name within the directory.  The
158    directory lookup uses the current root and working directory.  If
159    successful, stores in *NAME a pointer into FILE where the name
160    within directory begins and returns a port to the directory;
161    otherwise sets `errno' and returns MACH_PORT_NULL.  */
162
163 extern file_t __path_split (const char *file, char **name);
164 extern file_t path_split (const char *file, char **name);
165
166 /* Open a port to FILE with the given FLAGS and MODE (see <fcntl.h>).
167    The file lookup uses the current root and working directory.
168    Returns a port to the file if successful; otherwise sets `errno'
169    and returns MACH_PORT_NULL.  */
170
171 extern file_t __path_lookup (const char *file, int flags, mode_t mode);
172 extern file_t path_lookup (const char *file, int flags, mode_t mode);
173
174
175 /* Open a file descriptor on a port.  */
176
177 extern int openport (io_t port, int flags);
178
179
180 /* Execute a file, replacing TASK's current program image.  */
181
182 extern error_t _hurd_exec (task_t task,
183                            file_t file,
184                            char *const argv[],
185                            char *const envp[]);
186
187
188 /* Inform the proc server we have exitted with STATUS, and kill the
189    task thoroughly.  This function never returns, no matter what.  */
190
191 extern void _hurd_exit (int status) __attribute__ ((noreturn));
192
193
194 /* Initialize the library data structures from the
195    ints and ports passed to us by the exec server.
196    Then vm_deallocate PORTARRAY and INTARRAY.  */
197
198 extern void _hurd_init (int flags, char **argv,
199                         mach_port_t *portarray, size_t portarraysize,
200                         int *intarray, size_t intarraysize);
201
202 /* Do startup handshaking with the proc server.  */
203
204 extern void _hurd_proc_init (char **argv);
205
206 /* Return the socket server for sockaddr domain DOMAIN.  */
207
208 extern socket_t _hurd_socket_server (int domain);
209
210 /* Fetch the host privileged port and device master port from the proc
211    server.  They are fetched only once and then cached in the
212    variables below.  A special program that gets them from somewhere
213    other than the proc server (such as a bootstrap filesystem) can set
214    these variables to install the ports.  */
215
216 extern kern_return_t get_privileged_ports (host_priv_t *host_priv_ptr,
217                                            device_t *device_master_ptr);
218 extern mach_port_t _hurd_host_priv, _hurd_device_master;
219
220 /* Return the PID of the task whose control port is TASK.
221    On error, sets `errno' and returns -1.  */
222
223 extern pid_t __task2pid (task_t task), task2pid (task_t task);
224
225 /* Return the task control port of process PID.
226    On error, sets `errno' and returns MACH_PORT_NULL.  */
227
228 extern task_t __pid2task (pid_t pid), pid2task (pid_t pid);
229
230
231 /* Return the io server port for file descriptor FD.
232    This adds a Mach user reference to the returned port.
233    On error, sets `errno' and returns MACH_PORT_NULL.  */
234
235 extern io_t __getdport (int fd), getdport (int fd);
236
237
238
239 #endif  /* hurd.h */