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