hurd/hurdexec.c

   1 /* Copyright (C) 1991, 1992, 1993, 1994, 1995 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 <errno.h>
  20 #include <unistd.h>
  21 #include <fcntl.h>
  22 #include <limits.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <hurd.h>
  26 #include <hurd/fd.h>
  27 #include <hurd/signal.h>
  28
  29 /* Overlay TASK, executing FILE with arguments ARGV and environment ENVP.
  30    If TASK == mach_task_self (), some ports are dealloc'd by the exec server.
  31    ARGV and ENVP are terminated by NULL pointers.  */
  32 error_t
  33 _hurd_exec (task_t task, file_t file,
  34             char *const argv[], char *const envp[])
  35 {
  36   error_t err;
  37   char *args, *env, *ap;
  38   size_t argslen, envlen;
  39   int ints[INIT_INT_MAX];
  40   mach_port_t ports[_hurd_nports];
  41   struct hurd_userlink ulink_ports[_hurd_nports];
  42   file_t *dtable;
  43   unsigned int dtablesize, i;
  44   struct hurd_port **dtable_cells;
  45   struct hurd_userlink *ulink_dtable;
  46   char *const *p;
  47   struct hurd_sigstate *ss;
  48   mach_port_t *please_dealloc, *pdp;
  49
  50
  51   /* Pack the arguments into an array with nulls separating the elements.  */
  52   argslen = 0;
  53   if (argv != NULL)
  54     {
  55       p = argv;
  56       while (*p != NULL)
  57         argslen += strlen (*p++) + 1;
  58       args = __alloca (argslen);
  59       ap = args;
  60       for (p = argv; *p != NULL; ++p)
  61         ap = __memccpy (ap, *p, '\0', ULONG_MAX);
  62     }
  63   else
  64     args = NULL;
  65
  66   /* Pack the environment into an array with nulls separating elements.  */
  67   envlen = 0;
  68   if (envp != NULL)
  69     {
  70       p = envp;
  71       while (*p != NULL)
  72         envlen += strlen (*p++) + 1;
  73       env = __alloca (envlen);
  74       ap = env;
  75       for (p = envp; *p != NULL; ++p)
  76         ap = __memccpy (ap, *p, '\0', ULONG_MAX);
  77     }
  78   else
  79     env = NULL;
  80
  81   /* Load up the ports to give to the new program.  */
  82   for (i = 0; i < _hurd_nports; ++i)
  83     if (i == INIT_PORT_PROC && task != __mach_task_self ())
  84       {
  85         /* This is another task, so we need to ask the proc server
  86            for the right proc server port for it.  */
  87         if (err = __USEPORT (PROC, __proc_task2proc (port, task, &ports[i])))
  88           {
  89             while (--i > 0)
  90               _hurd_port_free (&_hurd_ports[i], &ulink_ports[i], ports[i]);
  91             return err;
  92           }
  93       }
  94     else
  95       ports[i] = _hurd_port_get (&_hurd_ports[i], &ulink_ports[i]);
  96
  97
  98   /* Load up the ints to give the new program.  */
  99   for (i = 0; i < INIT_INT_MAX; ++i)
 100     switch (i)
 101       {
 102       case INIT_UMASK:
 103         ints[i] = _hurd_umask;
 104         break;
 105
 106       case INIT_SIGMASK:
 107       case INIT_SIGIGN:
 108       case INIT_SIGPENDING:
 109         /* We will set these all below.  */
 110         break;
 111
 112       default:
 113         ints[i] = 0;
 114       }
 115
 116   ss = _hurd_self_sigstate ();
 117   __spin_lock (&ss->lock);
 118   ints[INIT_SIGMASK] = ss->blocked;
 119   ints[INIT_SIGPENDING] = ss->pending;
 120   ints[INIT_SIGIGN] = 0;
 121   for (i = 1; i < NSIG; ++i)
 122     if (ss->actions[i].sa_handler == SIG_IGN)
 123       ints[INIT_SIGIGN] |= __sigmask (i);
 124
 125   /* We hold the sigstate lock until the exec has failed so that no signal
 126      can arrive between when we pack the blocked and ignored signals, and
 127      when the exec actually happens.  A signal handler could change what
 128      signals are blocked and ignored.  Either the change will be reflected
 129      in the exec, or the signal will never be delivered.  Setting the
 130      critical section flag avoids anything we call trying to acquire the
 131      sigstate lock.  */
 132
 133   ss->critical_section = 1;
 134   __spin_unlock (&ss->lock);
 135
 136   /* Pack up the descriptor table to give the new program.  */
 137   __mutex_lock (&_hurd_dtable_lock);
 138
 139   dtablesize = _hurd_dtable ? _hurd_dtablesize : _hurd_init_dtablesize;
 140
 141   if (task == __mach_task_self ())
 142     /* Request the exec server to deallocate some ports from us if the exec
 143        succeeds.  The init ports and descriptor ports will arrive in the
 144        new program's exec_startup message.  If we failed to deallocate
 145        them, the new program would have duplicate user references for them.
 146        But we cannot deallocate them ourselves, because we must still have
 147        them after a failed exec call.  */
 148     please_dealloc = __alloca ((_hurd_nports + (2 * dtablesize))
 149                                 * sizeof (mach_port_t));
 150   else
 151     please_dealloc = NULL;
 152   pdp = please_dealloc;
 153
 154   if (_hurd_dtable != NULL)
 155     {
 156       dtable = __alloca (dtablesize * sizeof (dtable[0]));
 157       ulink_dtable = __alloca (dtablesize * sizeof (ulink_dtable[0]));
 158       dtable_cells = __alloca (dtablesize * sizeof (dtable_cells[0]));
 159       for (i = 0; i < dtablesize; ++i)
 160         {
 161           struct hurd_fd *const d = _hurd_dtable[i];
 162           if (d == NULL)
 163             {
 164               dtable[i] = MACH_PORT_NULL;
 165               continue;
 166             }
 167           __spin_lock (&d->port.lock);
 168           if (d->flags & FD_CLOEXEC)
 169             {
 170               /* This descriptor is marked to be closed on exec.
 171                  So don't pass it to the new program.  */
 172               dtable[i] = MACH_PORT_NULL;
 173               if (pdp && d->port.port != MACH_PORT_NULL)
 174                 {
 175                   /* We still need to deallocate the ports.  */
 176                   *pdp++ = d->port.port;
 177                   if (d->ctty.port != MACH_PORT_NULL)
 178                     *pdp++ = d->ctty.port;
 179                 }
 180               __spin_unlock (&d->port.lock);
 181             }
 182           else
 183             {
 184               if (pdp && d->ctty.port != MACH_PORT_NULL)
 185                 /* All the elements of DTABLE are added to PLEASE_DEALLOC
 186                    below, so we needn't add the port itself.
 187                    But we must deallocate the ctty port as well as
 188                    the normal port that got installed in DTABLE[I].  */
 189                 *pdp++ = d->ctty.port;
 190               dtable[i] = _hurd_port_locked_get (&d->port, &ulink_dtable[i]);
 191               dtable_cells[i] = &d->port;
 192             }
 193         }
 194     }
 195   else
 196     {
 197       dtable = _hurd_init_dtable;
 198       ulink_dtable = NULL;
 199       dtable_cells = NULL;
 200     }
 201
 202   /* The information is all set up now.  Try to exec the file.  */
 203
 204   {
 205     if (pdp)
 206       {
 207         /* Request the exec server to deallocate some ports from us if the exec
 208            succeeds.  The init ports and descriptor ports will arrive in the
 209            new program's exec_startup message.  If we failed to deallocate
 210            them, the new program would have duplicate user references for them.
 211            But we cannot deallocate them ourselves, because we must still have
 212            them after a failed exec call.  */
 213
 214         for (i = 0; i < _hurd_nports; ++i)
 215           *pdp++ = ports[i];
 216         for (i = 0; i < dtablesize; ++i)
 217           *pdp++ = dtable[i];
 218       }
 219
 220     err = __file_exec (file, task, MACH_MSG_TYPE_COPY_SEND,
 221                        _hurd_exec_flags & EXEC_INHERITED,
 222                        args, argslen, 0, env, envlen, 0,
 223                        dtable, MACH_MSG_TYPE_COPY_SEND, dtablesize,  0,
 224                        ports, MACH_MSG_TYPE_COPY_SEND, _hurd_nports, 0,
 225                        ints, INIT_INT_MAX, 0,
 226                        please_dealloc, pdp - please_dealloc, 0,
 227                        NULL, 0, 0);
 228   }
 229
 230   /* Release references to the standard ports.  */
 231   for (i = 0; i < _hurd_nports; ++i)
 232     if (i == INIT_PORT_PROC && task != __mach_task_self ())
 233       __mach_port_deallocate (__mach_task_self (), ports[i]);
 234     else
 235       _hurd_port_free (&_hurd_ports[i], &ulink_ports[i], ports[i]);
 236
 237   if (ulink_dtable != NULL)
 238     /* Release references to the file descriptor ports.  */
 239     for (i = 0; i < dtablesize; ++i)
 240       if (dtable[i] != MACH_PORT_NULL)
 241         _hurd_port_free (dtable_cells[i], &ulink_dtable[i], dtable[i]);
 242
 243   /* Release lock on the file descriptor table. */
 244   __mutex_unlock (&_hurd_dtable_lock);
 245
 246   /* Safe to let signals happen now.  */
 247   {
 248     sigset_t pending;
 249     __spin_lock (&ss->lock);
 250     ss->critical_section = 0;
 251     pending = ss->pending & ~ss->blocked;
 252     __spin_unlock (&ss->lock);
 253     if (pending)
 254       __msg_sig_post (_hurd_msgport, 0, __mach_task_self ());
 255   }
 256
 257   return err;
 258 }