hurd/hurdinit.c

   1 /* Copyright (C) 1992, 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 #include <sys/stat.h>
  20 #include <stdlib.h>
  21 #include <stdio.h>
  22 #include <unistd.h>
  23 #include <hurd.h>
  24 #include <hurd/port.h>
  25 #include "set-hooks.h"
  26 #include "hurdmalloc.h"         /* XXX */
  27
  28
  29 int _hurd_exec_flags;
  30 struct hurd_port *_hurd_ports;
  31 unsigned int _hurd_nports;
  32 mode_t _hurd_umask;
  33
  34 error_t
  35 _hurd_ports_use (int which, error_t (*operate) (mach_port_t))
  36 {
  37   return HURD_PORT_USE (&_hurd_ports[which], (*operate) (port));
  38 }
  39
  40 void _hurd_proc_init (char **argv);
  41
  42 DEFINE_HOOK (_hurd_subinit, (void));
  43
  44 /* Initialize the library data structures from the
  45    ints and ports passed to us by the exec server.
  46
  47    PORTARRAY and INTARRAY are vm_deallocate'd.  */
  48
  49 void
  50 _hurd_init (int flags, char **argv,
  51             mach_port_t *portarray, size_t portarraysize,
  52             int *intarray, size_t intarraysize)
  53 {
  54   size_t i;
  55
  56   _hurd_exec_flags = flags;
  57
  58   _hurd_ports = malloc (portarraysize * sizeof (*_hurd_ports));
  59   if (_hurd_ports == NULL)
  60     __libc_fatal ("Can't allocate _hurd_ports\n");
  61   _hurd_nports = portarraysize;
  62
  63   /* See what ports we were passed.  */
  64   for (i = 0; i < portarraysize; ++i)
  65     _hurd_port_init (&_hurd_ports[i], portarray[i]);
  66
  67   /* When the user asks for the bootstrap port,
  68      he will get the one the exec server passed us.  */
  69   __task_set_special_port (__mach_task_self (), TASK_BOOTSTRAP_PORT,
  70                            portarray[INIT_PORT_BOOTSTRAP]);
  71
  72   /* Tell the proc server we exist, if it does.  */
  73   if (portarray[INIT_PORT_PROC] != MACH_PORT_NULL)
  74     _hurd_proc_init (argv);
  75
  76   if (intarraysize > INIT_UMASK)
  77     _hurd_umask = intarray[INIT_UMASK] & 0777;
  78   else
  79     _hurd_umask = CMASK;
  80
  81   /* All done with init ints and ports.  */
  82   __vm_deallocate (__mach_task_self (),
  83                    (vm_address_t) intarray,
  84                    intarraysize * sizeof (int));
  85   __vm_deallocate (__mach_task_self (),
  86                    (vm_address_t) portarray,
  87                    portarraysize * sizeof (mach_port_t));
  88
  89   if (flags & EXEC_SECURE)
  90     /* XXX if secure exec, elide environment variables
  91        which the library uses and could be security holes.
  92        CORESERVER, COREFILE
  93        */ ;
  94
  95   /* Call other things which want to do some initialization.  These are not
  96      on the __libc_subinit hook because things there like to be able to
  97      assume the availability of the POSIX.1 services we provide.  */
  98   RUN_HOOK (_hurd_subinit, ());
  99 }
 100 \f
 101 #include <hurd/signal.h>
 102
 103 /* The user can do "int _hide_arguments = 1;" to make
 104    sure the arguments are never visible with `ps'.  */
 105 int _hide_arguments, _hide_environment;
 106
 107 /* Hook for things which should be initialized as soon as the proc
 108    server is available.  */
 109 DEFINE_HOOK (_hurd_proc_subinit, (void));
 110
 111 /* Do startup handshaking with the proc server just installed in _hurd_ports.
 112    Call _hurdsig_init to set up signal processing.  */
 113
 114 void
 115 _hurd_proc_init (char **argv)
 116 {
 117   mach_port_t oldmsg;
 118   struct hurd_userlink ulink;
 119   process_t procserver;
 120
 121   /* Initialize the signal code; Mach exceptions will become signals.  */
 122   _hurdsig_init ();
 123
 124   /* The signal thread is now prepared to receive messages.
 125      It is safe to give the port to the proc server.  */
 126
 127   procserver = _hurd_port_get (&_hurd_ports[INIT_PORT_PROC], &ulink);
 128
 129   /* Give the proc server our message port.  */
 130   __proc_setmsgport (procserver, _hurd_msgport, &oldmsg);
 131   if (oldmsg != MACH_PORT_NULL)
 132     /* Deallocate the old msg port we replaced.  */
 133     __mach_port_deallocate (__mach_task_self (), oldmsg);
 134
 135   /* Tell the proc server where our args and environment are.  */
 136   __proc_set_arg_locations (procserver,
 137                             _hide_arguments ? 0 : (vm_address_t) argv,
 138                             _hide_environment ? 0 : (vm_address_t) __environ);
 139
 140   _hurd_port_free (&_hurd_ports[INIT_PORT_PROC], &ulink, procserver);
 141
 142   /* Initialize proc server-assisted fault recovery for the signal thread.  */
 143   _hurdsig_fault_init ();
 144
 145   /* Call other things which want to do some initialization.  These are not
 146      on the _hurd_subinit hook because things there assume that things done
 147      here, like _hurd_pid, are already initialized.  */
 148   RUN_HOOK (_hurd_proc_subinit, ());
 149
 150   if (_hurd_exec_flags & EXEC_TRACED)
 151     /* This process is "traced", meaning it should stop on signals or exec.
 152        We are all set up now to handle signals.  Stop ourselves, to inform
 153        our parent (presumably a debugger) that the exec has completed.  */
 154     __msg_sig_post (_hurd_msgport, SIGTRAP, __mach_task_self ());
 155 }
 156 \f
 157 /* Called when we get a message telling us to change our proc server port.  */
 158
 159 error_t
 160 _hurd_setproc (process_t procserver)
 161 {
 162   error_t err;
 163   mach_port_t oldmsg;
 164
 165   /* Give the proc server our message port.  */
 166   if (err = __proc_setmsgport (procserver, _hurd_msgport, &oldmsg))
 167     return err;
 168   if (oldmsg != MACH_PORT_NULL)
 169     /* Deallocate the old msg port we replaced.  */
 170     __mach_port_deallocate (__mach_task_self (), oldmsg);
 171
 172   /* Tell the proc server where our args and environment are.  */
 173   if (err = __proc_set_arg_locations (procserver,
 174                                       /* We don't know the ARGV location.  */
 175                                       (vm_address_t) 0,
 176                                       _hide_environment ? 0 :
 177                                       (vm_address_t) __environ))
 178     return err;
 179
 180   /* Those calls worked, so the port looks good.  */
 181   _hurd_port_set (&_hurd_ports[INIT_PORT_PROC], procserver);
 182
 183   {
 184     pid_t oldpgrp = _hurd_pgrp;
 185
 186     /* Call these functions again so they can fetch the
 187        new information from the new proc server.  */
 188     RUN_HOOK (_hurd_proc_subinit, ());
 189
 190     if (_hurd_pgrp != oldpgrp)
 191       {
 192         /* Run things that want notification of a pgrp change.  */
 193         DECLARE_HOOK (_hurd_pgrp_changed_hook, (pid_t));
 194         RUN_HOOK (_hurd_pgrp_changed_hook, (_hurd_pgrp));
 195       }
 196   }
 197
 198   return 0;
 199 }
 200 \f
 201 #ifndef PIC
 202
 203 /* Map the page at address zero with no access allowed, so
 204    dereferencing NULL will fault and no "anywhere" allocations
 205    (e.g. the out of line memory containing the argument strings)
 206    can be assigned address zero, which C says is not a valid pointer.
 207
 208    When dynamically linked, this will be done by the dynamic linker
 209    before we run.  */
 210
 211 static void map0 (void) __attribute__ ((unused));
 212 text_set_element (_hurd_preinit_hook, map0);
 213
 214 static void
 215 map0 (void)
 216 {
 217   vm_address_t addr = 0;
 218   __vm_map (__mach_task_self (),
 219             &addr, __vm_page_size, 0, 0, MACH_PORT_NULL, 0, 1,
 220             VM_PROT_NONE, VM_PROT_NONE, VM_INHERIT_COPY);
 221 }
 222
 223 #endif