* Makefile.in: Add cygheap.o.

* child_info.h: Add specific exec class.
* cygheap.h: New file.  Contains declarations for cygwin heap.
* cygheap.cc: New file.  Implements cygwin heap functions.
* dcrt0.cc (quoted): Simplify due to new method for passing arguments between
cygwin programs.
(alloc_stack_hard_way): Attempt to handle overlapped stack.
(dll_crt0_1): Move child_info processing here.  Accomodate new method for
passing arguments between cygwin programs.  Initialize cygwin heap.  Establish
__argc and __argv variables.
(_dll_crt0): Move most of child_info processing to dll_crt0_1.
(cygwin_dll_init): Remove duplication.
* dtable.cc (dtable::extend): Allocate dtable using cygwin heap.
(dtable::build_fhandler): Ditto for fhandler type being constructed.
(dtable::dup_worker): Free new fhandler from cygwin heap on error.
(dtable::select_*): Don't assume that this == fdtab.
(dtable::linearize_fd_array): Delete.
(dtable::delinearize_fd_array): Delete.
(dtable::fixup_after_exec): New file.
(dtable::vfork_child_dup): Use cygwin heap.
(dtable::vfork_parent_restore): Ditto.
* dtable.h: Remove obsolete methods.  Add new method.
* environ.cc (posify): Eliminate already_posix parameter and logic.
(envsize): New function.
(_addenv): Use envsize.
(environ_init): Accept an argument pointing to an existing environment list.
If supplied, allocate space for this in the the program's heap.
* fhandler.cc (fhandler_base::operator =): Move here from fhandler.h.  Use
cygwin heap to allocate filenames.
(fhandler_base::set_name): Allocate/free names from cygwin heap.
(fhandler_base::linearize): Delete.
(fhandler_base::de_linearize): Delete.
(fhandler_base::operator delete): Free from cygwin heap.
(fhandler_base::~fhandler_base): Ditto.
* fhandler.h: Accomodate elimination of *linearize and other changes above.
* fhandler_console.cc (fhandler_console::fixup_after_exec): Rename from
de_linearize.
* heap.h: New file.
* fhandler_tty.cc (fhandler_tty_slave::fhandler_tty_slave): Use cygwin heap for
name.  fhandler_tty::fixup_after_exec): Rename from de_linearize.
* fork.cc (fork): Call cygheap_fixup_in_child.
* heap.cc: Use declarations in heap.h.
* malloc.cc: Sprinkle assertions throughout to catch attempts to free/realloc
something from the cygwin heap.
* path.cc: Throughout, eliminate use of per-thread cache for cwd.  Use cwd_*
functions rather than cwd_* variables to access cwd_win32 and cwd_posix.
(cwd_win32): New function.
(cwd_posix): New function.
(cwd_hash): New function.
(cwd_fixup_after_exec): New function.
* path.h: Accomodate path.cc changes.
* pinfo.cc (pinfo_init): Accept a pointer to an environment table.  Pass this
to environ_init.  Eliminate old 'title' tests.
* pinfo.h: Accomodate above change in argument.
* spawn.cc (struct av): New method for building argv list.
(av::unshift): New method.
(spawn_guts): Allocate everything that the child process needs in the cygwin
heap and pass a pointer to this to the child.  Build argv list using new
method.  Eliminate delinearize stuff.
* thread.h: Eliminate _cwd_win32 and _cwd_posix buffers.
* winsup.h: Eliminate obsolete functions.  Add envsize() declaration.

1 files changed, 232 insertions, 0 deletions

diff --git a/winsup/cygwin/cygheap.cc b/winsup/cygwin/cygheap.cc
new file mode 100644
index 000000000..157c7e478
--- /dev/null
+++ b/winsup/cygwin/cygheap.cc
@@ -0,0 +1,232 @@
+/* cygheap.cc: Cygwin heap manager.
+
+   Copyright 2000 Cygnus Solutions.
+
+   This file is part of Cygwin.
+
+   This software is a copyrighted work licensed under the terms of the
+   Cygwin license.  Please consult the file "CYGWIN_LICENSE" for
+   details. */
+
+#include "winsup.h"
+#include <errno.h>
+#include <fhandler.h>
+#include <assert.h>
+#include "cygheap.h"
+#include "heap.h"
+#include "cygerrno.h"
+
+#define HEAP_START ((void *) 0x12010000)
+inline static void
+init_cheap ()
+{
+  if (!VirtualAlloc (HEAP_START, CYGHEAPSIZE, MEM_RESERVE, PAGE_NOACCESS))
+    api_fatal ("Couldn't reserve space for child's heap, %E");
+  cygheap = cygheap_max = HEAP_START;
+}
+
+#define pagetrunc(x) ((void *) (((DWORD) (x)) & ~(4096 - 1)))
+static void *__stdcall
+_csbrk (int sbs)
+{
+  void *lastheap;
+  if (!cygheap)
+    init_cheap ();
+  lastheap = cygheap_max;
+  (char *) cygheap_max += sbs;
+  void *heapalign = (void *) pagetrunc (lastheap);
+  int needalloc = sbs && ((heapalign == lastheap) || heapalign != pagetrunc (cygheap_max));
+  if (needalloc && !VirtualAlloc (lastheap, (DWORD) sbs, MEM_COMMIT, PAGE_READWRITE))
+    api_fatal ("couldn't commit memory for cygwin heap, %E");
+
+  return lastheap;
+}
+
+/* Copyright (C) 1997, 2000 DJ Delorie */
+
+char *buckets[32] = {0};
+int bucket2size[32] = {0};
+
+static inline int
+size2bucket (int size)
+{
+  int rv = 0x1f;
+  int bit = ~0x10;
+  int i;
+
+  if (size < 4)
+    size = 4;
+  size = (size + 3) & ~3;
+
+  for (i = 0; i < 5; i++)
+    {
+      if (bucket2size[rv & bit] >= size)
+	rv &= bit;
+      bit >>= 1;
+    }
+  return rv;
+}
+
+static inline void
+init_buckets ()
+{
+  unsigned b;
+  for (b = 0; b < 32; b++)
+    bucket2size[b] = (1 << b);
+}
+
+static void *__stdcall
+_cmalloc (int size)
+{
+  char *rv;
+  int b;
+
+  if (bucket2size[0] == 0)
+    init_buckets ();
+
+  b = size2bucket (size);
+  if (buckets[b])
+    {
+      rv = buckets[b];
+      buckets[b] = *(char **) rv;
+      return rv;
+    }
+
+  size = bucket2size[b] + 4;
+  rv = (char *) _csbrk (size);
+
+  *(int *) rv = b;
+  rv += 4;
+  return rv;
+}
+
+static void __stdcall
+_cfree (void *ptr)
+{
+  int b = *(int *) ((char *) ptr - 4);
+  *(char **) ptr = buckets[b];
+  buckets[b] = (char *) ptr;
+}
+
+static void *__stdcall
+_crealloc (void *ptr, int size)
+{
+  char *newptr;
+  int oldsize = bucket2size[*(int *) ((char *) ptr - 4)];
+  if (size <= oldsize)
+    return ptr;
+  newptr = (char *) _cmalloc (size);
+  memcpy (newptr, ptr, oldsize);
+  _cfree (ptr);
+  return newptr;
+}
+
+/* End Copyright (C) 1997 DJ Delorie */
+
+void *cygheap = NULL;
+void *cygheap_max = NULL;
+
+#define sizeof_cygheap(n) ((n) + sizeof(cygheap_entry))
+
+struct cygheap_entry
+  {
+    cygheap_types type;
+    char data[0];
+  };
+
+#define N ((cygheap_entry *) NULL)
+#define tocygheap(s) ((cygheap_entry *) (((char *) (s)) - (int) (N->data)))
+
+void
+cygheap_init ()
+{
+  if (!cygheap)
+    init_cheap ();
+}
+
+extern "C" void __stdcall
+cygheap_fixup_in_child (HANDLE parent)
+{
+  DWORD m, n;
+  n = (DWORD) cygheap_max - (DWORD) cygheap;
+  if (!VirtualAlloc (cygheap, CYGHEAPSIZE, MEM_RESERVE, PAGE_NOACCESS))
+    api_fatal ("Couldn't reserve space for child's heap, %E");
+
+  if (!VirtualAlloc (cygheap, n, MEM_COMMIT, PAGE_READWRITE))
+    api_fatal ("Couldn't allocate space for child's heap %p, size %d, %E",
+	       cygheap, n);
+  m = 0;
+  n = (DWORD) pagetrunc (n + 4095);
+  if (!ReadProcessMemory (parent, cygheap, cygheap, n, &m) ||
+      m != n)
+    api_fatal ("Couldn't read parent's cygwin heap %d bytes != %d, %E",
+	       n, m);
+}
+
+static void *__stdcall
+creturn (cygheap_types x, cygheap_entry * c, int len)
+{
+  if (!c)
+    {
+      __seterrno ();
+      return NULL;
+    }
+  c->type = x;
+  if (cygheap_max < ((char *) c + len))
+    cygheap_max = (char *) c + len;
+  return (void *) c->data;
+}
+
+extern "C" void *__stdcall
+cmalloc (cygheap_types x, DWORD n)
+{
+  cygheap_entry *c;
+  c = (cygheap_entry *) _cmalloc (sizeof_cygheap (n));
+  if (!c)
+    system_printf ("cmalloc returned NULL");
+  return creturn (x, c, n);
+}
+
+extern "C" void *__stdcall
+crealloc (void *s, DWORD n)
+{
+  if (s == NULL)
+    return cmalloc (HEAP_STR, n);	// kludge
+
+  assert (!inheap (s));
+  cygheap_entry *c = tocygheap (s);
+  cygheap_types t = c->type;
+  c = (cygheap_entry *) _crealloc (c, sizeof_cygheap (n));
+  if (!c)
+    system_printf ("crealloc returned NULL");
+  return creturn (t, c, n);
+}
+
+extern "C" void __stdcall
+cfree (void *s)
+{
+  assert (!inheap (s));
+  (void) _cfree (tocygheap (s));
+}
+
+extern "C" void *__stdcall
+ccalloc (cygheap_types x, DWORD n, DWORD size)
+{
+  cygheap_entry *c;
+  c = (cygheap_entry *) _cmalloc (sizeof_cygheap (n * size));
+  if (c)
+    memset (c->data, 0, size);
+  if (!c)
+    system_printf ("ccalloc returned NULL");
+  return creturn (x, c, n);
+}
+
+extern "C" char *__stdcall
+cstrdup (const char *s)
+{
+  char *p = (char *) cmalloc (HEAP_STR, strlen (s) + 1);
+  if (!p)
+    return NULL;
+  strcpy (p, s);
+  return p;
+}