Initial revision

1 files changed, 1516 insertions, 0 deletions

diff --git a/exec/exec.c b/exec/exec.c
new file mode 100644
index 00000000..2e489711
--- /dev/null
+++ b/exec/exec.c
@@ -0,0 +1,1516 @@
+/* GNU Hurd standard exec server.
+   Copyright (C) 1992, 1993, 1994 Free Software Foundation, Inc.
+   Written by Roland McGrath.
+
+   #ifdef BFD
+   Can exec any executable format the BFD library understands
+   to be for this flavor of machine. [requires nonexistent BFD support]
+   #endif
+   #ifdef AOUT
+   Can exec a.out format.
+   #endif
+
+This file is part of the GNU Hurd.
+
+The GNU Hurd is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+The GNU Hurd 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 General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with the GNU Hurd; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#include <errno.h>
+#include <mach.h>
+#include <mach/notify.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <hurd.h>
+#include <hurd/startup.h>
+#include <hurd/shared.h>
+#include <hurd/fsys.h>
+#include <hurd/exec.h>
+#include "exec_server.h"
+#include "fsys_S.h"
+
+
+/* Default: BFD or a.out?  */
+#if	!defined (BFD) && !defined (AOUT)
+#define	AOUT
+#endif
+
+
+#ifdef	BFD
+#include <bfd.h>
+
+/* Uses the following nonexistent functions: */
+bfd *bfd_openstream (FILE *);
+
+extern error_t bfd_mach_host_arch_mach (host_t host,
+					bfd_architecture *arch,
+					bfd_machine *machine);
+#else
+#include A_OUT_H
+
+extern error_t aout_mach_host_machine (host_t host, int *host_machine);
+#endif
+
+
+/* Data shared between check, check_section,
+   load, load_section, and finish.  */
+struct execdata
+  {
+    /* Passed out to caller.  */
+    error_t error;
+
+    /* Set by check.  */
+    vm_address_t entry;
+#ifdef	BFD
+    FILE stream;
+    bfd *bfd;
+#else
+    file_t file;
+    struct exec *header;
+#endif
+    memory_object_t filemap, cntlmap;
+    struct shared_io *cntl;
+    off_t file_size;
+
+    /* Set by caller of load.  */
+    task_t task;
+
+#ifdef	BFD
+    /* Vector indexed by section index,
+       information passed from check_section to load_section.
+       Set by caller of check_section and load.  */
+    vm_offset_t *locations;
+#endif
+  };
+
+#ifdef	BFD
+static bfd host_bfd;		/* A BFD whose architecture and machine type
+				   reflect those of the running system.  */
+#else
+static enum machine_type host_machine; /* a.out machine_type of the host.  */
+#endif
+
+static file_t realnode;
+static mach_port_t execserver;	/* Port doing exec protocol.  */
+static mach_port_t fsys;	/* Port doing fsys protocol.  */
+static mach_port_t request_portset; /* Portset we receive on.  */
+char *exec_version = "0.0 pre-alpha";
+char **save_argv;
+
+/* Standard exec data for secure execs.  */
+static mach_port_t *std_ports;
+static int *std_ints;
+static size_t std_nports, std_nints;
+
+#ifdef	BFD
+/* Return a Hurd error code corresponding to the most recent BFD error.  */
+static error_t
+b2he (error_t deflt)
+{
+  switch (bfd_error)
+    {
+    case system_call_error:
+      return a2he (errno);
+
+    case no_memory:
+      return ENOMEM;
+
+    default:
+      return deflt;
+    }
+}
+#else
+#define	b2he()	a2he (errno)
+#endif
+
+#ifdef	BFD
+
+/* Check a section, updating the `locations' vector [BFD].  */
+static void
+check_section (bfd *bfd, asection *sec, void *userdata)
+{
+  struct execdata *u = userdata;
+  vm_address_t addr;
+
+  if (u->error)
+    return;
+
+  if (!(sec->flags & SEC_ALLOC|SEC_LOAD) ||
+      (sec->flags & SEC_NEVER_LOAD))
+    /* Nothing to do for this section.  */
+    return;
+
+  if (sec->flags & SEC_RELOC)
+    {
+      u->error = EINVAL;
+      return;
+    }
+
+  addr = (vm_address_t) sec->bfd_vma;
+
+  if (sec->flags & SEC_LOAD)
+    {
+      file_ptr section_offset;
+
+      u->locations[sec->index] = sec->filepos;
+      if ((off_t) sec->filepos < 0 || (off_t) sec->filepos > e->file_size)
+	u->error = EINVAL;
+    }
+}
+#endif
+
+enum section { text, data, bss };
+
+/* Load or allocate a section.  */
+static void
+#ifdef	BFD
+load_section (bfd *bfd, asection *sec, void *userdata)
+#else
+load_section (enum section section, struct execdata *u)
+#endif
+{
+#ifdef	BFD
+  struct execdata *u = userdata;
+#endif
+  vm_address_t addr = 0;
+  vm_offset_t filepos = 0;
+  vm_size_t secsize = 0;
+  vm_prot_t vm_prot;
+
+  if (u->error)
+    return;
+
+#ifdef	BFD
+  if (sec->flags & SEC_NEVER_LOAD)
+    /* Nothing to do for this section.  */
+    return;
+#endif
+
+  vm_prot = VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE;
+
+#ifdef	BFD
+  addr = (vm_address_t) sec->bfd_vma;
+  filepos = u->locations[sec->index];
+  secsize = sec->size;
+  if (sec->flags & (SEC_READONLY|SEC_ROM))
+    vm_prot &= ~VM_PROT_WRITE;
+#else
+  switch (section)
+    {
+    case text:
+      addr = (vm_address_t) N_TXTADDR (*u->header);
+      filepos = (vm_offset_t) N_TXTOFF (*u->header);
+      secsize = N_TXTLEN (*u->header);
+      vm_prot &= ~VM_PROT_WRITE;
+      break;
+    case data:
+      addr = (vm_address_t) N_DATADDR (*u->header);
+      filepos = (vm_offset_t) N_DATOFF (*u->header);
+      secsize = N_DATLEN (*u->header);
+      break;
+    case bss:
+      addr = (vm_address_t) N_BSSADDR (*u->header);
+      secsize = N_BSSLEN (*u->header);
+      break;
+    }
+#endif
+
+  if (
+#ifdef	BFD
+      sec->flags & SEC_LOAD
+#else
+      section != bss
+#endif
+      )
+    {
+      vm_address_t mapstart = round_page (addr);
+
+      if (mapstart - addr < secsize)
+	{
+	  /* MAPSTART is the first page that starts inside the section.
+	     Map all the pages that start inside the section.  */
+
+#ifdef	BFD
+	  if (sec->flags & SEC_IN_MEMORY)
+	    u->error = vm_write (u->task, mapstart,
+				 contents + (mapstart - addr),
+				 secsize - (mapstart - addr));
+	  else
+#endif
+	    u->error = vm_map (u->task,
+			       &mapstart, secsize - (mapstart - addr), 0, 0,
+			       u->filemap, filepos + (mapstart - addr), 1, 
+			       vm_prot,
+			       VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE,
+			       VM_INHERIT_COPY);
+	  if (u->error)
+	    return;
+	}
+
+      if (mapstart > addr)
+	{
+	  /* We must read and copy in the space in the section before the
+             first page boundary.  */
+	  vm_address_t overlap_page = trunc_page (addr);
+	  vm_address_t ourpage = 0;
+	  vm_size_t size = 0;
+	  void *readaddr;
+	  size_t readsize;
+
+#ifdef	AOUT
+	  if (N_MAGIC (*u->header) == NMAGIC || N_MAGIC (*u->header) == ZMAGIC)
+	    {
+	      u->error = ENOEXEC;
+	      goto maplose;
+	    }
+#endif
+
+	  if (u->error = vm_read (u->task, overlap_page, vm_page_size,
+				  &ourpage, &size))
+	    {
+	    maplose:
+	      vm_deallocate (u->task, mapstart, secsize);
+	      return;
+	    }
+
+	  readaddr = (void *) (ourpage + (addr - overlap_page));
+	  readsize = size - (addr - overlap_page);
+
+#ifdef	BFD
+	  if (sec->flags & SEC_IN_MEMORY)
+	    bcopy (sec->contents, readaddr, readsize);
+	  else if (fread (readaddr, readsize, 1, u->stream) != 1)
+	    {
+	      u->error = errno;
+	      goto maplose;
+	    }
+#else
+	  if (u->cntl)
+	    {
+	      /* We cannot call io_read while holding the conch,
+		 so we must read by mapping the file ourselves.  */
+	      vm_address_t data;
+	      if (u->error = vm_map (mach_task_self (), &data, readsize, 0, 1,
+				     u->filemap, filepos, 1,
+				     VM_PROT_READ, VM_PROT_READ,
+				     VM_INHERIT_COPY))
+		goto maplose;
+	      bcopy ((void *) data, readaddr, readsize);
+	      vm_deallocate (mach_task_self (), data, readsize);
+	    }
+	  else
+	    do
+	      {
+		char *data;
+		unsigned int nread;
+		data = readaddr;
+		if (u->error = io_read (u->file, &data, &nread,
+					filepos, readsize))
+		  goto maplose;
+		if (data != readaddr)
+		  {
+		    bcopy (data, readaddr, nread);
+		    vm_deallocate (mach_task_self (), (vm_address_t) data, 
+				   nread);
+		  }
+		readaddr += nread;
+		readsize -= nread;
+	      } while (readsize > 0);
+#endif
+	  u->error = vm_write (u->task, overlap_page, ourpage, size);
+	  if (u->error == KERN_PROTECTION_FAILURE)
+	    {
+	      /* The overlap page is not writable; the section
+		 that appears in preceding memory is read-only.
+		 Change the page's protection so we can write it.  */
+	      u->error = vm_protect (u->task, overlap_page, size,
+				     0, vm_prot | VM_PROT_WRITE);
+	      if (!u->error)
+		u->error = vm_write (u->task, overlap_page, ourpage, size);
+	      /* If this section is not supposed to be writable either,
+		 restore the page's protection to read-only.  */
+	      if (!u->error && !(vm_prot & VM_PROT_WRITE))
+		u->error = vm_protect (u->task, overlap_page, size,
+				       0, vm_prot);
+	    }
+	  vm_deallocate (mach_task_self (), ourpage, size);
+	  if (u->error)
+	    goto maplose;
+	}
+
+      if (u->cntl)
+	u->cntl->accessed = 1;
+    }
+#ifdef	BFD
+  else if (sec->flags & SEC_ALLOC)
+#else
+  else
+#endif
+    {
+      /* SEC_ALLOC: Allocate zero-filled memory for the section.  */
+
+      vm_address_t mapstart = round_page (addr);
+
+      if (mapstart - addr < secsize)
+	{
+	  /* MAPSTART is the first page that starts inside the section.
+	     Allocate all the pages that start inside the section.  */
+
+	  if (u->error = vm_allocate (u->task, &mapstart, 
+				      secsize - (mapstart - addr), 0))
+	    return;
+	}
+
+      if (mapstart > addr
+#ifdef	BFD
+	  && (sec->flags & SEC_HAS_CONTENTS)
+#endif
+	  )
+	{
+	  /* Zero space in the section before the first page boundary.  */
+	  vm_address_t overlap_page = trunc_page (addr);
+	  vm_address_t ourpage = 0;
+	  vm_size_t size = 0;
+	  if (u->error = vm_read (u->task, overlap_page, vm_page_size,
+				  &ourpage, &size))
+	    {
+	      vm_deallocate (u->task, mapstart, secsize);
+	      return;
+	    }
+	  bzero ((void *) (ourpage + (addr - overlap_page)),
+		 size - (addr - overlap_page));
+	  u->error = vm_write (u->task, overlap_page, ourpage, size);
+	  vm_deallocate (mach_task_self (), ourpage, size);
+	}
+    }
+}
+
+/* Do post-loading processing for a section.  This consists of peeking the
+   pages of non-demand-paged executables.  */
+
+static void
+#ifdef	BFD
+postload_section (bfd *bfd, asection *sec, void *userdata)
+#else
+postload_section (enum section section, struct execdata *u)
+#endif
+{
+#ifdef	BFD
+  struct execdata *u = userdata;
+#endif
+  vm_address_t addr = 0;
+  vm_size_t secsize = 0;
+
+#ifdef	BFD
+  addr = (vm_address_t) sec->bfd_vma;
+  secsize = sec->size;
+#else
+  switch (section)
+    {
+    case text:
+      addr = (vm_address_t) N_TXTADDR (*u->header);
+      secsize = N_TXTLEN (*u->header);
+      break;
+    case data:
+      addr = (vm_address_t) N_DATADDR (*u->header);
+      secsize = N_DATLEN (*u->header);
+      break;
+    case bss:
+      addr = (vm_address_t) N_BSSADDR (*u->header);
+      secsize = N_BSSLEN (*u->header);
+      break;
+    }
+#endif
+
+  if (
+#ifdef	AOUT
+      section != bss && N_MAGIC (*u->header) == NMAGIC
+#else
+      (sec->flags & SEC_LOAD) && !(bfd->flags & D_PAGED)
+#endif
+      )
+    {
+      /* Pre-load the section by peeking every mapped page.  */
+      vm_address_t myaddr, a;
+      vm_size_t mysize;
+      myaddr = 0;
+	  
+      /* We have already mapped the file into the task in load_section.
+	 Now read from the task's memory into our own address space so we
+	 can peek each page and cause it to be paged in.  */
+      if (u->error = vm_read (u->task, trunc_page (addr), round_page (secsize),
+			      &myaddr, &mysize))
+	return;
+
+      /* Peek at the first word of each page.  */
+      for (a = ((myaddr + mysize) & ~(vm_page_size - 1));
+	   a >= myaddr; a -= vm_page_size)
+	/* Force it to be paged in.  */
+	(void) *(volatile int *) a;
+
+      vm_deallocate (mach_task_self (), myaddr, mysize);
+    }
+}
+
+
+
+#ifdef	BFD
+/* stdio input-room function.  */
+static int
+input_room (FILE *f)
+{
+  struct execdata *e = f->__cookie;
+  const size_t size = e->file_size;
+
+  if (f->__buffer != NULL)
+    vm_deallocate (mach_task_self (), f->__buffer, f->__bufsize);
+
+  if (f->__target > size)
+    {
+      f->__eof = 1;
+      return EOF;
+    }
+
+  f->__buffer = NULL;
+  if (vm_map (mach_task_self (),
+	      (vm_address_t *) &f->__buffer, vm_page_size, 0, 1,
+	      e->filemap, f->__target, 1, VM_PROT_READ, VM_PROT_READ,
+	      VM_INHERIT_NONE))
+    {
+      errno = EIO;
+      f.__error = 1;
+      return EOF;
+    }
+  f->__bufsize = vm_page_size;
+  f->__offset = f->__target;
+
+  if (f->__target + f->__bufsize > size)
+    f->__get_limit = f->__buffer + (size - f->__target);
+  else
+    f->__get_limit = f->__buffer + f->__bufsize;
+
+  if (e->cntl)
+    e->cntl->accessed = 1;
+
+  f->__bufp = f->__buffer;
+  return (unsigned char) *f->__bufp++;
+}
+
+static int
+close_stdio_bfd (void *cookie)
+{
+  struct execdata *e = cookie;
+
+  if (e->stream.__buffer != NULL)
+    vm_deallocate (e->stream.__buffer, e->stream.__bufsize);
+
+  return 0;
+}
+#endif
+
+
+/* Prepare to load FILE.
+   On successful return, the caller must allocate the
+   E->locations vector, and map check_section over the BFD.  */
+static inline void
+check (file_t file, struct execdata *e)
+{
+  e->file = file;
+
+#ifdef	BFD
+  e->bfd = NULL;
+#endif
+  e->cntl = NULL;
+  e->filemap = MACH_PORT_NULL;
+  e->cntlmap = MACH_PORT_NULL;
+
+  {
+    memory_object_t rd, wr;
+    if (e->error = io_map (file, &rd, &wr))
+      return;
+    if (wr)
+      mach_port_deallocate (mach_task_self (), wr);
+    if (rd == MACH_PORT_NULL)
+      {
+	e->error = EBADF;	/* ? XXX */
+	return;
+      }
+    e->filemap = rd;
+
+    e->error = /* io_map_cntl (file, &e->cntlmap) */ EOPNOTSUPP; /* XXX */
+    if (e->error)
+      {
+	/* No shared page.  Do a stat to find the file size.  */
+	struct stat st;
+	if (e->error = io_stat (file, &st))
+	  return;
+	e->file_size = st.st_size;
+      }
+    else
+      e->error = vm_map (mach_task_self (), (vm_address_t *) &e->cntl,
+			 vm_page_size, 0, 1, e->cntlmap, 0, 0,
+			 VM_PROT_READ|VM_PROT_WRITE, 
+			 VM_PROT_READ|VM_PROT_WRITE, VM_INHERIT_NONE);
+
+    if (e->cntl)
+      while (1)
+	{
+	  spin_lock (&e->cntl->lock);
+	  switch (e->cntl->conch_status)
+	    {
+	    case USER_COULD_HAVE_CONCH:
+	      e->cntl->conch_status = USER_HAS_CONCH;
+	    case USER_HAS_CONCH:
+	      spin_unlock (&e->cntl->lock);
+	      /* Break out of the loop.  */
+	      break;
+	    case USER_RELEASE_CONCH:
+	    case USER_HAS_NOT_CONCH:
+	    default:		/* Oops.  */
+	      spin_unlock (&e->cntl->lock);
+	      if (e->error = io_get_conch (e->file))
+		return;
+	      /* Continue the loop.  */
+	      continue;
+	    }
+
+	  /* Get here if we are now IT.  */
+	  e->file_size = 0;
+	  if (e->cntl->use_file_size)
+	    e->file_size = e->cntl->file_size;
+	  if (e->cntl->use_read_size && e->cntl->read_size > e->file_size)
+	    e->file_size = e->cntl->read_size;
+	  break;
+	}
+  }
+
+#ifdef	BFD
+  /* Open a BFD to do mapped i/o to the file.  */
+  memset (&e->stream, 0, sizeof (e->stream));
+  e->stream.__magic = _IOMAGIC;
+  e->stream.__mode.__read = 1;
+  e->stream.__userbuf = 1;
+  e->stream.__room_funcs.__input = input_room;
+  e->stream.__io_funcs.__close = close_stdio_bfd;
+  e->stream.__cookie = &e;
+
+  e->bfd = bfd_openstream (&e->stream);
+  if (e->bfd == NULL)
+    {
+      e->error = b2he (ENOEXEC);
+      return;
+    }
+
+  bfd_error = no_error;
+  if (!bfd_check_format (e->bfd, bfd_object))
+    {
+      e->error = b2he (ENOEXEC);
+      return;
+    }
+  else if (!bfd_arch_compatible (e->bfd, &host_bfd, NULL, NULL) ||
+	   !(bfd->flags & EXEC_P))
+    {
+      e->error = b2he (EINVAL);
+      return;
+    }
+
+  e->entry = bfd->start_address;
+#else
+  /* Map in the a.out header.  */
+  if (e->file_size < sizeof (*e->header))
+    {
+      e->error = EINVAL;
+      return;
+    }
+  e->header = NULL;
+  if (e->error = vm_map (mach_task_self (),
+			 (vm_address_t *) &e->header, sizeof (*e->header),
+			 0, 1, e->filemap, 0, 1, VM_PROT_READ, VM_PROT_READ,
+			 VM_INHERIT_NONE))
+    return;
+  if (N_BADMAG (*e->header))
+    {
+      e->error = ENOEXEC;
+      return;
+    }
+  if (N_MACHTYPE (*e->header) && N_MACHTYPE (*e->header) != host_machine)
+    {
+      e->error = EINVAL;
+      return;
+    }
+
+  e->entry = e->header->a_entry;
+#endif
+}
+
+
+/* Load the file.  */
+static inline void
+load (task_t usertask, struct execdata *e)
+{
+  if (e->error)
+    return;
+
+  e->task = usertask;
+#ifdef	BFD
+  bfd_map_over_sections (e->bfd, load_section, e);
+#else
+  load_section (text, e);
+  load_section (data, e);
+  load_section (bss, e);
+#endif
+}
+
+/* Do post-loading processing on the task.  */
+static inline void
+postload (struct execdata *e)
+{
+  if (e->error)
+    return;
+
+#ifdef	BFD
+  bfd_map_over_sections (e->bfd, postload_section, e);
+#else
+  postload_section (text, e);
+  postload_section (data, e);
+  postload_section (bss, e);
+#endif
+}
+
+
+/* Release the conch and clean up mapping the file and control page.  */
+static inline void
+finish_mapping (struct execdata *e)
+{
+  if (e->cntl != NULL)
+    {
+      spin_lock (&e->cntl->lock);
+      if (e->cntl->conch_status == USER_RELEASE_CONCH)
+	{
+	  spin_unlock (&e->cntl->lock);
+	  io_release_conch (e->file);
+	}
+      else
+	{
+	  e->cntl->conch_status = USER_HAS_NOT_CONCH;
+	  spin_unlock (&e->cntl->lock);
+	}
+      vm_deallocate (mach_task_self (), (vm_address_t) e->cntl, vm_page_size);
+    }
+  if (e->filemap != MACH_PORT_NULL)
+    mach_port_deallocate (mach_task_self (), e->filemap);
+  if (e->cntlmap != MACH_PORT_NULL)
+    mach_port_deallocate (mach_task_self (), e->cntlmap);
+}
+      
+/* Clean up after reading the file (need not be completed).  */
+static inline void
+finish (struct execdata *e)
+{
+  finish_mapping (e);
+#ifdef	BFD
+  if (e->bfd != NULL)
+    (void) bfd_close (e->bfd);
+#else
+  if (e->header != NULL)
+    vm_deallocate (mach_task_self (),
+		   (vm_address_t) e->header, sizeof (*e->header));
+  mach_port_deallocate (mach_task_self (), e->file);
+#endif
+}
+
+static int
+request_server (mach_msg_header_t *inp,
+		mach_msg_header_t *outp)
+{
+  extern int notify_server (), exec_server (), fsys_server ();
+
+  return (notify_server (inp, outp) ||
+	  exec_server (inp, outp) ||
+	  fsys_server (inp, outp));
+}
+
+
+/* Allocate SIZE bytes of storage, and make the
+   resulting pointer a name for a new receive right.  */
+static void *
+alloc_recv (size_t size)
+{
+  void *obj = malloc (size);
+  if (obj == NULL)
+    return NULL;
+
+  if (mach_port_allocate_name (mach_task_self (),
+			       MACH_PORT_RIGHT_RECEIVE,
+			       (mach_port_t) obj)
+      == KERN_NAME_EXISTS)
+    {
+      void *new = alloc_recv (size); /* Bletch.  */
+      free (obj);
+      return new;
+    }
+
+  return obj;
+}
+
+/* Information kept around to be given to a new task
+   in response to a message on the task's bootstrap port.  */
+struct bootinfo
+  {
+    vm_address_t stack_base;
+    vm_size_t stack_size;
+    int flags;
+    char *argv, *envp;
+    size_t argvlen, envplen, dtablesize, nports, nints;
+    mach_port_t *dtable, *portarray;
+    int *intarray;
+  };
+
+static inline error_t
+servercopy (void **arg, u_int argsize, boolean_t argcopy)
+{
+  if (argcopy)
+    {
+      /* ARG came in-line, so we must copy it.  */
+      error_t error;
+      void *copy;
+      if (error = vm_allocate (mach_task_self (),
+			       (vm_address_t *) &copy, argsize, 1))
+	return error;
+      bcopy (*arg, copy, argsize);
+      *arg = copy;
+    }
+  return 0;
+}
+
+static error_t
+do_exec (mach_port_t execserver,
+	 file_t file,
+	 task_t oldtask,
+	 int flags,
+	 char *argv, u_int argvlen, boolean_t argv_copy,
+	 char *envp, u_int envplen, boolean_t envp_copy,
+	 mach_port_t *dtable, u_int dtablesize, boolean_t dtable_copy,
+	 mach_port_t *portarray, u_int nports, boolean_t portarray_copy,
+	 int *intarray, u_int nints, boolean_t intarray_copy,
+	 mach_port_t *deallocnames, u_int ndeallocnames,
+	 mach_port_t *destroynames, u_int ndestroynames)
+{
+  struct execdata e;
+  int finished = 0;
+  task_t newtask = MACH_PORT_NULL;
+  thread_t thread = MACH_PORT_NULL;
+  struct bootinfo *boot = 0;
+
+  if (oldtask != MACH_PORT_NULL && (e.error = task_suspend (oldtask)))
+    return e.error;
+
+  check (file, &e);
+  if (e.error)
+    goto out;
+#ifdef	BFD
+  e.locations = alloca (e.bfd->section_count * sizeof (vm_offset_t));
+  bfd_map_over_sections (e.bfd, check_section, e);
+  if (e.error)
+    goto out;
+#endif
+
+  if (oldtask == MACH_PORT_NULL)
+    flags |= EXEC_NEWTASK;
+
+  if (flags & (EXEC_NEWTASK|EXEC_SECURE))
+    {
+      /* Create the new task.  If we are not being secure, then use OLDTASK
+	 for the task_create RPC, in case it is something magical.  */	 
+      if (e.error = task_create (flags & EXEC_SECURE || !oldtask ?
+				 mach_task_self () : oldtask,
+				 0, &newtask))
+	goto out;
+    }
+  else
+    {
+      thread_array_t threads;
+      mach_msg_type_number_t nthreads, i;
+
+      /* Terminate all the threads of the old task.  */
+
+      if (e.error = task_threads (oldtask, &threads, &nthreads))
+	goto out;
+      for (i = 0; i < nthreads; ++i)
+	{
+	  thread_terminate (threads[i]);
+	  mach_port_deallocate (mach_task_self (), threads[i]);
+	}
+      vm_deallocate (mach_task_self (),
+		     (vm_address_t) threads, nthreads * sizeof (thread_t));
+
+      /* Deallocate the entire virtual address space of the task.  */
+
+      vm_deallocate (oldtask,
+		     VM_MIN_ADDRESS, VM_MAX_ADDRESS - VM_MIN_ADDRESS);
+
+      /* Deallocate and destroy the ports requested by the caller.
+	 These are ports the task wants not to lose if the exec call
+	 fails, but wants removed from the new program task.  */
+
+      for (i = 0; i < ndeallocnames; ++i)
+	mach_port_deallocate (oldtask, deallocnames[i]);
+
+      for (i = 0; i < ndestroynames; ++i)
+	mach_port_destroy (oldtask, destroynames[i]);
+
+      newtask = oldtask;
+    }
+
+  /* Load the file into the task.  */
+  load (newtask, &e);
+  if (e.error)
+    goto out;
+
+  /* Release the conch for the file.  */
+  finish_mapping (&e);
+
+  /* Further frobnicate the task after loading from the file.  */
+  postload (&e);
+  if (e.error)
+    goto out;
+
+  /* Clean up.  */
+  finish (&e);
+  finished = 1;
+
+  /* Create the initial thread.  */
+  if (e.error = thread_create (newtask, &thread))
+    goto out;
+
+  /* Store the data that we will give in response
+     to the RPC on the new task's bootstrap port.  */
+
+  boot = alloc_recv (sizeof (*boot));
+  if (boot == NULL)
+    {
+      e.error = ENOMEM;
+      goto out;
+    }
+
+  if (nports <= INIT_PORT_BOOTSTRAP)
+    {
+      mach_port_t *new;
+      vm_allocate (mach_task_self (),
+		   (vm_address_t *) &new,
+		   INIT_PORT_MAX * sizeof (mach_port_t), 1);
+      memcpy (new, portarray, nports * sizeof (mach_port_t));
+      bzero (&new[nports], (INIT_PORT_MAX - nports) * sizeof (mach_port_t));
+    }
+  if (portarray[INIT_PORT_BOOTSTRAP] == MACH_PORT_NULL &&
+      oldtask != MACH_PORT_NULL)
+    task_get_bootstrap_port (oldtask, &portarray[INIT_PORT_BOOTSTRAP]);
+
+  if (e.error = mach_port_insert_right (mach_task_self (),
+					(mach_port_t) boot,
+					(mach_port_t) boot,
+					MACH_MSG_TYPE_MAKE_SEND))
+    goto out;
+  if (e.error = task_set_bootstrap_port (newtask, (mach_port_t) boot))
+    goto out;
+  mach_port_deallocate (mach_task_self (), (mach_port_t) boot);
+
+  if (e.error = servercopy ((void **) &argv, argvlen, argv_copy))
+    goto bootout;
+  boot->argv = argv;
+  boot->argvlen = argvlen;
+  if (e.error = servercopy ((void **) &envp, envplen, envp_copy))
+    goto bootout;
+  boot->envp = envp;
+  boot->envplen = envplen;
+  if (e.error = servercopy ((void **) &dtable,
+			    dtablesize * sizeof (mach_port_t),
+			    dtable_copy))
+    goto bootout;
+  boot->dtable = dtable;
+  boot->dtablesize = dtablesize;
+  if (e.error = servercopy ((void **) &portarray,
+			    nports * sizeof (mach_port_t),
+			    portarray_copy))
+    goto bootout;
+  boot->portarray = portarray;
+  boot->nports = nports;
+  if (e.error = servercopy ((void **) &intarray,
+			    nints * sizeof (mach_port_t),
+			    intarray_copy))
+    goto bootout;
+  boot->intarray = intarray;
+  boot->nints = nints;
+  boot->flags = flags;
+
+  {
+    mach_port_t unused;
+    mach_port_request_notification (mach_task_self (),
+				    (mach_port_t) boot,
+				    MACH_NOTIFY_NO_SENDERS, 0,
+				    (mach_port_t) boot,
+				    MACH_MSG_TYPE_MAKE_SEND_ONCE,
+				    &unused);
+  }
+
+  if (flags & EXEC_SECURE)
+    {
+#ifdef notyet
+      mach_port_t new;
+      if (e.error = __USEPORT (PROC, proc_task2proc (port, newtask, &new)))
+	goto bootout;
+
+      if (nports < INIT_PORT_MAX)
+	{
+	  /* Allocate a new vector that is big enough.  */
+	  vm_allocate (mach_task_self (),
+		       (vm_address_t *) &boot->portarray,
+		       INIT_PORT_MAX * sizeof (mach_port_t),
+		       1);
+	  memcpy (boot->portarray, portarray,
+		  nports * sizeof (mach_port_t));
+	  vm_deallocate (mach_task_self (), (vm_address_t) portarray,
+			 nports * sizeof (mach_port_t));
+	  nports = INIT_PORT_MAX;
+	}
+
+      mach_port_deallocate (mach_task_self (),
+			    boot->portarray[INIT_PORT_PROC]);
+      boot->portarray[INIT_PORT_PROC] = new;
+      mach_port_deallocate (mach_task_self (),
+			    boot->portarray[INIT_PORT_CRDIR]);
+      boot->portarray[INIT_PORT_CRDIR]
+	= std_ports ? std_ports[INIT_PORT_CRDIR] : MACH_PORT_NULL;
+      mach_port_deallocate (mach_task_self (),
+			    boot->portarray[INIT_PORT_CWDIR]);
+      boot->portarray[INIT_PORT_CWDIR]
+	= std_ports ? std_ports[INIT_PORT_CWDIR] : MACH_PORT_NULL;
+
+      if (nints < INIT_INT_MAX)
+	{
+	  /* Allocate a new vector that is big enough.  */
+	  vm_allocate (mach_task_self (),
+		       (vm_address_t *) &boot->intarray,
+		       INIT_INT_MAX * sizeof (int),
+		       1);
+	  memcpy (boot->intarray, intarray, nints * sizeof (int));
+	  vm_deallocate (mach_task_self (), (vm_address_t) intarray,
+			 nints * sizeof (int));
+	  nints = INIT_INT_MAX;
+	}
+
+      boot->intarray[INIT_UMASK]
+	= std_ints ? std_ints[INIT_UMASK] : CMASK;
+#else
+      abort ();
+#endif      
+    }
+
+  if (nports > INIT_PORT_PROC)
+    proc_mark_exec (boot->portarray[INIT_PORT_PROC]);
+
+  /* Start up the initial thread at the entry point.  */
+  boot->stack_base = 0, boot->stack_size = 0; /* Don't care about values.  */
+  if (e.error = mach_setup_thread (newtask, thread, (void *) e.entry,
+				   &boot->stack_base, &boot->stack_size))
+    goto bootout;
+
+  if (oldtask != newtask && oldtask != MACH_PORT_NULL)
+    {
+#if 0
+      /* The program is on its way.  The old task can be nuked.  */
+      process_t proc;
+      /* Use the canonical proc server if secure, or there is none other.
+	 When not secure, it is nice to let processes associate with
+	 whatever proc server turns them on, regardless of which exec
+	 itself is using.  */
+      process_t psrv = ((nports > INIT_PORT_PROC && !(flags & EXEC_SECURE)) ?
+			boot->portarray[INIT_PORT_PROC] : procserver);
+      /* XXX there is a race here for SIGKILLing the process.  */
+      if (! proc_task2proc (procserver, oldtask, &proc))
+	{
+	  /* XXX check for errors?? */
+	  proc_reassign (proc, newtask);
+	  mach_port_deallocate (mach_task_self (), proc);
+	}
+#endif
+      e.error = EINVAL;
+      goto bootout;
+    }
+
+  newtask = MACH_PORT_NULL;
+
+ bootout:
+  if (e.error)
+    {
+      mach_port_deallocate (mach_task_self (), (vm_address_t) boot);
+      if (boot->portarray != portarray)
+	vm_deallocate (mach_task_self (),
+		       (vm_address_t) boot->portarray,
+		       boot->nports * sizeof (mach_port_t));
+      free (boot);
+    }
+
+ out:
+  if (newtask != MACH_PORT_NULL)
+    {
+      task_terminate (newtask);
+      mach_port_deallocate (mach_task_self (), newtask);
+    }
+  if (!finished)
+    finish (&e);
+  
+  task_resume (oldtask);
+  thread_resume (thread);
+
+  if (thread != MACH_PORT_NULL)
+    mach_port_deallocate (mach_task_self (), thread);
+
+  mach_port_deallocate (mach_task_self (), oldtask);
+  
+  mach_port_move_member (mach_task_self (),
+			 (mach_port_t) boot, request_portset);
+
+  return e.error;
+}
+
+kern_return_t
+S_exec_exec (mach_port_t execserver,
+	     file_t file,
+	     task_t oldtask,
+	     int flags,
+	     char *argv, u_int argvlen, boolean_t argv_copy,
+	     char *envp, u_int envplen, boolean_t envp_copy,
+	     mach_port_t *dtable, u_int dtablesize, boolean_t dtable_copy,
+	     mach_port_t *portarray, u_int nports, boolean_t portarray_copy,
+	     int *intarray, u_int nints, boolean_t intarray_copy,
+	     mach_port_t *deallocnames, u_int ndeallocnames,
+	     mach_port_t *destroynames, u_int ndestroynames)
+{
+  if (!(flags & EXEC_SECURE))
+    {
+      const char envar[] = "\0EXECSERVERS=";
+      char *p = NULL;
+      if (envplen >= sizeof (envar) &&
+	  !memcmp (&envar[1], envp, sizeof (envar) - 2))
+	p = envp - 1;
+      else
+	p = memmem (envp, envplen, envar, sizeof (envar) - 1);
+      if (p != NULL)
+	{
+	  size_t len;
+	  char *list;
+	  int tried = 0;
+	  p += sizeof (envar) - 1;
+	  len = strlen (p) + 1;
+	  list = alloca (len);
+	  memcpy (list, p, len);
+	  while (p = strsep (&list, ":"))
+	    {
+	      file_t server;
+	      if (!hurd_path_lookup (portarray[INIT_PORT_CRDIR],
+				     portarray[INIT_PORT_CWDIR],
+				     p, 0, 0, &server))
+		{
+		  error_t err = (server == execserver ?
+				 do_exec (server, file, oldtask, 0,
+					  argv, argvlen, argv_copy,
+					  envp, envplen, envp_copy,
+					  dtable, dtablesize, dtable_copy,
+					  portarray, nports, portarray_copy,
+					  intarray, nints, intarray_copy,
+					  deallocnames, ndeallocnames,
+					  destroynames, ndestroynames) :
+				 exec_exec (server,
+					    file, MACH_MSG_TYPE_MOVE_SEND,
+					    oldtask, 0,
+					    argv, argvlen,
+					    envp, envplen,
+					    dtable, MACH_MSG_TYPE_MOVE_SEND,
+					    dtablesize,
+					    portarray, MACH_MSG_TYPE_MOVE_SEND,
+					    nports,
+					    intarray, nints,
+					    deallocnames, ndeallocnames,
+					    destroynames, ndestroynames));
+		  mach_port_deallocate (mach_task_self (), server);
+		  if (err != ENOEXEC)
+		    return err;
+		  tried = 1;
+		}
+	    }
+	  if (tried)
+	    /* At least one exec server got a crack at it and gave up.  */
+	    return ENOEXEC;
+	}
+    }
+
+  /* There were no user-specified exec servers,
+     or none of them could be found.  */
+
+  return do_exec (execserver, file, oldtask, 0,
+		  argv, argvlen, argv_copy,
+		  envp, envplen, envp_copy,
+		  dtable, dtablesize, dtable_copy,
+		  portarray, nports, portarray_copy,
+		  intarray, nints, intarray_copy,
+		  deallocnames, ndeallocnames,
+		  destroynames, ndestroynames);
+}
+
+kern_return_t
+S_exec_setexecdata (mach_port_t me,
+		    mach_port_t *ports, u_int nports, int ports_copy,
+		    int *ints, u_int nints, int ints_copy)
+{
+  error_t err;
+
+  /* XXX needs authentication */
+
+  if (nports < INIT_PORT_MAX || nints < INIT_INT_MAX)
+    return EINVAL;
+
+  if (std_ports)
+    vm_deallocate (mach_task_self (), (vm_address_t)std_ports, 
+		   std_nports * sizeof (mach_port_t));
+  if (err = servercopy ((void **) &ports, nports * sizeof (mach_port_t),
+			ports_copy))
+    return err;
+
+  std_ports = ports;
+  std_nports = nports;
+
+  if (std_ints)
+    vm_deallocate (mach_task_self (), (vm_address_t)std_ints,
+		   std_nints * sizeof (int));
+  if (err = servercopy ((void **) &ints, nints * sizeof (int), ints_copy))
+    return err;
+
+  std_ints = ints;
+  std_nints = nints;
+
+  return 0;
+}
+
+/* fsys server.  */
+
+kern_return_t
+S_fsys_getroot (fsys_t fsys,
+		uid_t *uids, u_int nuids,
+		gid_t *gids, u_int ngids,
+		int flags,
+		retry_type *retry,
+		char *retry_name,
+		file_t *rootfile,
+		mach_msg_type_name_t *rootfilePoly)
+{
+  /* XXX eventually this should return a user-specific port which has an
+     associated access-restricted realnode port which file ops get
+     forwarded to.  */
+
+  *rootfile = execserver;
+  *rootfilePoly = MACH_MSG_TYPE_MAKE_SEND;
+
+  *retry = FS_RETRY_NONE;
+  *retry_name = '\0';
+  return 0;
+}
+
+kern_return_t
+S_fsys_goaway (fsys_t fsys, int flags)
+{
+  if (!(flags & FSYS_GOAWAY_FORCE))
+    {
+      mach_port_t *serving;
+      mach_msg_type_number_t nserving, i;
+      mach_port_get_set_status (mach_task_self (), request_portset,
+				&serving, &nserving);
+      for (i = 0; i < nserving; ++i)
+	mach_port_deallocate (mach_task_self (), serving[i]);
+      if (nserving > 2)
+	/* Not just fsys and execserver.
+	   We are also waiting on some bootstrap ports.  */
+	return EBUSY;
+    }
+  mach_port_mod_refs (mach_task_self (), request_portset,
+		      MACH_PORT_TYPE_RECEIVE, -1);
+  return 0;
+}
+
+kern_return_t
+S_fsys_startup (mach_port_t bootstrap,
+		fsys_t control,
+		mach_port_t *node,
+		mach_msg_type_name_t *realnodePoly,
+		mach_port_t *dotdot,
+		mach_msg_type_name_t *dotdotPoly)
+{
+  return EOPNOTSUPP;
+}
+
+kern_return_t
+S_fsys_getfile (fsys_t fsys,
+		uid_t *uids,
+		u_int nuids,
+		uid_t *gids,
+		u_int ngids,
+		char *filehandle,
+		u_int filehandlelen,
+		mach_port_t *file,
+		mach_msg_type_name_t *filetype)
+{
+  return EOPNOTSUPP;
+}
+
+kern_return_t
+S_fsys_getpriv (fsys_t fsys,
+		mach_port_t *hp,
+		mach_port_t *dm,
+		mach_port_t *tk)
+{
+  return EOPNOTSUPP;
+}
+
+kern_return_t
+S_fsys_init (fsys_t fsys,
+	     mach_port_t reply, mach_msg_type_name_t replytype,
+	     mach_port_t ps,
+	     mach_port_t ah)
+{
+  return EOPNOTSUPP;
+}
+
+
+
+
+/* RPC sent on the bootstrap port.  */
+
+kern_return_t
+S_exec_startup (mach_port_t port,
+		vm_address_t *stack_base, vm_size_t *stack_size,
+		int *flags,
+		char **argvp, u_int *argvlen,
+		char **envpp, u_int *envplen,
+		mach_port_t **dtable, mach_msg_type_name_t *dtablepoly,
+		u_int *dtablesize,
+		mach_port_t **portarray, mach_msg_type_name_t *portpoly,
+		u_int *nports,
+		int **intarray, u_int *nints)
+{
+  struct bootinfo *boot = (struct bootinfo *)port;
+  if ((mach_port_t) boot == execserver || (mach_port_t) boot == fsys)
+    return EOPNOTSUPP;
+
+  *stack_base = boot->stack_base;
+  *stack_size = boot->stack_size;
+
+  *argvp = boot->argv;
+  *argvlen = boot->argvlen;
+
+  *envpp = boot->envp;
+  *envplen = boot->envplen;
+
+  *dtable = boot->dtable;
+  *dtablesize = boot->dtablesize;
+  *dtablepoly = MACH_MSG_TYPE_MOVE_SEND;
+
+  *intarray = boot->intarray;
+  *nints = boot->nints;
+
+  *portarray = boot->portarray;
+  *nports = boot->nports;
+  *portpoly = MACH_MSG_TYPE_MOVE_SEND;
+
+  *flags = boot->flags;
+
+  mach_port_move_member (mach_task_self (), (mach_port_t) boot, 
+			 MACH_PORT_NULL); /* XXX what is this XXX here for? */
+  
+  mach_port_mod_refs (mach_task_self (), (mach_port_t) boot,
+		      MACH_PORT_TYPE_RECEIVE, -1);
+  free (boot);
+
+  return 0;
+}
+
+/* Notice when a receive right has no senders.  Either this is the
+   bootstrap port of a stillborn task, or it is the execserver port itself. */
+
+kern_return_t
+do_mach_notify_no_senders (mach_port_t port, mach_port_mscount_t mscount)
+{
+  if (port != execserver && port != fsys)
+    {
+      /* Free the resources we were saving to give the task
+	 which can no longer ask for them.  */
+
+      struct bootinfo *boot = (struct bootinfo *) port;
+      size_t i;
+
+      vm_deallocate (mach_task_self (),
+		     (vm_address_t) boot->argv, boot->argvlen);
+      vm_deallocate (mach_task_self (),
+		     (vm_address_t) boot->envp, boot->envplen);
+
+      for (i = 0; i < boot->dtablesize; ++i)
+	mach_port_deallocate (mach_task_self (), boot->dtable[i]);
+      for (i = 0; i < boot->nports; ++i)
+	mach_port_deallocate (mach_task_self (), boot->portarray[i]);
+      vm_deallocate (mach_task_self (),
+		     (vm_address_t) boot->portarray,
+		     boot->nports * sizeof (mach_port_t));
+      vm_deallocate (mach_task_self (),
+		     (vm_address_t) boot->intarray,
+		     boot->nints * sizeof (int));
+
+      free (boot);
+    }
+
+  /* Deallocate the request port.  */
+  mach_port_mod_refs (mach_task_self (), port, MACH_PORT_TYPE_RECEIVE, -1);
+
+  mach_port_mod_refs (mach_task_self (), request_portset,
+		      MACH_PORT_TYPE_RECEIVE, -1);
+
+  return KERN_SUCCESS;
+}
+
+/* Sent by the bootstrap filesystem after the other essential
+   servers have been started up.  */
+
+kern_return_t
+S_exec_init (mach_port_t server, auth_t auth, process_t proc)
+{
+  mach_port_t host_priv, dev_master, startup;
+  error_t err;
+
+  if (_hurd_ports[INIT_PORT_PROC].port != MACH_PORT_NULL)
+    /* Can only be done once.  */
+    return EPERM;
+
+  _hurd_port_set (&_hurd_ports[INIT_PORT_PROC], proc);
+  _hurd_port_set (&_hurd_ports[INIT_PORT_AUTH], auth);
+
+  /* Do initial setup with the proc server.  */
+  _hurd_proc_init (save_argv);
+
+  err = get_privileged_ports (&host_priv, &dev_master);
+  if (!err)
+    {
+      proc_register_version (proc, host_priv, "exec", HURD_RELEASE,
+			     exec_version);
+      mach_port_deallocate (mach_task_self (), dev_master);
+      err = proc_getmsgport (proc, 1, &startup);
+      if (!err)
+	{
+	  startup_essential_task (startup, mach_task_self (), MACH_PORT_NULL,
+				  "exec", host_priv);
+	  mach_port_deallocate (mach_task_self (), startup);
+	}
+      mach_port_deallocate (mach_task_self (), host_priv);
+    }
+      
+#if 0
+  /* Have the proc server notify us when the canonical ints and ports change.
+     The notification comes as a normal RPC on the message port, which
+     the C library's signal thread handles.  */
+  __USEPORT (PROC, proc_execdata_notify (port, execserver));
+#endif
+
+  return 0;
+}
+
+
+int
+main (int argc, char **argv)
+{
+  error_t err;
+  mach_port_t boot, dotdot;
+
+  /* XXX */
+  stdout = mach_open_devstream (getdport (1), "w");
+  stderr = mach_open_devstream (getdport (2), "w");
+  /* End XXX */
+
+  save_argv = argv;
+
+#ifdef	BFD
+  /* Put the Mach kernel's idea of what flavor of machine this is into the
+     fake BFD against which architecture compatibility checks are made.  */
+  err = bfd_mach_host_arch_mach (mach_host_self (),
+				 &host_bfd.obj_machine,
+				 &host_bfd.obj_arch);
+#else
+  err = aout_mach_host_machine (mach_host_self (), (int *)&host_machine);
+#endif
+  if (err)
+    return err;
+
+  mach_port_allocate (mach_task_self (), MACH_PORT_RIGHT_RECEIVE, &fsys);
+  mach_port_allocate (mach_task_self (), MACH_PORT_RIGHT_RECEIVE, &execserver);
+
+  task_get_bootstrap_port (mach_task_self (), &boot);
+  fsys_startup (boot, fsys, MACH_MSG_TYPE_MAKE_SEND, &realnode, &dotdot);
+  mach_port_deallocate (mach_task_self (), dotdot); /* Don't care.  */
+
+  mach_port_allocate (mach_task_self (),
+		      MACH_PORT_RIGHT_PORT_SET, &request_portset);
+  mach_port_move_member (mach_task_self (), fsys, request_portset);
+  mach_port_move_member (mach_task_self (), execserver, request_portset);
+
+  while (1)
+    {
+      err = mach_msg_server (request_server, vm_page_size, request_portset);
+      fprintf (stderr, "%s: mach_msg_server: %s\n",
+	       (argv && argv[0]) ? argv[0] : "exec server",
+	       strerror (err));
+    }
+}
+
+/* Nops */
+kern_return_t 
+do_mach_notify_port_deleted (mach_port_t notify,
+			     mach_port_t name)
+{
+  return EOPNOTSUPP;
+}
+
+kern_return_t
+do_mach_notify_msg_accepted (mach_port_t notify,
+			     mach_port_t name)
+{
+  return EOPNOTSUPP;
+}
+
+kern_return_t
+do_mach_notify_port_destroyed (mach_port_t notify,
+			       mach_port_t rights)
+{
+  return EOPNOTSUPP;
+}
+
+kern_return_t
+do_mach_notify_send_once (mach_port_t notify)
+{
+  return EOPNOTSUPP;
+}
+
+kern_return_t
+do_mach_notify_dead_name (mach_port_t notify,
+			  mach_port_t name)
+{
+  return EOPNOTSUPP;
+}
+