[thirdparty/glibc.git] / hurd / hurdexec.c

/* Copyright (C) 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
This file is part of the GNU C Library.

The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.

The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Library General Public License for more details.

You should have received a copy of the GNU Library General Public
License along with the GNU C Library; see the file COPYING.LIB.  If
not, write to the Free Software Foundation, Inc., 675 Mass Ave,
Cambridge, MA 02139, USA.  */

#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include <hurd.h>
#include <hurd/fd.h>
#include <hurd/signal.h>

/* Overlay TASK, executing FILE with arguments ARGV and environment ENVP.
   If TASK == mach_task_self (), some ports are dealloc'd by the exec server.
   ARGV and ENVP are terminated by NULL pointers.  */
error_t
_hurd_exec (task_t task, file_t file,
	    char *const argv[], char *const envp[])
{
  error_t err;
  char *args, *env, *ap;
  size_t argslen, envlen;
  int ints[INIT_INT_MAX];
  mach_port_t ports[_hurd_nports];
  struct hurd_userlink ulink_ports[_hurd_nports];
  file_t *dtable;
  unsigned int dtablesize, i;
  struct hurd_port **dtable_cells;
  struct hurd_userlink *ulink_dtable;
  char *const *p;
  struct hurd_sigstate *ss;
  mach_port_t *please_dealloc, *pdp;


  /* Pack the arguments into an array with nulls separating the elements.  */
  argslen = 0;
  if (argv != NULL)
    {
      p = argv;
      while (*p != NULL)
	argslen += strlen (*p++) + 1;
      args = __alloca (argslen);
      ap = args;
      for (p = argv; *p != NULL; ++p)
	ap = __memccpy (ap, *p, '\0', ULONG_MAX);
    }
  else
    args = NULL;

  /* Pack the environment into an array with nulls separating elements.  */
  envlen = 0;
  if (envp != NULL)
    {
      p = envp;
      while (*p != NULL)
	envlen += strlen (*p++) + 1;
      env = __alloca (envlen);
      ap = env;
      for (p = envp; *p != NULL; ++p)
	ap = __memccpy (ap, *p, '\0', ULONG_MAX);
    }
  else
    env = NULL;

  /* Load up the ports to give to the new program.  */
  for (i = 0; i < _hurd_nports; ++i)
    if (i == INIT_PORT_PROC && task != __mach_task_self ())
      {
	/* This is another task, so we need to ask the proc server
	   for the right proc server port for it.  */
	if (err = __USEPORT (PROC, __proc_task2proc (port, task, &ports[i])))
	  {
	    while (--i > 0)
	      _hurd_port_free (&_hurd_ports[i], &ulink_ports[i], ports[i]);
	    return err;
	  }
      }
    else
      ports[i] = _hurd_port_get (&_hurd_ports[i], &ulink_ports[i]);


  /* Load up the ints to give the new program.  */
  for (i = 0; i < INIT_INT_MAX; ++i)
    switch (i)
      {
      case INIT_UMASK:
	ints[i] = _hurd_umask;
	break;

      case INIT_SIGMASK:
      case INIT_SIGIGN:
      case INIT_SIGPENDING:
	/* We will set these all below.  */
	break;

      default:
	ints[i] = 0;
      }

  ss = _hurd_self_sigstate ();
  __spin_lock (&ss->lock);
  ints[INIT_SIGMASK] = ss->blocked;
  ints[INIT_SIGPENDING] = ss->pending;
  ints[INIT_SIGIGN] = 0;
  for (i = 1; i < NSIG; ++i)
    if (ss->actions[i].sa_handler == SIG_IGN)
      ints[INIT_SIGIGN] |= __sigmask (i);

  /* We hold the sigstate lock until the exec has failed so that no signal
     can arrive between when we pack the blocked and ignored signals, and
     when the exec actually happens.  A signal handler could change what
     signals are blocked and ignored.  Either the change will be reflected
     in the exec, or the signal will never be delivered.  Setting the
     critical section flag avoids anything we call trying to acquire the
     sigstate lock.  */

  ss->critical_section = 1;
  __spin_unlock (&ss->lock);

  /* Pack up the descriptor table to give the new program.  */
  __mutex_lock (&_hurd_dtable_lock);

  dtablesize = _hurd_dtable ? _hurd_dtablesize : _hurd_init_dtablesize;

  if (task == __mach_task_self ())
    /* Request the exec server to deallocate some ports from us if the exec
       succeeds.  The init ports and descriptor ports will arrive in the
       new program's exec_startup message.  If we failed to deallocate
       them, the new program would have duplicate user references for them.
       But we cannot deallocate them ourselves, because we must still have
       them after a failed exec call.  */
    please_dealloc = __alloca ((_hurd_nports + (2 * dtablesize))
				* sizeof (mach_port_t));
  else
    please_dealloc = NULL;
  pdp = please_dealloc;

  if (_hurd_dtable != NULL)
    {
      dtable = __alloca (dtablesize * sizeof (dtable[0]));
      ulink_dtable = __alloca (dtablesize * sizeof (ulink_dtable[0]));
      dtable_cells = __alloca (dtablesize * sizeof (dtable_cells[0]));
      for (i = 0; i < dtablesize; ++i)
	{
	  struct hurd_fd *const d = _hurd_dtable[i];
	  if (d == NULL)
	    {
	      dtable[i] = MACH_PORT_NULL;
	      continue;
	    }
	  __spin_lock (&d->port.lock);
	  if (d->flags & FD_CLOEXEC)
	    {
	      /* This descriptor is marked to be closed on exec.
		 So don't pass it to the new program.  */
	      dtable[i] = MACH_PORT_NULL;
	      if (pdp && d->port.port != MACH_PORT_NULL)
		{
		  /* We still need to deallocate the ports.  */
		  *pdp++ = d->port.port;
		  if (d->ctty.port != MACH_PORT_NULL)
		    *pdp++ = d->ctty.port;
		}
	      __spin_unlock (&d->port.lock);
	    }
	  else
	    {
	      if (pdp && d->ctty.port != MACH_PORT_NULL)
		/* All the elements of DTABLE are added to PLEASE_DEALLOC
		   below, so we needn't add the port itself.
		   But we must deallocate the ctty port as well as
		   the normal port that got installed in DTABLE[I].  */
		*pdp++ = d->ctty.port;
	      dtable[i] = _hurd_port_locked_get (&d->port, &ulink_dtable[i]);
	      dtable_cells[i] = &d->port;
	    }
	}
    }
  else
    {
      dtable = _hurd_init_dtable;
      ulink_dtable = NULL;
      dtable_cells = NULL;
    }

  /* The information is all set up now.  Try to exec the file.  */

  {
    if (pdp)
      {
	/* Request the exec server to deallocate some ports from us if the exec
	   succeeds.  The init ports and descriptor ports will arrive in the
	   new program's exec_startup message.  If we failed to deallocate
	   them, the new program would have duplicate user references for them.
	   But we cannot deallocate them ourselves, because we must still have
	   them after a failed exec call.  */

	for (i = 0; i < _hurd_nports; ++i)
	  *pdp++ = ports[i];
	for (i = 0; i < dtablesize; ++i)
	  *pdp++ = dtable[i];
      }

    err = __file_exec (file, task,
		       _hurd_exec_flags & EXEC_INHERITED,
		       args, argslen, env, envlen,
		       dtable, MACH_MSG_TYPE_COPY_SEND, dtablesize,
		       ports, MACH_MSG_TYPE_COPY_SEND, _hurd_nports,
		       ints, INIT_INT_MAX,
		       please_dealloc, pdp - please_dealloc,
		       &_hurd_msgport, task == __mach_task_self () ? 1 : 0);
  }

  /* Release references to the standard ports.  */
  for (i = 0; i < _hurd_nports; ++i)
    if (i == INIT_PORT_PROC && task != __mach_task_self ())
      __mach_port_deallocate (__mach_task_self (), ports[i]);
    else
      _hurd_port_free (&_hurd_ports[i], &ulink_ports[i], ports[i]);

  if (ulink_dtable != NULL)
    /* Release references to the file descriptor ports.  */
    for (i = 0; i < dtablesize; ++i)
      if (dtable[i] != MACH_PORT_NULL)
	_hurd_port_free (dtable_cells[i], &ulink_dtable[i], dtable[i]);

  /* Release lock on the file descriptor table. */
  __mutex_unlock (&_hurd_dtable_lock);

  /* Safe to let signals happen now.  */
  {
    sigset_t pending;
    __spin_lock (&ss->lock);
    ss->critical_section = 0;
    pending = ss->pending & ~ss->blocked;
    __spin_unlock (&ss->lock);
    if (pending)
      __msg_sig_post (_hurd_msgport, 0, __mach_task_self ());
  }

  return err;
}
Commit	Line	Data
28f540f4 RM	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
75914335	33	_hurd_exec (task_t task, file_t file,
28f540f4 RM	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;
1e9dc039	43	unsigned int dtablesize, i;
28f540f4 RM	44	struct hurd_port **dtable_cells;
28f540f4 RM	45	struct hurd_userlink *ulink_dtable;
28f540f4 RM	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. */
75914335	132
28f540f4 RM	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
924b9ff6	220	err = __file_exec (file, task,
28f540f4	221	_hurd_exec_flags & EXEC_INHERITED,
924b9ff6 RM	222	args, argslen, env, envlen,
	223	dtable, MACH_MSG_TYPE_COPY_SEND, dtablesize,
	224	ports, MACH_MSG_TYPE_COPY_SEND, _hurd_nports,
	225	ints, INIT_INT_MAX,
	226	please_dealloc, pdp - please_dealloc,
75914335	227	&_hurd_msgport, task == __mach_task_self () ? 1 : 0);
28f540f4 RM	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	}