hurd/hurd.h

   1 /* Copyright (C) 1993, 1994, 1995, 1996 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
  46 _EXTERN_INLINE int
  47 __hurd_fail (error_t err)
  48 {
  49   switch (err)
  50     {
  51     case EMACH_SEND_INVALID_DEST:
  52     case EMIG_SERVER_DIED:
  53       /* The server has disappeared!  */
  54       err = EIEIO;
  55       break;
  56
  57     case KERN_NO_SPACE:
  58       err = ENOMEM;
  59       break;
  60     case KERN_INVALID_ARGUMENT:
  61       err = EINVAL;
  62       break;
  63
  64     case 0:
  65       return 0;
  66     default:
  67     }
  68
  69   errno = err;
  70   return -1;
  71 }
  72 \f
  73 /* Basic ports and info, initialized by startup.  */
  74
  75 extern int _hurd_exec_flags;    /* Flags word passed in exec_startup.  */
  76 extern struct hurd_port *_hurd_ports;
  77 extern unsigned int _hurd_nports;
  78 extern volatile mode_t _hurd_umask;
  79 extern sigset_t _hurdsig_traced;
  80
  81 /* Shorthand macro for internal library code referencing _hurd_ports (see
  82    <hurd/port.h>).  */
  83
  84 #define __USEPORT(which, expr) \
  85   HURD_PORT_USE (&_hurd_ports[INIT_PORT_##which], (expr))
  86
  87 /* Function version of __USEPORT: calls OPERATE with a send right.  */
  88
  89 extern error_t _hurd_ports_use (int which, error_t (*operate) (mach_port_t));
  90
  91
  92 /* Base address and size of the initial stack set up by the exec server.
  93    If using cthreads, this stack is deallocated in startup.
  94    Not locked.  */
  95
  96 extern vm_address_t _hurd_stack_base;
  97 extern vm_size_t _hurd_stack_size;
  98
  99 /* Initial file descriptor table we were passed at startup.  If we are
 100    using a real dtable, these are turned into that and then cleared at
 101    startup.  If not, these are never changed after startup.  Not locked.  */
 102
 103 extern mach_port_t *_hurd_init_dtable;
 104 extern mach_msg_type_number_t _hurd_init_dtablesize;
 105 \f
 106 /* Current process IDs.  */
 107
 108 extern pid_t _hurd_pid, _hurd_ppid, _hurd_pgrp;
 109 extern int _hurd_orphaned;
 110
 111 /* This variable is incremented every time the process IDs change.  */
 112
 113 unsigned int _hurd_pids_changed_stamp;
 114
 115 /* This condition is broadcast every time the process IDs change.  */
 116 struct condition _hurd_pids_changed_sync;
 117 \f
 118 /* Unix `data break', for brk and sbrk.
 119    If brk and sbrk are not used, this info will not be initialized or used.  */
 120
 121
 122 /* Data break.  This is what `sbrk (0)' returns.  */
 123
 124 extern vm_address_t _hurd_brk;
 125
 126 /* End of allocated space.  This is generally `round_page (_hurd_brk)'.  */
 127
 128 extern vm_address_t _hurd_data_end;
 129
 130 /* This mutex locks _hurd_brk and _hurd_data_end.  */
 131
 132 extern struct mutex _hurd_brk_lock;
 133
 134 /* Set the data break to NEWBRK; _hurd_brk_lock must
 135    be held, and is released on return.  */
 136
 137 extern int _hurd_set_brk (vm_address_t newbrk);
 138 \f
 139 #define __need_FILE
 140 #include <stdio.h>
 141
 142 /* Calls to get and set basic ports.  */
 143
 144 extern error_t _hurd_ports_get (unsigned int which, mach_port_t *result);
 145 extern error_t _hurd_ports_set (unsigned int which, mach_port_t newport);
 146
 147 extern process_t getproc (void);
 148 extern file_t getcwdir (void), getcrdir (void);
 149 extern auth_t getauth (void);
 150 extern mach_port_t getcttyid (void);
 151 extern int setproc (process_t);
 152 extern int setcwdir (file_t), setcrdir (file_t);
 153 extern int setcttyid (mach_port_t);
 154
 155 /* Does reauth with the proc server and fd io servers.  */
 156 extern int __setauth (auth_t), setauth (auth_t);
 157
 158
 159 /* Split FILE into a directory and a name within the directory.  The
 160    directory lookup uses the current root and working directory.  If
 161    successful, stores in *NAME a pointer into FILE where the name
 162    within directory begins and returns a port to the directory;
 163    otherwise sets `errno' and returns MACH_PORT_NULL.  */
 164
 165 extern file_t __file_name_split (const char *file, char **name);
 166 extern file_t file_name_split (const char *file, char **name);
 167
 168 /* Open a port to FILE with the given FLAGS and MODE (see <fcntl.h>).
 169    The file lookup uses the current root and working directory.
 170    Returns a port to the file if successful; otherwise sets `errno'
 171    and returns MACH_PORT_NULL.  */
 172
 173 extern file_t __file_name_lookup (const char *file, int flags, mode_t mode);
 174 extern file_t file_name_lookup (const char *file, int flags, mode_t mode);
 175
 176 /* Open a port to FILE with the given FLAGS and MODE (see <fcntl.h>).  The
 177    file lookup uses the current root directory, but uses STARTDIR as the
 178    "working directory" for file relative names.  Returns a port to the file
 179    if successful; otherwise sets `errno' and returns MACH_PORT_NULL.  */
 180
 181 extern file_t __file_name_lookup_under (file_t startdir, const char *file,
 182                                         int flags, mode_t mode);
 183 extern file_t file_name_lookup_under (file_t startdir, const char *file,
 184                                       int flags, mode_t mode);
 185
 186
 187 /* Lookup FILE_NAME and return the node opened with FLAGS & MODE
 188    (see hurd_file_name_lookup for details), but a simple file name (without
 189    any directory prefixes) will be consecutively prefixed with the pathnames
 190    in the `:' separated list PATH until one succeeds in a successful lookup.
 191    If none succeed, then the first error that wasn't ENOENT is returned, or
 192    ENOENT if no other errors were returned.  If PREFIXED_NAME is non-NULL,
 193    then if the result is looked up directly, *PREFIXED_NAME is set to NULL, and
 194    if it is looked up using a prefix from PATH, *PREFIXED_NAME is set to
 195    malloc'd storage containing the prefixed name.  */
 196 extern file_t file_name_path_lookup (const char *file_name, const char *path,
 197                                      int flags, mode_t mode,
 198                                      char **prefixed_name);
 199
 200
 201
 202 /* Open a file descriptor on a port.  FLAGS are as for `open'; flags
 203    affected by io_set_openmodes are not changed by this.  If successful,
 204    this consumes a user reference for PORT (which will be deallocated on
 205    close).  */
 206
 207 extern int openport (io_t port, int flags);
 208
 209 /* Open a stream on a port.  MODE is as for `fopen'.
 210    If successful, this consumes a user reference for PORT
 211    (which will be deallocated on fclose).  */
 212
 213 extern FILE *fopenport (io_t port, const char *mode);
 214 extern FILE *__fopenport (io_t port, const char *mode);
 215
 216
 217 /* Execute a file, replacing TASK's current program image.  */
 218
 219 extern error_t _hurd_exec (task_t task,
 220                            file_t file,
 221                            char *const argv[],
 222                            char *const envp[]);
 223
 224
 225 /* Inform the proc server we have exitted with STATUS, and kill the
 226    task thoroughly.  This function never returns, no matter what.  */
 227
 228 extern void _hurd_exit (int status) __attribute__ ((noreturn));
 229
 230
 231 /* Initialize the library data structures from the
 232    ints and ports passed to us by the exec server.
 233    Then vm_deallocate PORTARRAY and INTARRAY.  */
 234
 235 extern void _hurd_init (int flags, char **argv,
 236                         mach_port_t *portarray, size_t portarraysize,
 237                         int *intarray, size_t intarraysize);
 238
 239 /* Do startup handshaking with the proc server.  */
 240
 241 extern void _hurd_proc_init (char **argv);
 242
 243
 244 /* Return the socket server for sockaddr domain DOMAIN.  If DEAD is
 245    nonzero, remove the old cached port and always do a fresh lookup.
 246
 247    It is assumed that a socket server will stay alive during a complex socket
 248    operation involving several RPCs.  But a socket server may die during
 249    long idle periods between socket operations.  Callers should first pass
 250    zero for DEAD; if the first socket RPC tried on the returned port fails
 251    with MACH_SEND_INVALID_DEST or MIG_SERVER_DIED (indicating the server
 252    went away), the caller should call _hurd_socket_server again with DEAD
 253    nonzero and retry the RPC on the new socket server port.  */
 254
 255 extern socket_t _hurd_socket_server (int domain, int dead);
 256
 257 /* Send a `sig_post' RPC to process number PID.  If PID is zero,
 258    send the message to all processes in the current process's process group.
 259    If PID is < -1, send SIG to all processes in process group - PID.
 260    SIG and REFPORT are passed along in the request message.  */
 261
 262 extern error_t _hurd_sig_post (pid_t pid, int sig, mach_port_t refport);
 263 extern error_t hurd_sig_post (pid_t pid, int sig, mach_port_t refport);
 264
 265 /* Fetch the host privileged port and device master port from the proc
 266    server.  They are fetched only once and then cached in the
 267    variables below.  A special program that gets them from somewhere
 268    other than the proc server (such as a bootstrap filesystem) can set
 269    these variables to install the ports.  */
 270
 271 extern kern_return_t get_privileged_ports (host_priv_t *host_priv_ptr,
 272                                            device_t *device_master_ptr);
 273 extern mach_port_t _hurd_host_priv, _hurd_device_master;
 274
 275 /* Return the PID of the task whose control port is TASK.
 276    On error, sets `errno' and returns -1.  */
 277
 278 extern pid_t __task2pid (task_t task), task2pid (task_t task);
 279
 280 /* Return the task control port of process PID.
 281    On error, sets `errno' and returns MACH_PORT_NULL.  */
 282
 283 extern task_t __pid2task (pid_t pid), pid2task (pid_t pid);
 284
 285 /* Return the current thread's thread port.  This is a cheap operation (no
 286    system call), but it relies on Hurd signal state being set up.  */
 287 extern thread_t hurd_thread_self (void);
 288
 289
 290 /* Cancel pending operations on THREAD.  If it is doing an interruptible RPC,
 291    that RPC will now return EINTR; otherwise, the "cancelled" flag will be
 292    set, causing the next `hurd_check_cancel' call to return nonzero or the
 293    next interruptible RPC to return EINTR (whichever is called first).  */
 294 extern error_t hurd_thread_cancel (thread_t thread);
 295
 296 /* Test and clear the calling thread's "cancelled" flag.  */
 297 extern int hurd_check_cancel (void);
 298
 299
 300 /* Return the io server port for file descriptor FD.
 301    This adds a Mach user reference to the returned port.
 302    On error, sets `errno' and returns MACH_PORT_NULL.  */
 303
 304 extern io_t __getdport (int fd), getdport (int fd);
 305
 306
 307 #endif  /* hurd.h */