Sat Apr 22 14:48:03 1995 Roland McGrath <roland@churchy.gnu.ai.mit.edu>

	* mach/Machrules [interface-library]
 	(LDFLAGS-$(interface-library:lib%=%.so)): New variable, set to
 	-nostdlib.

	* sysdeps/mach/hurd/fork.c: Subfunction `unlockss' removed.  Lock
 	_hurd_siglock only around initial task creation in parent.  Use
 	_hurd_critical_section_unlock at end.  Handle dead name rights
 	properly, and deal with a send right dying while we try to copy
 	it.  For the time being, use assert_perror for kernel and proc RPC
 	failures.

Fri Apr 21 01:10:15 1995  Roland McGrath  <roland@churchy.gnu.ai.mit.edu>

	* extra-lib.mk: Don't include $(o-iterator); construct it by hand
 	using $(object-suffixes-$(lib)) instead.

	* sysdeps/mach/hurd/Makefile (LDLIBS-c.so): New variable.

	* Makerules (lib%.so: lib%_pic.a): Pass $(LDFLAGS-$(notdir $*).so).
	(LDFLAGS-c.so): New variable.

	* resolv/res_init.c (res_init): Don't clobber _res.options with
 	RES_DEFAULT.  If RES_INIT is clear, OR in RES_DEFAULT.

	* hurd/hurd.h: Declare _hurd_startup.
	* hurd/hurdstartup.c: New file.
	* hurd/Makefile (routines): Add hurdstartup.

1 files changed, 302 insertions, 0 deletions

diff --git a/hurd/hurdstartup.c b/hurd/hurdstartup.c
new file mode 100644
index 0000000000..1612859884
--- /dev/null
+++ b/hurd/hurdstartup.c
@@ -0,0 +1,302 @@
+/* Initial program startup for running under the GNU Hurd.
+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 <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <hurd.h>
+#include <hurd/exec.h>
+#include <sysdep.h>
+#include <hurd/threadvar.h>
+#include <unistd.h>
+#include "set-hooks.h"
+#include "hurdmalloc.h"		/* XXX */
+
+mach_port_t *_hurd_init_dtable;
+mach_msg_type_number_t _hurd_init_dtablesize;
+
+unsigned int __hurd_threadvar_max;
+unsigned long int __hurd_threadvar_stack_mask;
+unsigned long int __hurd_threadvar_stack_offset;
+
+/* These are set up by _hurdsig_init.  */
+unsigned long int __hurd_sigthread_stack_base;
+unsigned long int __hurd_sigthread_stack_end;
+unsigned long int *__hurd_sigthread_variables;
+
+vm_address_t _hurd_stack_base;
+vm_size_t _hurd_stack_size;
+
+/* Things that want to be run before _hurd_init or much anything else.
+   Importantly, these are called before anything tries to use malloc.  */
+DEFINE_HOOK (_hurd_preinit_hook, (void));
+
+extern void __mach_init (void);
+extern void __libc_init (int argc, char **argv, char **envp);
+
+void *(*_cthread_init_routine) (void); /* Returns new SP to use.  */
+void (*_cthread_exit_routine) (int status) __attribute__ ((__noreturn__));
+
+int _hurd_split_args (char *, size_t, char **);
+
+/* These communicate values from _hurd_startup to start1,
+   where we cannot use the stack for anything.  */
+struct info
+  {
+    char *args, *env;
+    mach_port_t *portarray;
+    int *intarray;
+    mach_msg_type_number_t argslen, envlen, portarraysize, intarraysize;
+    int flags;
+    char **argv, **envp;
+    int argc;
+    void (*hurd_main) (int, char **, char **,
+		       mach_port_t *, mach_msg_type_number_t,
+		       int *, mach_msg_type_number_t);
+  };
+
+static void start1 (struct info *) __attribute__ ((__noreturn__));
+
+
+/* Entry point.  This is the first thing in the text segment.
+
+   The exec server started the initial thread in our task with this spot the
+   PC, and a stack that is presumably big enough.  We do basic Mach
+   initialization so mig-generated stubs work, and then do an exec_startup
+   RPC on our bootstrap port, to which the exec server responds with the
+   information passed in the exec call, as well as our original bootstrap
+   port, and the base address and size of the preallocated stack.
+
+   If using cthreads, we are given a new stack by cthreads initialization and
+   deallocate the stack set up by the exec server.  On the new stack we call
+   `start1' (above) to do the rest of the startup work.  Since the stack may
+   disappear out from under us in a machine-dependent way, we use a pile of
+   static variables to communicate the information from exec_startup to start1.
+   This is unfortunate but preferable to machine-dependent frobnication to copy
+   the state from the old stack to the new one.  */
+
+void
+_hurd_startup (void **argptr,
+	       void (*main) (int, char **, char **,
+			     mach_port_t *, mach_msg_type_number_t,
+			     int *, mach_msg_type_number_t))
+{
+  error_t err;
+  mach_port_t in_bootstrap;
+  struct info i;
+
+  /* Basic Mach initialization, must be done before RPCs can be done.  */
+  __mach_init ();
+
+  /* Run things that want to do initialization as soon as possible.  We do
+     this before exec_startup so that no out of line data arrives and
+     clutters up the address space before brk initialization.  */
+
+  RUN_HOOK (_hurd_preinit_hook, ());
+
+  if (err = __task_get_special_port (__mach_task_self (), TASK_BOOTSTRAP_PORT,
+				     &in_bootstrap))
+    LOSE;
+
+  if (in_bootstrap != MACH_PORT_NULL)
+    {
+      /* Call the exec server on our bootstrap port and
+	 get all our standard information from it.  */
+
+      i.argslen = i.envlen = 0;
+      _hurd_init_dtablesize = i.portarraysize = i.intarraysize = 0;
+
+      err = __exec_startup (in_bootstrap,
+			    &_hurd_stack_base, &_hurd_stack_size,
+			    &i.flags,
+			    &i.args, &i.argslen, &i.env, &i.envlen,
+			    &_hurd_init_dtable, &_hurd_init_dtablesize,
+			    &i.portarray, &i.portarraysize,
+			    &i.intarray, &i.intarraysize);
+      __mach_port_deallocate (__mach_task_self (), in_bootstrap);
+    }
+
+  if (err || in_bootstrap == MACH_PORT_NULL)
+    {
+      /* Either we have no bootstrap port, or the RPC to the exec server
+	 failed.  Try to snarf the args in the canonical Mach way.
+	 Hopefully either they will be on the stack as expected, or the
+	 stack will be zeros so we don't crash.  Set all our other
+	 variables to have empty information.  */
+
+      /* SNARF_ARGS (ARGPTR, ARGC, ARGV, ENVP) snarfs the arguments and
+	 environment from the stack, assuming they were put there by the
+	 microkernel.  */
+      SNARF_ARGS (argptr, i.argc, i.argv, i.envp);
+
+      i.flags = 0;
+      i.args = i.env = NULL;
+      i.argslen = i.envlen = 0;
+      _hurd_init_dtable = NULL;
+      _hurd_init_dtablesize = 0;
+      i.portarray = NULL;
+      i.portarraysize = 0;
+      i.intarray = NULL;
+      i.intarraysize = 0;
+    }
+  else
+    i.argv = i.envp = NULL;
+
+  i.hurd_main = main;
+
+  /* The user might have defined a value for this, to get more variables.
+     Otherwise it will be zero on startup.  We must make sure it is set
+     properly before before cthreads initialization, so cthreads can know
+     how much space to leave for thread variables.  */
+  if (__hurd_threadvar_max < _HURD_THREADVAR_MAX)
+    __hurd_threadvar_max = _HURD_THREADVAR_MAX;
+
+  /* Do cthreads initialization and switch to the cthread stack.  */
+
+  if (_cthread_init_routine != NULL)
+    CALL_WITH_SP (start1, i, (*_cthread_init_routine) ());
+  else
+    start1 (&i);
+
+  /* Should never get here.  */
+  LOSE;
+}
+
+
+static void
+start1 (struct info *info)
+{
+  register int envc = 0;
+
+  {
+    /* Check if the stack we are now on is different from
+       the one described by _hurd_stack_{base,size}.  */
+
+    char dummy;
+    const vm_address_t newsp = (vm_address_t) &dummy;
+
+    if (_hurd_stack_size != 0 && (newsp < _hurd_stack_base ||
+				  newsp - _hurd_stack_base > _hurd_stack_size))
+      /* The new stack pointer does not intersect with the
+	 stack the exec server set up for us, so free that stack.  */
+      __vm_deallocate (__mach_task_self (),
+		       _hurd_stack_base, _hurd_stack_size);
+  }
+
+  if (__hurd_threadvar_stack_mask == 0)
+    {
+      /* We are not using cthreads, so we will have just a single allocated
+	 area for the per-thread variables of the main user thread.  */
+      unsigned long int i;
+      __hurd_threadvar_stack_offset
+	= (unsigned long int) malloc (__hurd_threadvar_max *
+				      sizeof (unsigned long int));
+      if (__hurd_threadvar_stack_offset == 0)
+	__libc_fatal ("Can't allocate single-threaded per-thread variables.");
+      for (i = 0; i < __hurd_threadvar_max; ++i)
+	((unsigned long int *) __hurd_threadvar_stack_offset)[i] = 0;
+    }
+
+
+  /* Turn the block of null-separated strings we were passed for the
+     arguments and environment into vectors of pointers to strings.  */
+
+  if (! info->argv)
+    {
+      if (info->args)
+	/* Count up the arguments so we can allocate ARGV.  */
+	info->argc = _hurd_split_args (args, argslen, NULL);
+      if (! info->args || info->argc == 0)
+	{
+	  /* No arguments passed; set argv to { NULL }.  */
+	  info->argc = 0;
+	  info->args = NULL;
+	  info->argv = (char **) &info->args;
+	}
+    }
+
+  if (! info->envp)
+    {
+      if (info->env)
+	/* Count up the environment variables so we can allocate ENVP.  */
+	envc = _hurd_split_args (info->env, info->envlen, NULL);
+      if (! info->env || envc == 0)
+	{
+	  /* No environment passed; set __environ to { NULL }.  */
+	  info->env = NULL;
+	  info->envp = (char **) &env;
+	}
+    }
+
+  if (! info->argv)
+    {
+      /* There were some arguments.
+	 Allocate space for the vectors of pointers and fill them in.  */
+      info->argv = __alloca ((info->argc + 1) * sizeof (char *));
+      _hurd_split_args (info->args, info->argslen, info->argv);
+    }
+  
+  if (! info->envp)
+    {
+      /* There was some environment.
+	 Allocate space for the vectors of pointers and fill them in.  */
+      info->envp = __alloca ((envc + 1) * sizeof (char *));
+      _hurd_split_args (info->env, info->envlen, info->envp);
+    }
+
+  (*info->hurd_main) (info->argc, info->argv, info->envp,
+		      info->portarray, info->portarraysize,
+		      info->intarray, info->intarraysize);
+
+  /* Should never get here.  */
+  LOSE;
+}
+
+/* Split ARGSLEN bytes at ARGS into words, breaking at NUL characters.  If
+   ARGV is not a null pointer, store a pointer to the start of each word in
+   ARGV[n], and null-terminate ARGV.  Return the number of words split.  */
+
+int
+_hurd_split_args (char *args, size_t argslen, char **argv)
+{
+  char *p = args;
+  size_t n = argslen;
+  int argc = 0;
+
+  while (n > 0)
+    {
+      char *end = memchr (p, '\0', n);
+
+      if (argv)
+	argv[argc] = p;
+      ++argc;
+
+      if (end == NULL)
+	/* The last argument is unterminated.  */
+	break;
+
+      n -= end + 1 - p;
+      p = end + 1;
+    }
+
+  if (argv)
+    argv[argc] = NULL;
+  return argc;
+}