* thread.h (__reent_t::init_clib): Declare new function.

* thread.cc (__reent_t::init_clib): Define new function.
(pthread::thread_init_wrapper): Use __reent_t::init_clib to init local clib
storage and set std{in,out,err} appropriately.
* syscalls.cc (system): Strip signal considerations from here so that they are
not inherited by a child process.
* spawn.cc (spawn_guts): Handle system() signal stuff here.
* winsup.h (_P_SYSTEM): Define.

6 files changed, 5279 insertions, 29 deletions

diff --git a/winsup/cygwin/ChangeLog b/winsup/cygwin/ChangeLog
index 36c2dfe0e86..6bdf4f729db 100644
--- a/winsup/cygwin/ChangeLog
+++ b/winsup/cygwin/ChangeLog
@@ -1,3 +1,17 @@
+2003-09-19  Christopher Faylor  <cgf@redhat.com>
+
+	* thread.h (__reent_t::init_clib): Declare new function.
+	* thread.cc (__reent_t::init_clib): Define new function.
+	(pthread::thread_init_wrapper): Use __reent_t::init_clib to init local
+	clib storage and set std{in,out,err} appropriately.
+
+2003-09-19  Christopher Faylor  <cgf@redhat.com>
+
+	* syscalls.cc (system): Strip signal considerations from here so that
+	they are not inherited by a child process.
+	* spawn.cc (spawn_guts): Handle system() signal stuff here.
+	* winsup.h (_P_SYSTEM): Define.
+
 2003-09-18  Corinna Vinschen  <corinna@vinschen.de>
 
 	* fhandler_tty.cc (fhandler_pty_master::process_slave_output): Handle
diff --git a/winsup/cygwin/pinfo.h b/winsup/cygwin/pinfo.h
new file mode 100644
index 00000000000..78dde835831
--- /dev/null
+++ b/winsup/cygwin/pinfo.h
@@ -0,0 +1,243 @@
+/* pinfo.h: process table info
+
+   Copyright 2000, 2001, 2002 Red Hat, Inc.
+
+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. */
+
+#ifndef _PINFO_H
+#define _PINFO_H
+/* Signal constants (have to define them here, unfortunately) */
+
+enum
+{
+  __SIGFLUSH	    = -2,
+  __SIGSTRACE	    = -1,
+  __SIGCOMMUNE	    =  0,
+  __SIGOFFSET	    =  2
+};
+
+#define PSIZE 63
+
+#include <sys/resource.h>
+#include "thread.h"
+
+struct commune_result
+{
+  char *s;
+  int n;
+};
+
+enum picom
+{
+  PICOM_CMDLINE = 1
+};
+
+extern struct sigaction *global_sigs;
+
+class _pinfo
+{
+public:
+  /* Cygwin pid */
+  pid_t pid;
+
+  /* Various flags indicating the state of the process.  See PID_
+     constants below. */
+  DWORD process_state;
+
+  /* If hProcess is set, it's because it came from a
+     CreateProcess call.  This means it's process relative
+     to the thing which created the process.  That's ok because
+     we only use this handle from the parent. */
+  HANDLE hProcess;
+
+#define PINFO_REDIR_SIZE ((char *) &myself.procinfo->hProcess - (char *) myself.procinfo)
+
+  /* Handle associated with initial Windows pid which started it all. */
+  HANDLE pid_handle;
+
+  /* Handle to the logical parent of this pid. */
+  HANDLE ppid_handle;
+
+  /* Parent process id.  */
+  pid_t ppid;
+
+  /* dwProcessId contains the processid used for sending signals.  It
+   * will be reset in a child process when it is capable of receiving
+   * signals.
+   */
+  DWORD dwProcessId;
+
+  /* Used to spawn a child for fork(), among other things. */
+  char progname[MAX_PATH];
+
+  /* User information.
+     The information is derived from the GetUserName system call,
+     with the name looked up in /etc/passwd and assigned a default value
+     if not found.  This data resides in the shared data area (allowing
+     tasks to store whatever they want here) so it's for informational
+     purposes only. */
+  __uid32_t uid;	/* User ID */
+  __gid32_t gid;	/* Group ID */
+  pid_t pgid;		/* Process group ID */
+  pid_t sid;		/* Session ID */
+  int ctty;		/* Control tty */
+  bool has_pgid_children;/* True if we've forked or spawned children with our GID. */
+
+  /* Resources used by process. */
+  long start_time;
+  struct rusage rusage_self;
+  struct rusage rusage_children;
+
+  /* Non-zero if process was stopped by a signal. */
+  char stopsig;
+
+  /* commune */
+  pid_t hello_pid;
+  HANDLE tothem;
+  HANDLE fromthem;
+
+  void exit (UINT n, bool norecord = 0) __attribute__ ((noreturn, regparm(2)));
+
+  inline void set_has_pgid_children ()
+  {
+    if (pgid == pid)
+      has_pgid_children = 1;
+  }
+
+  inline void set_has_pgid_children (bool val) {has_pgid_children = val;}
+
+  inline struct sigaction& getsig (int sig)
+  {
+    return global_sigs[sig];
+  }
+
+  inline sigset_t& getsigmask ()
+  {
+    return thread2signal ? *thread2signal->sigmask : sig_mask;
+  }
+
+  inline void setsigmask (sigset_t mask)
+  {
+    if (thread2signal)
+      *(thread2signal->sigmask) = mask;
+    sig_mask = mask;
+  }
+
+  inline LONG* getsigtodo (int sig) {return _sigtodo + __SIGOFFSET + sig;}
+
+  inline HANDLE getthread2signal ()
+  {
+    return thread2signal ? thread2signal->win32_obj_id : hMainThread;
+  }
+
+  inline void setthread2signal (void *thr) {thread2signal = (pthread *) thr;}
+  void commune_recv ();
+  commune_result commune_send (DWORD);
+  bool alive ();
+  char *cmdline (size_t &);
+
+  friend void __stdcall set_myself (pid_t, HANDLE);
+
+private:
+  sigset_t sig_mask;		/* one set for everything to ignore. */
+  LONG _sigtodo[NSIG + __SIGOFFSET];
+  pthread *thread2signal;  // NULL means thread any other means a pthread
+  CRITICAL_SECTION lock;
+};
+
+class pinfo
+{
+  HANDLE h;
+  _pinfo *procinfo;
+  bool destroy;
+public:
+  void init (pid_t n, DWORD create = 0, HANDLE h = NULL) __attribute__ ((regparm(3)));
+  pinfo () {}
+  pinfo (_pinfo *x): procinfo (x) {}
+  pinfo (pid_t n) {init (n);}
+  pinfo (pid_t n, int create) {init (n, create);}
+  void release ();
+  ~pinfo ()
+  {
+    if (destroy && procinfo)
+      release ();
+  }
+
+  _pinfo *operator -> () const {return procinfo;}
+  int operator == (pinfo *x) const {return x->procinfo == procinfo;}
+  int operator == (pinfo &x) const {return x.procinfo == procinfo;}
+  int operator == (void *x) const {return procinfo == x;}
+  int operator == (int x) const {return (int) procinfo == (int) x;}
+  int operator == (char *x) const {return (char *) procinfo == x;}
+  _pinfo *operator * () const {return procinfo;}
+  operator _pinfo * () const {return procinfo;}
+  // operator bool () const {return (int) h;}
+#ifndef _SIGPROC_H
+  int remember () {system_printf ("remember is not here"); return 0;}
+#else
+  int remember ()
+  {
+    int res = proc_subproc (PROC_ADDCHILD, (DWORD) this);
+    destroy = res ? false : true;
+    return res;
+  }
+#endif
+  HANDLE shared_handle () {return h;}
+};
+
+#define ISSTATE(p, f)	(!!((p)->process_state & f))
+#define NOTSTATE(p, f)	(!((p)->process_state & f))
+
+class winpids
+{
+  DWORD *pidlist;
+  DWORD npidlist;
+  pinfo *pinfolist;
+  DWORD (winpids::* enum_processes) (bool winpid);
+  DWORD enum_init (bool winpid);
+  DWORD enumNT (bool winpid);
+  DWORD enum9x (bool winpid);
+  void add (DWORD& nelem, bool, DWORD pid);
+  static CRITICAL_SECTION cs;
+public:
+  DWORD npids;
+  inline void reset () { npids = 0; release (); }
+  void set (bool winpid);
+  winpids (int): enum_processes (&winpids::enum_init) { reset (); }
+  winpids (): pidlist (NULL), npidlist (0), pinfolist (NULL),
+	      enum_processes (&winpids::enum_init), npids (0) { set (0); }
+  inline DWORD& winpid (int i) const {return pidlist[i];}
+  inline _pinfo *operator [] (int i) const {return (_pinfo *) pinfolist[i];}
+  ~winpids ();
+  void release ();
+  static void init ();
+};
+
+extern __inline pid_t
+cygwin_pid (pid_t pid)
+{
+  return (pid_t) (wincap.has_negative_pids ()) ? -(int) pid : pid;
+}
+
+void __stdcall pinfo_init (char **, int);
+void __stdcall set_myself (pid_t pid, HANDLE h = NULL);
+extern pinfo myself;
+
+#define _P_VFORK 0
+#define _P_SYSTEM 512
+
+extern void __stdcall pinfo_fixup_after_fork ();
+extern HANDLE hexec_proc;
+
+/* For mmaps across fork(). */
+int __stdcall fixup_mmaps_after_fork (HANDLE parent);
+/* for shm areas across fork (). */
+int __stdcall fixup_shms_after_fork ();
+
+void __stdcall fill_rusage (struct rusage *, HANDLE);
+void __stdcall add_rusage (struct rusage *, struct rusage *);
+#endif /*_PINFO_H*/
diff --git a/winsup/cygwin/spawn.cc b/winsup/cygwin/spawn.cc
new file mode 100644
index 00000000000..7afb3ee0180
--- /dev/null
+++ b/winsup/cygwin/spawn.cc
@@ -0,0 +1,1076 @@
+/* spawn.cc
+
+   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 Red Hat, Inc.
+
+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 <stdlib.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <process.h>
+#include <sys/wait.h>
+#include <limits.h>
+#include <wingdi.h>
+#include <winuser.h>
+#include <ctype.h>
+#include "cygerrno.h"
+#include <sys/cygwin.h>
+#include "security.h"
+#include "path.h"
+#include "fhandler.h"
+#include "dtable.h"
+#include "sigproc.h"
+#include "cygheap.h"
+#include "child_info.h"
+#include "shared_info.h"
+#include "pinfo.h"
+#define NEED_VFORK
+#include "perthread.h"
+#include "registry.h"
+#include "environ.h"
+#include "cygthread.h"
+
+#define LINE_BUF_CHUNK (MAX_PATH * 2)
+
+static suffix_info std_suffixes[] =
+{
+  suffix_info (".exe", 1), suffix_info ("", 1),
+  suffix_info (".com"), suffix_info (".cmd"),
+  suffix_info (".bat"), suffix_info (".dll"),
+  suffix_info (NULL)
+};
+
+HANDLE hExeced;
+DWORD dwExeced;
+
+/* Add .exe to PROG if not already present and see if that exists.
+   If not, return PROG (converted from posix to win32 rules if necessary).
+   The result is always BUF.
+
+   Returns (possibly NULL) suffix */
+
+static const char *
+perhaps_suffix (const char *prog, path_conv& buf)
+{
+  char *ext;
+
+  debug_printf ("prog '%s'", prog);
+  buf.check (prog, PC_SYM_FOLLOW | PC_FULL, std_suffixes);
+
+  if (!buf.exists () || buf.isdir ())
+    ext = NULL;
+  else if (buf.known_suffix)
+    ext = (char *) buf + (buf.known_suffix - buf.get_win32 ());
+  else
+    ext = strchr (buf, '\0');
+
+  debug_printf ("buf %s, suffix found '%s'", (char *) buf, ext);
+  return ext;
+}
+
+/* Find an executable name, possibly by appending known executable
+   suffixes to it.  The win32-translated name is placed in 'buf'.
+   Any found suffix is returned in known_suffix.
+
+   If the file is not found and !null_if_not_found then the win32 version
+   of name is placed in buf and returned.  Otherwise the contents of buf
+   is undefined and NULL is returned.  */
+
+const char * __stdcall
+find_exec (const char *name, path_conv& buf, const char *mywinenv,
+	   unsigned opt, const char **known_suffix)
+{
+  const char *suffix = "";
+  debug_printf ("find_exec (%s)", name);
+  const char *retval = buf;
+  char tmp[MAX_PATH];
+  const char *posix = (opt & FE_NATIVE) ? NULL : name;
+  bool has_slash = strchr (name, '/');
+
+  /* Check to see if file can be opened as is first.
+     Win32 systems always check . first, but PATH may not be set up to
+     do this. */
+  if ((has_slash || opt & FE_CWD)
+      && (suffix = perhaps_suffix (name, buf)) != NULL)
+    {
+      if (posix && !has_slash)
+	{
+	  tmp[0] = '.';
+	  tmp[1] = '/';
+	  strcpy (tmp + 2, name);
+	  posix = tmp;
+	}
+      goto out;
+    }
+
+  win_env *winpath;
+  const char *path;
+  const char *posix_path;
+
+  /* Return the error condition if this is an absolute path or if there
+     is no PATH to search. */
+  if (strchr (name, '/') || strchr (name, '\\') ||
+      isdrive (name) ||
+      !(winpath = getwinenv (mywinenv)) ||
+      !(path = winpath->get_native ()) ||
+      *path == '\0')
+    goto errout;
+
+  debug_printf ("%s%s", mywinenv, path);
+
+  posix = (opt & FE_NATIVE) ? NULL : tmp;
+  posix_path = winpath->get_posix () - 1;
+  /* Iterate over the specified path, looking for the file with and
+     without executable extensions. */
+  do
+    {
+      posix_path++;
+      char *eotmp = strccpy (tmp, &path, ';');
+      /* An empty path or '.' means the current directory, but we've
+	 already tried that.  */
+      if (opt & FE_CWD && (tmp[0] == '\0' || (tmp[0] == '.' && tmp[1] == '\0')))
+	continue;
+
+      *eotmp++ = '\\';
+      strcpy (eotmp, name);
+
+      debug_printf ("trying %s", tmp);
+
+      if ((suffix = perhaps_suffix (tmp, buf)) != NULL)
+	{
+	  if (posix == tmp)
+	    {
+	      eotmp = strccpy (tmp, &posix_path, ':');
+	      if (eotmp == tmp)
+		*eotmp++ = '.';
+	      *eotmp++ = '/';
+	      strcpy (eotmp, name);
+	    }
+	  goto out;
+	}
+    }
+  while (*path && *++path && (posix_path = strchr (posix_path, ':')));
+
+ errout:
+  posix = NULL;
+  /* Couldn't find anything in the given path.
+     Take the appropriate action based on null_if_not_found. */
+  if (opt & FE_NNF)
+    retval = NULL;
+  else if (opt & FE_NATIVE)
+    buf.check (name);
+  else
+    retval = name;
+
+ out:
+  if (posix)
+    buf.set_path (posix);
+  debug_printf ("%s = find_exec (%s)", (char *) buf, name);
+  if (known_suffix)
+    *known_suffix = suffix ?: strchr (buf, '\0');
+  return retval;
+}
+
+/* Utility for spawn_guts.  */
+
+static HANDLE
+handle (int n, int direction)
+{
+  fhandler_base *fh = cygheap->fdtab[n];
+
+  if (!fh)
+    return INVALID_HANDLE_VALUE;
+  if (fh->get_close_on_exec ())
+    return INVALID_HANDLE_VALUE;
+  if (direction == 0)
+    return fh->get_handle ();
+  return fh->get_output_handle ();
+}
+
+int
+iscmd (const char *argv0, const char *what)
+{
+  int n;
+  n = strlen (argv0) - strlen (what);
+  if (n >= 2 && argv0[1] != ':')
+    return 0;
+  return n >= 0 && strcasematch (argv0 + n, what) &&
+	 (n == 0 || isdirsep (argv0[n - 1]));
+}
+
+class linebuf
+{
+ public:
+  size_t ix;
+  char *buf;
+  size_t alloced;
+  linebuf () : ix (0), buf (NULL), alloced (0) {}
+  ~linebuf () {if (buf) free (buf);}
+  void add (const char *what, int len);
+  void add (const char *what) {add (what, strlen (what));}
+  void prepend (const char *what, int len);
+};
+
+void
+linebuf::add (const char *what, int len)
+{
+  size_t newix;
+  if ((newix = ix + len) >= alloced || !buf)
+    {
+      alloced += LINE_BUF_CHUNK + newix;
+      buf = (char *) realloc (buf, alloced + 1);
+    }
+  memcpy (buf + ix, what, len);
+  ix = newix;
+  buf[ix] = '\0';
+}
+
+void
+linebuf::prepend (const char *what, int len)
+{
+  int buflen;
+  size_t newix;
+  if ((newix = ix + len) >= alloced)
+    {
+      alloced += LINE_BUF_CHUNK + newix;
+      buf = (char *) realloc (buf, alloced + 1);
+      buf[ix] = '\0';
+    }
+  if ((buflen = strlen (buf)))
+      memmove (buf + len, buf, buflen + 1);
+  else
+      buf[newix] = '\0';
+  memcpy (buf, what, len);
+  ix = newix;
+}
+
+class av
+{
+  char **argv;
+  int calloced;
+ public:
+  int error;
+  int argc;
+  av (int ac, const char * const *av) : calloced (0), error (false), argc (ac)
+  {
+    argv = (char **) cmalloc (HEAP_1_ARGV, (argc + 5) * sizeof (char *));
+    memcpy (argv, av, (argc + 1) * sizeof (char *));
+  }
+  ~av ()
+  {
+    if (argv)
+      {
+	for (int i = 0; i < calloced; i++)
+	  if (argv[i])
+	    cfree (argv[i]);
+	cfree (argv);
+      }
+  }
+  int unshift (const char *what, int conv = 0);
+  operator char **() {return argv;}
+  void all_calloced () {calloced = argc;}
+  void replace0_maybe (const char *arg0)
+  {
+    /* Note: Assumes that argv array has not yet been "unshifted" */
+    if (!calloced
+	&& (argv[0] = cstrdup1 (arg0)))
+      calloced = true;
+    else
+      error = errno;
+  }
+  void dup_maybe (int i)
+  {
+    if (i >= calloced
+	&& !(argv[i] = cstrdup1 (argv[i])))
+      error = errno;
+  }
+  void dup_all ()
+  {
+    for (int i = calloced; i < argc; i++)
+      if (!(argv[i] = cstrdup1 (argv[i])))
+	error = errno;
+  }
+};
+
+int
+av::unshift (const char *what, int conv)
+{
+  char **av;
+  av = (char **) crealloc (argv, (argc + 2) * sizeof (char *));
+  if (!av)
+    return 0;
+
+  argv = av;
+  memmove (argv + 1, argv, (argc + 1) * sizeof (char *));
+  char buf[MAX_PATH + 1];
+  if (conv)
+    {
+      cygwin_conv_to_posix_path (what, buf);
+      char *p = strchr (buf, '\0') - 4;
+      if (p > buf && strcasematch (p, ".exe"))
+	*p = '\0';
+      what = buf;
+    }
+  if (!(*argv = cstrdup1 (what)))
+    error = errno;
+  argc++;
+  calloced++;
+  return 1;
+}
+
+static int __stdcall
+spawn_guts (const char * prog_arg, const char *const *argv,
+	    const char *const envp[], int mode)
+{
+  BOOL rc;
+  pid_t cygpid;
+  sigframe thisframe (mainthread);
+
+  MALLOC_CHECK;
+
+  if (prog_arg == NULL)
+    {
+      syscall_printf ("prog_arg is NULL");
+      set_errno (EINVAL);
+      return -1;
+    }
+
+  syscall_printf ("spawn_guts (%d, %.9500s)", mode, prog_arg);
+
+  if (argv == NULL)
+    {
+      syscall_printf ("argv is NULL");
+      set_errno (EINVAL);
+      return -1;
+    }
+
+  path_conv real_path;
+
+  linebuf one_line;
+
+  STARTUPINFO si = {0, NULL, NULL, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL};
+
+  child_info_spawn ciresrv;
+  si.lpReserved2 = (LPBYTE) &ciresrv;
+  si.cbReserved2 = sizeof (ciresrv);
+
+  DWORD chtype;
+  if (mode != _P_OVERLAY)
+    chtype = PROC_SPAWN;
+  else
+    chtype = PROC_EXEC;
+
+  HANDLE subproc_ready;
+  if (chtype != PROC_EXEC)
+    subproc_ready = NULL;
+  else
+    {
+      subproc_ready = CreateEvent (&sec_all, TRUE, FALSE, NULL);
+      ProtectHandleINH (subproc_ready);
+    }
+
+  init_child_info (chtype, &ciresrv, (mode == _P_OVERLAY) ? myself->pid : 1,
+		   subproc_ready);
+  if (!DuplicateHandle (hMainProc, hMainProc, hMainProc, &ciresrv.parent, 0, 1,
+			DUPLICATE_SAME_ACCESS))
+     {
+       system_printf ("couldn't create handle to myself for child, %E");
+       return -1;
+     }
+
+  ciresrv.moreinfo = (cygheap_exec_info *) ccalloc (HEAP_1_EXEC, 1, sizeof (cygheap_exec_info));
+  ciresrv.moreinfo->old_title = NULL;
+
+  /* CreateProcess takes one long string that is the command line (sigh).
+     We need to quote any argument that has whitespace or embedded "'s.  */
+
+  int ac;
+  for (ac = 0; argv[ac]; ac++)
+    /* nothing */;
+
+  av newargv (ac, argv);
+
+  int null_app_name = 0;
+  if (ac == 3 && argv[1][0] == '/' && argv[1][1] == 'c' &&
+      (iscmd (argv[0], "command.com") || iscmd (argv[0], "cmd.exe")))
+    {
+      real_path.check (prog_arg);
+      one_line.add ("\"");
+      if (!real_path.error)
+	one_line.add (real_path);
+      else
+	one_line.add (argv[0]);
+      one_line.add ("\"");
+      one_line.add (" ");
+      one_line.add (argv[1]);
+      one_line.add (" ");
+      one_line.add (argv[2]);
+      strcpy (real_path, argv[0]);
+      null_app_name = 1;
+      goto skip_arg_parsing;
+    }
+
+  const char *ext;
+  if ((ext = perhaps_suffix (prog_arg, real_path)) == NULL)
+    {
+      set_errno (ENOENT);
+      return -1;
+    }
+
+  MALLOC_CHECK;
+
+  /* If the file name ends in either .exe, .com, .bat, or .cmd we assume
+     that it is NOT a script file */
+  while (*ext == '\0')
+    {
+      HANDLE hnd = CreateFile (real_path, GENERIC_READ,
+			       FILE_SHARE_READ | FILE_SHARE_WRITE,
+			       &sec_none_nih, OPEN_EXISTING,
+			       FILE_ATTRIBUTE_NORMAL, 0);
+      if (hnd == INVALID_HANDLE_VALUE)
+	{
+	  __seterrno ();
+	  return -1;
+	}
+
+      DWORD done;
+
+      char buf[2 * MAX_PATH + 1];
+      buf[0] = buf[1] = buf[2] = buf[sizeof (buf) - 1] = '\0';
+      if (!ReadFile (hnd, buf, sizeof (buf) - 1, &done, 0))
+	{
+	  CloseHandle (hnd);
+	  __seterrno ();
+	  return -1;
+	}
+
+      CloseHandle (hnd);
+
+      if (buf[0] == 'M' && buf[1] == 'Z')
+	break;
+
+      debug_printf ("%s is a script", (char *) real_path);
+
+      char *pgm, *arg1;
+
+      if (buf[0] != '#' || buf[1] != '!')
+	{
+	  pgm = (char *) "/bin/sh";
+	  arg1 = NULL;
+	}
+      else
+	{
+	  char *ptr;
+	  pgm = buf + 2;
+	  pgm += strspn (pgm, " \t");
+	  for (ptr = pgm, arg1 = NULL;
+	       *ptr && *ptr != '\r' && *ptr != '\n';
+	       ptr++)
+	    if (!arg1 && (*ptr == ' ' || *ptr == '\t'))
+	      {
+		/* Null terminate the initial command and step over
+		   any additional white space.  If we've hit the
+		   end of the line, exit the loop.  Otherwise, we've
+		   found the first argument. Position the current
+		   pointer on the last known white space. */
+		*ptr = '\0';
+		char *newptr = ptr + 1;
+		newptr += strspn (newptr, " \t");
+		if (!*newptr || *newptr == '\r' || *newptr == '\n')
+		  break;
+		arg1 = newptr;
+		ptr = newptr - 1;
+	      }
+
+	  *ptr = '\0';
+	}
+
+      /* Replace argv[0] with the full path to the script if this is the
+	 first time through the loop. */
+      newargv.replace0_maybe (prog_arg);
+
+      /* pointers:
+       * pgm	interpreter name
+       * arg1	optional string
+       */
+      if (arg1)
+	newargv.unshift (arg1);
+
+      /* FIXME: This should not be using FE_NATIVE.  It should be putting
+	 the posix path on the argv list. */
+      find_exec (pgm, real_path, "PATH=", FE_NATIVE, &ext);
+      newargv.unshift (real_path, 1);
+    }
+
+  if (real_path.iscygexec ())
+    newargv.dup_all ();
+  else
+    {
+      for (int i = 0; i < newargv.argc; i++)
+	{
+	  char *p = NULL;
+	  const char *a;
+
+	  newargv.dup_maybe (i);
+	  a = i ? newargv[i] : (char *) real_path;
+	  int len = strlen (a);
+	  if (len != 0 && !strpbrk (a, " \t\n\r\""))
+	    one_line.add (a, len);
+	  else
+	    {
+	      one_line.add ("\"", 1);
+	      /* Handle embedded special characters " and \.
+		 A " is always preceded by a \.
+		 A \ is not special unless it precedes a ".  If it does,
+		 then all preceding \'s must be doubled to avoid having
+		 the Windows command line parser interpret the \ as quoting
+		 the ".  This rule applies to a string of \'s before the end
+		 of the string, since cygwin/windows uses a " to delimit the
+		 argument. */
+	      for (; (p = strpbrk (a, "\"\\")); a = ++p)
+		{
+		  one_line.add (a, p - a);
+		  /* Find length of string of backslashes */
+		  int n = strspn (p, "\\");
+		  if (!n)
+		    one_line.add ("\\\"", 2);	/* No backslashes, so it must be a ".
+						   The " has to be protected with a backslash. */
+		  else
+		    {
+		      one_line.add (p, n);	/* Add the run of backslashes */
+		      /* Need to double up all of the preceding
+			 backslashes if they precede a quote or EOS. */
+		      if (!p[n] || p[n] == '"')
+			one_line.add (p, n);
+		      p += n - 1;		/* Point to last backslash */
+		    }
+		}
+	      if (*a)
+		one_line.add (a);
+	      one_line.add ("\"", 1);
+	    }
+	  MALLOC_CHECK;
+	  one_line.add (" ", 1);
+	  MALLOC_CHECK;
+	}
+
+      MALLOC_CHECK;
+      if (one_line.ix)
+	one_line.buf[one_line.ix - 1] = '\0';
+      else
+	one_line.add ("", 1);
+      MALLOC_CHECK;
+    }
+
+  char *envblock;
+  newargv.all_calloced ();
+  if (newargv.error)
+    {
+      set_errno (newargv.error);
+      return -1;
+    }
+
+  ciresrv.moreinfo->argc = newargv.argc;
+  ciresrv.moreinfo->argv = newargv;
+  ciresrv.hexec_proc = hexec_proc;
+
+  if (mode != _P_OVERLAY ||
+      !DuplicateHandle (hMainProc, myself.shared_handle (), hMainProc,
+			&ciresrv.moreinfo->myself_pinfo, 0,
+			TRUE, DUPLICATE_SAME_ACCESS))
+    ciresrv.moreinfo->myself_pinfo = NULL;
+
+ skip_arg_parsing:
+  PROCESS_INFORMATION pi = {NULL, 0, 0, 0};
+  si.lpReserved = NULL;
+  si.lpDesktop = NULL;
+  si.dwFlags = STARTF_USESTDHANDLES;
+  si.hStdInput = handle (0, 0); /* Get input handle */
+  si.hStdOutput = handle (1, 1); /* Get output handle */
+  si.hStdError = handle (2, 1); /* Get output handle */
+  si.cb = sizeof (si);
+
+  int flags = CREATE_DEFAULT_ERROR_MODE | GetPriorityClass (hMainProc);
+
+  if (mode == _P_DETACH || !set_console_state_for_spawn ())
+    flags |= DETACHED_PROCESS;
+  if (mode != _P_OVERLAY)
+    flags |= CREATE_SUSPENDED;
+
+  /* Some file types (currently only sockets) need extra effort in the
+     parent after CreateProcess and before copying the datastructures
+     to the child. So we have to start the child in suspend state,
+     unfortunately, to avoid a race condition. */
+  if (cygheap->fdtab.need_fixup_before ())
+    flags |= CREATE_SUSPENDED;
+
+
+  const char *runpath = null_app_name ? NULL : (const char *) real_path;
+
+  syscall_printf ("null_app_name %d (%s, %.9500s)", null_app_name, runpath, one_line.buf);
+
+  void *newheap;
+  /* Preallocated buffer for `sec_user' call */
+  char sa_buf[1024];
+
+  cygbench ("spawn-guts");
+
+  cygheap->fdtab.set_file_pointers_for_exec ();
+  cygheap->user.deimpersonate ();
+  /* When ruid != euid we create the new process under the current original
+     account and impersonate in child, this way maintaining the different
+     effective vs. real ids.
+     FIXME: If ruid != euid and ruid != orig_uid we currently give
+     up on ruid. The new process will have ruid == euid. */
+  if (!cygheap->user.issetuid ()
+      || (cygheap->user.orig_uid == cygheap->user.real_uid
+	  && cygheap->user.orig_gid == cygheap->user.real_gid
+	  && !cygheap->user.groups.issetgroups ()))
+    {
+      PSECURITY_ATTRIBUTES sec_attribs = sec_user_nih (sa_buf);
+      ciresrv.moreinfo->envp = build_env (envp, envblock, ciresrv.moreinfo->envc,
+					  real_path.iscygexec ());
+      newheap = cygheap_setup_for_child (&ciresrv, cygheap->fdtab.need_fixup_before ());
+      rc = CreateProcess (runpath,	/* image name - with full path */
+			  one_line.buf,	/* what was passed to exec */
+			  sec_attribs,	/* process security attrs */
+			  sec_attribs,	/* thread security attrs */
+			  TRUE,		/* inherit handles from parent */
+			  flags,
+			  envblock,	/* environment */
+			  0,		/* use current drive/directory */
+			  &si,
+			  &pi);
+    }
+  else
+    {
+      PSID sid = cygheap->user.sid ();
+
+      /* Set security attributes with sid */
+      PSECURITY_ATTRIBUTES sec_attribs = sec_user_nih (sa_buf, sid);
+
+      /* allow the child to interact with our window station/desktop */
+      HANDLE hwst, hdsk;
+      SECURITY_INFORMATION dsi = DACL_SECURITY_INFORMATION;
+      DWORD n;
+      char wstname[1024];
+      char dskname[1024];
+
+      hwst = GetProcessWindowStation ();
+      SetUserObjectSecurity (hwst, &dsi, get_null_sd ());
+      GetUserObjectInformation (hwst, UOI_NAME, wstname, 1024, &n);
+      hdsk = GetThreadDesktop (GetCurrentThreadId ());
+      SetUserObjectSecurity (hdsk, &dsi, get_null_sd ());
+      GetUserObjectInformation (hdsk, UOI_NAME, dskname, 1024, &n);
+      strcat (wstname, "\\");
+      strcat (wstname, dskname);
+      si.lpDesktop = wstname;
+
+      ciresrv.moreinfo->envp = build_env (envp, envblock, ciresrv.moreinfo->envc,
+					  real_path.iscygexec ());
+      newheap = cygheap_setup_for_child (&ciresrv, cygheap->fdtab.need_fixup_before ());
+      rc = CreateProcessAsUser (cygheap->user.token (),
+		       runpath,		/* image name - with full path */
+		       one_line.buf,	/* what was passed to exec */
+		       sec_attribs,     /* process security attrs */
+		       sec_attribs,     /* thread security attrs */
+		       TRUE,		/* inherit handles from parent */
+		       flags,
+		       envblock,	/* environment */
+		       0,		/* use current drive/directory */
+		       &si,
+		       &pi);
+    }
+
+  /* FIXME: There is a small race here */
+
+  sigset_t old_mask;
+  _sig_func_ptr oldint = (_sig_func_ptr) NULL;
+  _sig_func_ptr oldquit = (_sig_func_ptr) NULL;
+  if (mode == _P_SYSTEM)
+    {
+      sigset_t child_block;
+      oldint = signal (SIGINT, SIG_IGN);
+      oldquit = signal (SIGQUIT, SIG_IGN);
+      sigemptyset (&child_block);
+      sigaddset (&child_block, SIGCHLD);
+      (void) sigprocmask (SIG_BLOCK, &child_block, &old_mask);
+    }
+
+  /* Restore impersonation. In case of _P_OVERLAY this isn't
+     allowed since it would overwrite child data. */
+  if (mode != _P_OVERLAY)
+      cygheap->user.reimpersonate ();
+
+  MALLOC_CHECK;
+  if (envblock)
+    free (envblock);
+  MALLOC_CHECK;
+
+  /* Set errno now so that debugging messages from it appear before our
+     final debugging message [this is a general rule for debugging
+     messages].  */
+  if (!rc)
+    {
+      __seterrno ();
+      syscall_printf ("CreateProcess failed, %E");
+      if (subproc_ready)
+	ForceCloseHandle (subproc_ready);
+      cygheap_setup_for_child_cleanup (newheap, &ciresrv, 0);
+      return -1;
+    }
+
+  /* Fixup the parent datastructure if needed and resume the child's
+     main thread. */
+  if (!cygheap->fdtab.need_fixup_before ())
+    cygheap_setup_for_child_cleanup (newheap, &ciresrv, 0);
+  else
+    {
+      cygheap->fdtab.fixup_before_exec (pi.dwProcessId);
+      cygheap_setup_for_child_cleanup (newheap, &ciresrv, 1);
+      if (mode == _P_OVERLAY)
+	{
+	  ResumeThread (pi.hThread);
+	  cygthread::terminate ();
+	}
+    }
+
+  if (mode != _P_OVERLAY)
+    cygpid = cygwin_pid (pi.dwProcessId);
+  else
+    cygpid = myself->pid;
+
+  /* We print the original program name here so the user can see that too.  */
+  syscall_printf ("%d = spawn_guts (%s, %.9500s)",
+		  rc ? cygpid : (unsigned int) -1, prog_arg, one_line.buf);
+
+  /* Name the handle similarly to proc_subproc. */
+  ProtectHandle1 (pi.hProcess, childhProc);
+
+  if (mode == _P_OVERLAY)
+    {
+      /* These are both duplicated in the child code.  We do this here,
+	 primarily for strace. */
+      strace.execing = 1;
+      hExeced = pi.hProcess;
+      dwExeced = pi.dwProcessId;
+      strcpy (myself->progname, real_path);
+      close_all_files ();
+    }
+  else
+    {
+      myself->set_has_pgid_children ();
+      ProtectHandle (pi.hThread);
+      pinfo child (cygpid, 1);
+      if (!child)
+	{
+	  set_errno (EAGAIN);
+	  syscall_printf ("-1 = spawnve (), process table full");
+	  return -1;
+	}
+      child->dwProcessId = pi.dwProcessId;
+      child->hProcess = pi.hProcess;
+      child.remember ();
+      strcpy (child->progname, real_path);
+      /* FIXME: This introduces an unreferenced, open handle into the child.
+	 The purpose is to keep the pid shared memory open so that all of
+	 the fields filled out by child.remember do not disappear and so there
+	 is not a brief period during which the pid is not available.
+	 However, we should try to find another way to do this eventually. */
+      (void) DuplicateHandle (hMainProc, child.shared_handle (), pi.hProcess,
+			      NULL, 0, 0, DUPLICATE_SAME_ACCESS);
+      /* Start the child running */
+      ResumeThread (pi.hThread);
+    }
+
+  ForceCloseHandle (pi.hThread);
+
+  sigproc_printf ("spawned windows pid %d", pi.dwProcessId);
+
+  DWORD res;
+  BOOL exited;
+
+  res = 0;
+  exited = FALSE;
+  MALLOC_CHECK;
+  if (mode == _P_OVERLAY)
+    {
+      int nwait = 3;
+      HANDLE waitbuf[3] = {pi.hProcess, signal_arrived, subproc_ready};
+      for (int i = 0; i < 100; i++)
+	{
+	  switch (WaitForMultipleObjects (nwait, waitbuf, FALSE, INFINITE))
+	    {
+	    case WAIT_OBJECT_0:
+	      sigproc_printf ("subprocess exited");
+	      DWORD exitcode;
+	      if (!GetExitCodeProcess (pi.hProcess, &exitcode))
+		exitcode = 1;
+	      res |= exitcode;
+	      exited = TRUE;
+	      break;
+	    case WAIT_OBJECT_0 + 1:
+	      sigproc_printf ("signal arrived");
+	      reset_signal_arrived ();
+	      continue;
+	    case WAIT_OBJECT_0 + 2:
+	      if (my_parent_is_alive ())
+		res |= EXIT_REPARENTING;
+	      else if (!myself->ppid_handle)
+		{
+		  nwait = 2;
+		  sigproc_terminate ();
+		  continue;
+		}
+	      break;
+	    case WAIT_FAILED:
+	      system_printf ("wait failed: nwait %d, pid %d, winpid %d, %E",
+			     nwait, myself->pid, myself->dwProcessId);
+	      system_printf ("waitbuf[0] %p %d", waitbuf[0],
+			     WaitForSingleObject (waitbuf[0], 0));
+	      system_printf ("waitbuf[1] %p = %d", waitbuf[1],
+			     WaitForSingleObject (waitbuf[1], 0));
+	      system_printf ("waitbuf[w] %p = %d", waitbuf[2],
+			     WaitForSingleObject (waitbuf[2], 0));
+	      set_errno (ECHILD);
+	      try_to_debug ();
+	      return -1;
+	    }
+	  break;
+	}
+
+      ForceCloseHandle (subproc_ready);
+
+      sigproc_printf ("res = %x", res);
+
+      if (res & EXIT_REPARENTING)
+	{
+	  /* Try to reparent child process.
+	   * Make handles to child available to parent process and exit with
+	   * EXIT_REPARENTING status. Wait() syscall in parent will then wait
+	   * for newly created child.
+	   */
+	  HANDLE oldh = myself->hProcess;
+	  HANDLE h = myself->ppid_handle;
+	  sigproc_printf ("parent handle %p", h);
+	  int rc = DuplicateHandle (hMainProc, pi.hProcess, h, &myself->hProcess,
+				    0, FALSE, DUPLICATE_SAME_ACCESS);
+	  sigproc_printf ("%d = DuplicateHandle, oldh %p, newh %p",
+			  rc, oldh, myself->hProcess);
+	  if (!rc && my_parent_is_alive ())
+	    {
+	      system_printf ("Reparent failed, parent handle %p, %E", h);
+	      system_printf ("my dwProcessId %d, myself->dwProcessId %d",
+			     GetCurrentProcessId (), myself->dwProcessId);
+	      system_printf ("old hProcess %p, hProcess %p", oldh, myself->hProcess);
+	    }
+	}
+
+    }
+
+  MALLOC_CHECK;
+
+  switch (mode)
+    {
+    case _P_OVERLAY:
+      ForceCloseHandle1 (pi.hProcess, childhProc);
+      proc_terminate ();
+      myself->exit (res, 1);
+      break;
+    case _P_WAIT:
+    case _P_SYSTEM:
+      waitpid (cygpid, (int *) &res, 0);
+      if (mode == _P_SYSTEM)
+	{
+	  signal (SIGINT, oldint);
+	  signal (SIGQUIT, oldquit);
+	  sigprocmask (SIG_SETMASK, &old_mask, NULL);
+	}
+      break;
+    case _P_DETACH:
+      res = 0;	/* Lose all memory of this child. */
+      break;
+    case _P_NOWAIT:
+    case _P_NOWAITO:
+    case _P_VFORK:
+      res = cygpid;
+      break;
+    default:
+      break;
+    }
+
+  return (int) res;
+}
+
+extern "C" int
+cwait (int *result, int pid, int)
+{
+  return waitpid (pid, result, 0);
+}
+
+/*
+ * Helper function for spawn runtime calls.
+ * Doesn't search the path.
+ */
+
+extern "C" int
+spawnve (int mode, const char *path, const char *const *argv,
+	 const char *const *envp)
+{
+  int ret;
+  vfork_save *vf = vfork_storage.val ();
+
+  if (vf != NULL && (vf->pid < 0) && mode == _P_OVERLAY)
+    mode = _P_NOWAIT;
+  else
+    vf = NULL;
+
+  syscall_printf ("spawnve (%s, %s, %x)", path, argv[0], envp);
+
+  switch (mode)
+    {
+    case _P_OVERLAY:
+      /* We do not pass _P_SEARCH_PATH here. execve doesn't search PATH.*/
+      /* Just act as an exec if _P_OVERLAY set. */
+      spawn_guts (path, argv, envp, mode);
+      /* Errno should be set by spawn_guts.  */
+      ret = -1;
+      break;
+    case _P_VFORK:
+    case _P_NOWAIT:
+    case _P_NOWAITO:
+    case _P_WAIT:
+    case _P_DETACH:
+    case _P_SYSTEM:
+      subproc_init ();
+      ret = spawn_guts (path, argv, envp, mode);
+      if (vf)
+	{
+	  debug_printf ("longjmping due to vfork");
+	  if (ret < 0)
+	    vf->restore_exit (ret);
+	  else
+	    vf->restore_pid (ret);
+	}
+      break;
+    default:
+      set_errno (EINVAL);
+      ret = -1;
+      break;
+    }
+  return ret;
+}
+
+/*
+ * spawn functions as implemented in the MS runtime library.
+ * Most of these based on (and copied from) newlib/libc/posix/execXX.c
+ */
+
+extern "C" int
+spawnl (int mode, const char *path, const char *arg0, ...)
+{
+  int i;
+  va_list args;
+  const char *argv[256];
+
+  va_start (args, arg0);
+  argv[0] = arg0;
+  i = 1;
+
+  do
+      argv[i] = va_arg (args, const char *);
+  while (argv[i++] != NULL);
+
+  va_end (args);
+
+  return spawnve (mode, path, (char * const  *) argv, cur_environ ());
+}
+
+extern "C" int
+spawnle (int mode, const char *path, const char *arg0, ...)
+{
+  int i;
+  va_list args;
+  const char * const *envp;
+  const char *argv[256];
+
+  va_start (args, arg0);
+  argv[0] = arg0;
+  i = 1;
+
+  do
+    argv[i] = va_arg (args, const char *);
+  while (argv[i++] != NULL);
+
+  envp = va_arg (args, const char * const *);
+  va_end (args);
+
+  return spawnve (mode, path, (char * const *) argv, (char * const *) envp);
+}
+
+extern "C" int
+spawnlp (int mode, const char *path, const char *arg0, ...)
+{
+  int i;
+  va_list args;
+  const char *argv[256];
+
+  va_start (args, arg0);
+  argv[0] = arg0;
+  i = 1;
+
+  do
+      argv[i] = va_arg (args, const char *);
+  while (argv[i++] != NULL);
+
+  va_end (args);
+
+  return spawnvpe (mode, path, (char * const *) argv, cur_environ ());
+}
+
+extern "C" int
+spawnlpe (int mode, const char *path, const char *arg0, ...)
+{
+  int i;
+  va_list args;
+  const char * const *envp;
+  const char *argv[256];
+
+  va_start (args, arg0);
+  argv[0] = arg0;
+  i = 1;
+
+  do
+    argv[i] = va_arg (args, const char *);
+  while (argv[i++] != NULL);
+
+  envp = va_arg (args, const char * const *);
+  va_end (args);
+
+  return spawnvpe (mode, path, (char * const *) argv, envp);
+}
+
+extern "C" int
+spawnv (int mode, const char *path, const char * const *argv)
+{
+  return spawnve (mode, path, argv, cur_environ ());
+}
+
+extern "C" int
+spawnvp (int mode, const char *path, const char * const *argv)
+{
+  return spawnvpe (mode, path, argv, cur_environ ());
+}
+
+extern "C" int
+spawnvpe (int mode, const char *file, const char * const *argv,
+					     const char * const *envp)
+{
+  path_conv buf;
+  return spawnve (mode, find_exec (file, buf), argv, envp);
+}
diff --git a/winsup/cygwin/syscalls.cc b/winsup/cygwin/syscalls.cc
index 702c7a5e2b9..a938c101d5f 100644
--- a/winsup/cygwin/syscalls.cc
+++ b/winsup/cygwin/syscalls.cc
@@ -1450,21 +1450,6 @@ done:
   return res;
 }
 
-struct system_cleanup_args
-{
-  _sig_func_ptr oldint, oldquit;
-  sigset_t old_mask;
-};
-
-static void system_cleanup (void *args)
-{
-  struct system_cleanup_args *cleanup_args = (struct system_cleanup_args *) args;
-
-  signal (SIGINT, cleanup_args->oldint);
-  signal (SIGQUIT, cleanup_args->oldquit);
-  (void) sigprocmask (SIG_SETMASK, &cleanup_args->old_mask, 0);
-}
-
 extern "C" int
 system (const char *cmdstring)
 {
@@ -1476,34 +1461,22 @@ system (const char *cmdstring)
   sigframe thisframe (mainthread);
   int res;
   const char* command[4];
-  struct system_cleanup_args cleanup_args;
-  sigset_t child_block;
 
   if (cmdstring == (const char *) NULL)
-	return 1;
-
-  cleanup_args.oldint = signal (SIGINT, SIG_IGN);
-  cleanup_args.oldquit = signal (SIGQUIT, SIG_IGN);
-  sigemptyset (&child_block);
-  sigaddset (&child_block, SIGCHLD);
-  (void) sigprocmask (SIG_BLOCK, &child_block, &cleanup_args.old_mask);
+    return 1;
 
   command[0] = "sh";
   command[1] = "-c";
   command[2] = cmdstring;
   command[3] = (const char *) NULL;
 
-  pthread_cleanup_push (system_cleanup, (void *) &cleanup_args);
-
-  if ((res = spawnvp (_P_WAIT, "sh", command)) == -1)
+  if ((res = spawnvp (_P_SYSTEM, "sh", command)) == -1)
     {
       // when exec fails, return value should be as if shell
       // executed exit (127)
       res = 127;
     }
 
-  pthread_cleanup_pop (1);
-
   return res;
 }
 
diff --git a/winsup/cygwin/thread.cc b/winsup/cygwin/thread.cc
new file mode 100644
index 00000000000..6931b39146f
--- /dev/null
+++ b/winsup/cygwin/thread.cc
@@ -0,0 +1,3236 @@
+/* thread.cc: Locking and threading module functions
+
+   Copyright 1998, 1999, 2000, 2001, 2002, 2003 Red Hat, Inc.
+
+   Originally written by Marco Fuykschot <marco@ddi.nl>
+   Substantialy enhanced by Robert Collins <rbtcollins@hotmail.com>
+
+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. */
+
+/* Implementation overview and caveats:
+
+   Win32 puts some contraints on what can and cannot be implemented.  Where
+   possible we work around those contrainsts.  Where we cannot work around
+   the constraints we either pretend to be conformant, or return an error
+   code.
+
+   Some caveats: PROCESS_SHARED objects while they pretend to be process
+   shared, may not actually work.  Some test cases are needed to determine
+   win32's behaviour.  My suspicion is that the win32 handle needs to be
+   opened with different flags for proper operation.
+
+   R.Collins, April 2001.  */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include "winsup.h"
+#include <limits.h>
+#include "cygerrno.h"
+#include <assert.h>
+#include <stdlib.h>
+#include <syslog.h>
+#include "pinfo.h"
+#include "perprocess.h"
+#include "security.h"
+#include <semaphore.h>
+#include <stdio.h>
+#include <sys/timeb.h>
+
+extern int threadsafe;
+
+extern "C" struct _reent *
+__getreent ()
+{
+  struct __reent_t *_r =
+    (struct __reent_t *) MT_INTERFACE->reent_key.get ();
+
+  if (_r == 0)
+    {
+#ifdef _CYG_THREAD_FAILSAFE
+      system_printf ("local thread storage not inited");
+#endif
+      /* Return _impure_ptr as long as MTinterface is not initialized */
+      return _impure_ptr;
+    }
+
+  return _r->_clib;
+}
+
+struct _winsup_t *
+_reent_winsup ()
+{
+  struct __reent_t *_r =
+    (struct __reent_t *) MT_INTERFACE->reent_key.get ();
+
+  if (_r == 0)
+    {
+#ifdef _CYG_THREAD_FAILSAFE
+      system_printf ("local thread storage not inited");
+#endif
+      return NULL;
+    }
+
+  return _r->_winsup;
+}
+
+bool
+native_mutex::init ()
+{
+  theHandle = CreateMutex (&sec_none_nih, FALSE, NULL);
+  if (!theHandle)
+    {
+      debug_printf ("CreateMutex failed. %E");
+      return false;
+    }
+  return true;
+}
+
+bool
+native_mutex::lock ()
+{
+  DWORD waitResult = WaitForSingleObject (theHandle, INFINITE);
+  if (waitResult != WAIT_OBJECT_0)
+    {
+      system_printf ("Received unexpected wait result %d on handle %p, %E", waitResult, theHandle);
+      return false;
+    }
+  return true;
+}
+
+void
+native_mutex::unlock ()
+{
+  if (!ReleaseMutex (theHandle))
+    system_printf ("Received a unexpected result releasing mutex. %E");
+}
+
+inline LPCRITICAL_SECTION
+ResourceLocks::Lock (int _resid)
+{
+#ifdef _CYG_THREAD_FAILSAFE
+  if (!inited)
+    system_printf ("lock called before initialization");
+
+  thread_printf
+    ("Get Resource lock %d ==> %p for %p , real : %d , threadid %d ", _resid,
+     &lock, user_data, myself->pid, GetCurrentThreadId ());
+#endif
+  return &lock;
+}
+
+void
+SetResourceLock (int _res_id, int _mode, const char *_function)
+{
+#ifdef _CYG_THREAD_FAILSAFE
+  thread_printf ("Set resource lock %d mode %d for %s start",
+		 _res_id, _mode, _function);
+#endif
+  EnterCriticalSection (user_data->resourcelocks->Lock (_res_id));
+
+#ifdef _CYG_THREAD_FAILSAFE
+  user_data->resourcelocks->owner = GetCurrentThreadId ();
+  user_data->resourcelocks->count++;
+#endif
+}
+
+void
+ReleaseResourceLock (int _res_id, int _mode, const char *_function)
+{
+#ifdef _CYG_THREAD_FAILSAFE
+  thread_printf ("Release resource lock %d mode %d for %s done", _res_id,
+		 _mode, _function);
+
+  AssertResourceOwner (_res_id, _mode);
+  user_data->resourcelocks->count--;
+  if (user_data->resourcelocks->count == 0)
+    user_data->resourcelocks->owner = 0;
+#endif
+
+  LeaveCriticalSection (user_data->resourcelocks->Lock (_res_id));
+}
+
+#ifdef _CYG_THREAD_FAILSAFE
+void
+AssertResourceOwner (int _res_id, int _mode)
+{
+
+  thread_printf
+    ("Assert Resource lock %d ==> for %p , real : %d , threadid %d count %d owner %d",
+     _res_id, user_data, myself->pid, GetCurrentThreadId (),
+     user_data->resourcelocks->count, user_data->resourcelocks->owner);
+  if (user_data && (user_data->resourcelocks->owner != GetCurrentThreadId ()))
+    system_printf ("assertion failed, not the resource owner");
+}
+
+#endif
+
+void
+ResourceLocks::Init ()
+{
+  InitializeCriticalSection (&lock);
+  inited = true;
+
+#ifdef _CYG_THREAD_FAILSAFE
+  owner = 0;
+  count = 0;
+#endif
+
+  thread_printf ("lock %p inited by %p , %d", &lock, user_data, myself->pid);
+}
+
+void
+ResourceLocks::Delete ()
+{
+  if (inited)
+    {
+      thread_printf ("Close Resource Locks %p ", &lock);
+      DeleteCriticalSection (&lock);
+      inited = false;
+    }
+}
+
+void
+MTinterface::Init ()
+{
+  reents._clib = _impure_ptr;
+  reents._winsup = &winsup_reent;
+  winsup_reent._process_logmask = LOG_UPTO (LOG_DEBUG);
+  reent_key.set (&reents);
+
+  pthread_mutex::init_mutex ();
+  pthread_cond::init_mutex ();
+  pthread_rwlock::init_mutex ();
+}
+
+void
+MTinterface::fixup_before_fork (void)
+{
+  pthread_key::fixup_before_fork ();
+}
+
+/* This function is called from a single threaded process */
+void
+MTinterface::fixup_after_fork (void)
+{
+  pthread_key::fixup_after_fork ();
+
+#ifndef __SIGNALS_ARE_MULTITHREADED__
+  /* As long as the signal handling not multithreaded
+     switch reents storage back to _impure_ptr for the mainthread
+     to support fork from threads other than the mainthread */
+  reents._clib = _impure_ptr;
+  reents._winsup = &winsup_reent;
+  winsup_reent._process_logmask = LOG_UPTO (LOG_DEBUG);
+  reent_key.set (&reents);
+#endif
+
+  threadcount = 1;
+  pthread::init_mainthread ();
+
+  pthread::fixup_after_fork ();
+  pthread_mutex::fixup_after_fork ();
+  pthread_cond::fixup_after_fork ();
+  pthread_rwlock::fixup_after_fork ();
+  semaphore::fixup_after_fork ();
+}
+
+/* pthread calls */
+
+/* static methods */
+void
+pthread::init_mainthread ()
+{
+  pthread *thread = get_tls_self_pointer ();
+  if (!thread)
+    {
+      thread = new pthread ();
+      if (!thread)
+	api_fatal ("failed to create mainthread object");
+    }
+
+  thread->init_current_thread ();
+}
+
+pthread *
+pthread::self ()
+{
+  pthread *thread = get_tls_self_pointer ();
+  if (thread)
+    return thread;
+  return pthread_null::get_null_pthread ();
+}
+
+void
+pthread::set_tls_self_pointer (pthread *thisThread)
+{
+  MT_INTERFACE->thread_self_key.set (thisThread);
+}
+
+pthread *
+pthread::get_tls_self_pointer ()
+{
+  return (pthread *) MT_INTERFACE->thread_self_key.get ();
+}
+
+
+
+List<pthread> pthread::threads;
+
+/* member methods */
+pthread::pthread ():verifyable_object (PTHREAD_MAGIC), win32_obj_id (0),
+		    running (false), suspended (false),
+		    cancelstate (0), canceltype (0), cancel_event (0),
+		    joiner (NULL), next (NULL), cleanup_stack (NULL)
+{
+  if (this != pthread_null::get_null_pthread ())
+    threads.insert (this);
+}
+
+pthread::~pthread ()
+{
+  if (win32_obj_id)
+    CloseHandle (win32_obj_id);
+  if (cancel_event)
+    CloseHandle (cancel_event);
+
+  if (this != pthread_null::get_null_pthread ())
+    threads.remove (this);
+}
+
+void
+pthread::set_thread_id_to_current ()
+{
+  thread_id = GetCurrentThreadId ();
+}
+
+void
+pthread::precreate (pthread_attr *newattr)
+{
+  pthread_mutex *verifyable_mutex_obj = &mutex;
+
+  /* already running ? */
+  if (win32_obj_id)
+    return;
+
+  if (newattr)
+    {
+      attr.joinable = newattr->joinable;
+      attr.contentionscope = newattr->contentionscope;
+      attr.inheritsched = newattr->inheritsched;
+      attr.stacksize = newattr->stacksize;
+    }
+
+  if (!pthread_mutex::is_good_object (&verifyable_mutex_obj))
+    {
+      thread_printf ("New thread object access mutex is not valid. this %p",
+		     this);
+      magic = 0;
+      return;
+    }
+  /* Change the mutex type to NORMAL to speed up mutex operations */
+  mutex.type = PTHREAD_MUTEX_NORMAL;
+
+  cancel_event = ::CreateEvent (&sec_none_nih, TRUE, FALSE, NULL);
+  if (!cancel_event)
+    {
+      system_printf ("couldn't create cancel event, this %p LastError %E", this);
+      /* we need the event for correct behaviour */
+      magic = 0;
+      return;
+    }
+}
+
+void
+pthread::create (void *(*func) (void *), pthread_attr *newattr,
+		 void *threadarg)
+{
+  precreate (newattr);
+  if (!magic)
+      return;
+   function = func;
+   arg = threadarg;
+
+  win32_obj_id = ::CreateThread (&sec_none_nih, attr.stacksize,
+				(LPTHREAD_START_ROUTINE) thread_init_wrapper,
+				this, CREATE_SUSPENDED, &thread_id);
+
+  if (!win32_obj_id)
+    {
+      thread_printf ("CreateThread failed: this %p LastError %E", this);
+      magic = 0;
+    }
+  else {
+      postcreate ();
+      ResumeThread (win32_obj_id);
+  }
+}
+
+void
+pthread::postcreate ()
+{
+  running = true;
+
+  InterlockedIncrement (&MT_INTERFACE->threadcount);
+  /* FIXME: set the priority appropriately for system contention scope */
+  if (attr.inheritsched == PTHREAD_EXPLICIT_SCHED)
+    {
+      /* FIXME: set the scheduling settings for the new thread */
+      /* sched_thread_setparam (win32_obj_id, attr.schedparam); */
+    }
+}
+
+void
+pthread::exit (void *value_ptr)
+{
+  class pthread *thread = this;
+
+  // run cleanup handlers
+  pop_all_cleanup_handlers ();
+
+  pthread_key::run_all_destructors ();
+
+  mutex.lock ();
+  // cleanup if thread is in detached state and not joined
+  if (equal (joiner, thread))
+    delete this;
+  else
+    {
+      running = false;
+      return_ptr = value_ptr;
+      mutex.unlock ();
+    }
+
+  if (InterlockedDecrement (&MT_INTERFACE->threadcount) == 0)
+    ::exit (0);
+  else
+    ExitThread (0);
+}
+
+int
+pthread::cancel (void)
+{
+  class pthread *thread = this;
+  class pthread *self = pthread::self ();
+
+  mutex.lock ();
+
+  if (!running)
+    {
+      mutex.unlock ();
+      return 0;
+    }
+
+  if (canceltype == PTHREAD_CANCEL_DEFERRED ||
+      cancelstate == PTHREAD_CANCEL_DISABLE)
+    {
+      // cancel deferred
+      mutex.unlock ();
+      SetEvent (cancel_event);
+      return 0;
+    }
+
+  else if (equal (thread, self))
+    {
+      mutex.unlock ();
+      cancel_self ();
+      return 0; // Never reached
+    }
+
+  // cancel asynchronous
+  SuspendThread (win32_obj_id);
+  if (WaitForSingleObject (win32_obj_id, 0) == WAIT_TIMEOUT)
+    {
+      CONTEXT context;
+      context.ContextFlags = CONTEXT_CONTROL;
+      GetThreadContext (win32_obj_id, &context);
+      context.Eip = (DWORD) pthread::static_cancel_self;
+      SetThreadContext (win32_obj_id, &context);
+    }
+  mutex.unlock ();
+  ResumeThread (win32_obj_id);
+
+  return 0;
+/*
+  TODO: insert  pthread_testcancel into the required functions
+  the required function list is: *indicates done, X indicates not present in cygwin.
+aio_suspend ()
+*close ()
+*creat ()
+fcntl ()
+fsync ()
+getmsg ()
+getpmsg ()
+lockf ()
+mq_receive ()
+mq_send ()
+msgrcv ()
+msgsnd ()
+msync ()
+nanosleep ()
+open ()
+*pause ()
+poll ()
+pread ()
+*pthread_cond_timedwait ()
+*pthread_cond_wait ()
+*pthread_join ()
+*pthread_testcancel ()
+putmsg ()
+putpmsg ()
+pwrite ()
+read ()
+readv ()
+select ()
+*sem_wait ()
+*sigpause ()
+*sigsuspend ()
+sigtimedwait ()
+sigwait ()
+sigwaitinfo ()
+*sleep ()
+*system ()
+tcdrain ()
+*usleep ()
+*wait ()
+*wait3()
+waitid ()
+*waitpid ()
+write ()
+writev ()
+
+the optional list is:
+catclose ()
+catgets ()
+catopen ()
+closedir ()
+closelog ()
+ctermid ()
+dbm_close ()
+dbm_delete ()
+dbm_fetch ()
+dbm_nextkey ()
+dbm_open ()
+dbm_store ()
+dlclose ()
+dlopen ()
+endgrent ()
+endpwent ()
+endutxent ()
+fclose ()
+fcntl ()
+fflush ()
+fgetc ()
+fgetpos ()
+fgets ()
+fgetwc ()
+fgetws ()
+fopen ()
+fprintf ()
+fputc ()
+fputs ()
+fputwc ()
+fputws ()
+fread ()
+freopen ()
+fscanf ()
+fseek ()
+fseeko ()
+fsetpos ()
+ftell ()
+ftello ()
+ftw ()
+fwprintf ()
+fwrite ()
+fwscanf ()
+getc ()
+getc_unlocked ()
+getchar ()
+getchar_unlocked ()
+getcwd ()
+getdate ()
+getgrent ()
+getgrgid ()
+getgrgid_r ()
+getgrnam ()
+getgrnam_r ()
+getlogin ()
+getlogin_r ()
+getpwent ()
+*getpwnam ()
+*getpwnam_r ()
+*getpwuid ()
+*getpwuid_r ()
+gets ()
+getutxent ()
+getutxid ()
+getutxline ()
+getw ()
+getwc ()
+getwchar ()
+getwd ()
+glob ()
+iconv_close ()
+iconv_open ()
+ioctl ()
+lseek ()
+mkstemp ()
+nftw ()
+opendir ()
+openlog ()
+pclose ()
+perror ()
+popen ()
+printf ()
+putc ()
+putc_unlocked ()
+putchar ()
+putchar_unlocked ()
+puts ()
+pututxline ()
+putw ()
+putwc ()
+putwchar ()
+readdir ()
+readdir_r ()
+remove ()
+rename ()
+rewind ()
+rewinddir ()
+scanf ()
+seekdir ()
+semop ()
+setgrent ()
+setpwent ()
+setutxent ()
+strerror ()
+syslog ()
+tmpfile ()
+tmpnam ()
+ttyname ()
+ttyname_r ()
+ungetc ()
+ungetwc ()
+unlink ()
+vfprintf ()
+vfwprintf ()
+vprintf ()
+vwprintf ()
+wprintf ()
+wscanf ()
+
+Note, that for fcntl (), for any value of the cmd argument.
+
+And we must not introduce cancellation points anywhere else that's part of the posix or
+opengroup specs.
+ */
+}
+
+void
+pthread::testcancel (void)
+{
+  if (cancelstate == PTHREAD_CANCEL_DISABLE)
+    return;
+
+  if (WaitForSingleObject (cancel_event, 0) == WAIT_OBJECT_0)
+    cancel_self ();
+}
+
+void
+pthread::static_cancel_self (void)
+{
+  pthread::self ()->cancel_self ();
+}
+
+
+DWORD
+pthread::cancelable_wait (HANDLE object, DWORD timeout, const bool do_cancel)
+{
+  DWORD res;
+  HANDLE wait_objects[2];
+  pthread_t thread = self ();
+
+  if (!is_good_object (&thread) || thread->cancelstate == PTHREAD_CANCEL_DISABLE)
+    return WaitForSingleObject (object, timeout);
+
+  // Do not change the wait order
+  // The object must have higher priority than the cancel event,
+  // because WaitForMultipleObjects will return the smallest index
+  // if both objects are signaled
+  wait_objects[0] = object;
+  wait_objects[1] = thread->cancel_event;
+
+  res = WaitForMultipleObjects (2, wait_objects, FALSE, timeout);
+  if (do_cancel && res == WAIT_CANCELED)
+    pthread::static_cancel_self ();
+  return res;
+}
+
+int
+pthread::setcancelstate (int state, int *oldstate)
+{
+  int result = 0;
+
+  mutex.lock ();
+
+  if (state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE)
+    result = EINVAL;
+  else
+    {
+      if (oldstate)
+	*oldstate = cancelstate;
+      cancelstate = state;
+    }
+
+  mutex.unlock ();
+
+  return result;
+}
+
+int
+pthread::setcanceltype (int type, int *oldtype)
+{
+  int result = 0;
+
+  mutex.lock ();
+
+  if (type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS)
+    result = EINVAL;
+  else
+    {
+      if (oldtype)
+	*oldtype = canceltype;
+      canceltype = type;
+    }
+
+  mutex.unlock ();
+
+  return result;
+}
+
+void
+pthread::push_cleanup_handler (__pthread_cleanup_handler *handler)
+{
+  if (this != self ())
+    // TODO: do it?
+    api_fatal ("Attempt to push a cleanup handler across threads");
+  handler->next = cleanup_stack;
+  InterlockedExchangePointer (&cleanup_stack, handler);
+}
+
+void
+pthread::pop_cleanup_handler (int const execute)
+{
+  if (this != self ())
+    // TODO: send a signal or something to the thread ?
+    api_fatal ("Attempt to execute a cleanup handler across threads");
+
+  mutex.lock ();
+
+  if (cleanup_stack != NULL)
+    {
+      __pthread_cleanup_handler *handler = cleanup_stack;
+
+      if (execute)
+	(*handler->function) (handler->arg);
+      cleanup_stack = handler->next;
+    }
+
+  mutex.unlock ();
+}
+
+void
+pthread::pop_all_cleanup_handlers ()
+{
+  while (cleanup_stack != NULL)
+    pop_cleanup_handler (1);
+}
+
+void
+pthread::cancel_self ()
+{
+  exit (PTHREAD_CANCELED);
+}
+
+DWORD
+pthread::get_thread_id ()
+{
+  return thread_id;
+}
+
+void
+pthread::init_current_thread ()
+{
+  cancel_event = ::CreateEvent (&sec_none_nih, TRUE, FALSE, NULL);
+  if (!DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
+			GetCurrentProcess (), &win32_obj_id,
+			0, FALSE, DUPLICATE_SAME_ACCESS))
+    win32_obj_id = NULL;
+  set_thread_id_to_current ();
+  set_tls_self_pointer (this);
+}
+
+void
+pthread::_fixup_after_fork ()
+{
+  /* set thread to not running if it is not the forking thread */
+  if (this != pthread::self ())
+    {
+      magic = 0;
+      running = false;
+      win32_obj_id = NULL;
+      cancel_event = NULL;
+    }
+}
+
+/* static members */
+bool
+pthread_attr::is_good_object (pthread_attr_t const *attr)
+{
+  if (verifyable_object_isvalid (attr, PTHREAD_ATTR_MAGIC) != VALID_OBJECT)
+    return false;
+  return true;
+}
+
+/* instance members */
+
+pthread_attr::pthread_attr ():verifyable_object (PTHREAD_ATTR_MAGIC),
+joinable (PTHREAD_CREATE_JOINABLE), contentionscope (PTHREAD_SCOPE_PROCESS),
+inheritsched (PTHREAD_INHERIT_SCHED), stacksize (0)
+{
+  schedparam.sched_priority = 0;
+}
+
+pthread_attr::~pthread_attr ()
+{
+}
+
+bool
+pthread_condattr::is_good_object (pthread_condattr_t const *attr)
+{
+  if (verifyable_object_isvalid (attr, PTHREAD_CONDATTR_MAGIC) != VALID_OBJECT)
+    return false;
+  return true;
+}
+
+pthread_condattr::pthread_condattr ():verifyable_object
+  (PTHREAD_CONDATTR_MAGIC), shared (PTHREAD_PROCESS_PRIVATE)
+{
+}
+
+pthread_condattr::~pthread_condattr ()
+{
+}
+
+List<pthread_cond> pthread_cond::conds;
+
+/* This is used for cond creation protection within a single process only */
+native_mutex NO_COPY pthread_cond::cond_initialization_lock;
+
+/* We can only be called once.
+   TODO: (no rush) use a non copied memory section to
+   hold an initialization flag.  */
+void
+pthread_cond::init_mutex ()
+{
+  if (!cond_initialization_lock.init ())
+    api_fatal ("Could not create win32 Mutex for pthread cond static initializer support.");
+}
+
+pthread_cond::pthread_cond (pthread_condattr *attr) :
+  verifyable_object (PTHREAD_COND_MAGIC),
+  shared (0), waiting (0), pending (0), sem_wait (NULL),
+  mtx_cond(NULL), next (NULL)
+{
+  pthread_mutex *verifyable_mutex_obj;
+
+  if (attr)
+    if (attr->shared != PTHREAD_PROCESS_PRIVATE)
+      {
+	magic = 0;
+	return;
+      }
+
+  verifyable_mutex_obj = &mtx_in;
+  if (!pthread_mutex::is_good_object (&verifyable_mutex_obj))
+    {
+      thread_printf ("Internal cond mutex is not valid. this %p", this);
+      magic = 0;
+      return;
+    }
+  /*
+   * Change the mutex type to NORMAL.
+   * This mutex MUST be of type normal
+  */
+  mtx_in.type = PTHREAD_MUTEX_NORMAL;
+
+  verifyable_mutex_obj = &mtx_out;
+  if (!pthread_mutex::is_good_object (&verifyable_mutex_obj))
+    {
+      thread_printf ("Internal cond mutex is not valid. this %p", this);
+      magic = 0;
+      return;
+    }
+  /* Change the mutex type to NORMAL to speed up mutex operations */
+  mtx_out.type = PTHREAD_MUTEX_NORMAL;
+
+  sem_wait = ::CreateSemaphore (&sec_none_nih, 0, LONG_MAX, NULL);
+  if (!sem_wait)
+    {
+      debug_printf ("CreateSemaphore failed. %E");
+      magic = 0;
+      return;
+    }
+
+  conds.insert (this);
+}
+
+pthread_cond::~pthread_cond ()
+{
+  if (sem_wait)
+    CloseHandle (sem_wait);
+
+  conds.remove (this);
+}
+
+void
+pthread_cond::unblock (const bool all)
+{
+  unsigned long releaseable;
+
+  /*
+   * Block outgoing threads (and avoid simultanous unblocks)
+   */
+  mtx_out.lock ();
+
+  releaseable = waiting - pending;
+  if (releaseable)
+    {
+      unsigned long released;
+
+      if (!pending)
+	{
+	  /*
+	   * Block incoming threads until all waiting threads are released.
+	   */
+	  mtx_in.lock ();
+
+	  /*
+	   * Calculate releaseable again because threads can enter until
+	   * the semaphore has been taken, but they can not leave, therefore pending
+	   * is unchanged and releaseable can only get higher
+	   */
+	  releaseable = waiting - pending;
+	}
+
+      released = all ? releaseable : 1;
+      pending += released;
+      /*
+       * Signal threads
+       */
+      ::ReleaseSemaphore (sem_wait, released, NULL);
+    }
+
+  /*
+   * And let the threads release.
+   */
+  mtx_out.unlock ();
+}
+
+int
+pthread_cond::wait (pthread_mutex_t mutex, DWORD dwMilliseconds)
+{
+  DWORD rv;
+
+  mtx_in.lock ();
+  if (InterlockedIncrement ((long *)&waiting) == 1)
+    mtx_cond = mutex;
+  else if (mtx_cond != mutex)
+    {
+      InterlockedDecrement ((long *)&waiting);
+      mtx_in.unlock ();
+      return EINVAL;
+    }
+  mtx_in.unlock ();
+
+  /*
+   * Release the mutex and wait on semaphore
+   */
+  ++mutex->condwaits;
+  mutex->unlock ();
+
+  rv = pthread::cancelable_wait (sem_wait, dwMilliseconds, false);
+
+  mtx_out.lock ();
+
+  if (rv != WAIT_OBJECT_0)
+    {
+      /*
+       * It might happen that a signal is sent while the thread got canceled
+       * or timed out. Try to take one.
+       * If the thread gets one than a signal|broadcast is in progress.
+       */
+      if (WaitForSingleObject (sem_wait, 0) == WAIT_OBJECT_0)
+	/*
+	 * thread got cancelled ot timed out while a signalling is in progress.
+	 * Set wait result back to signaled
+	 */
+	rv = WAIT_OBJECT_0;
+    }
+
+  InterlockedDecrement ((long *)&waiting);
+
+  if (rv == WAIT_OBJECT_0 && --pending == 0)
+    /*
+     * All signaled threads are released,
+     * new threads can enter Wait
+     */
+    mtx_in.unlock ();
+
+  mtx_out.unlock ();
+
+  mutex->lock ();
+  --mutex->condwaits;
+
+  if (rv == WAIT_CANCELED)
+    pthread::static_cancel_self ();
+  else if (rv == WAIT_TIMEOUT)
+    return ETIMEDOUT;
+
+  return 0;
+}
+
+void
+pthread_cond::_fixup_after_fork ()
+{
+  waiting = pending = 0;
+  mtx_cond = NULL;
+
+  /* Unlock eventually locked mutexes */
+  mtx_in.unlock ();
+  mtx_out.unlock ();
+
+  sem_wait = ::CreateSemaphore (&sec_none_nih, 0, LONG_MAX, NULL);
+  if (!sem_wait)
+    api_fatal ("pthread_cond::_fixup_after_fork () failed to recreate win32 semaphore");
+}
+
+bool
+pthread_rwlockattr::is_good_object (pthread_rwlockattr_t const *attr)
+{
+  if (verifyable_object_isvalid (attr, PTHREAD_RWLOCKATTR_MAGIC) != VALID_OBJECT)
+    return false;
+  return true;
+}
+
+pthread_rwlockattr::pthread_rwlockattr ():verifyable_object
+  (PTHREAD_RWLOCKATTR_MAGIC), shared (PTHREAD_PROCESS_PRIVATE)
+{
+}
+
+pthread_rwlockattr::~pthread_rwlockattr ()
+{
+}
+
+List<pthread_rwlock> pthread_rwlock::rwlocks;
+
+/* This is used for rwlock creation protection within a single process only */
+native_mutex NO_COPY pthread_rwlock::rwlock_initialization_lock;
+
+/* We can only be called once.
+   TODO: (no rush) use a non copied memory section to
+   hold an initialization flag.  */
+void
+pthread_rwlock::init_mutex ()
+{
+  if (!rwlock_initialization_lock.init ())
+    api_fatal ("Could not create win32 Mutex for pthread rwlock static initializer support.");
+}
+
+pthread_rwlock::pthread_rwlock (pthread_rwlockattr *attr) :
+  verifyable_object (PTHREAD_RWLOCK_MAGIC),
+  shared (0), waiting_readers (0), waiting_writers (0), writer (NULL),
+  readers (NULL), mtx (NULL), cond_readers (NULL), cond_writers (NULL),
+  next (NULL)
+{
+  pthread_mutex *verifyable_mutex_obj = &mtx;
+  pthread_cond *verifyable_cond_obj;
+
+  if (attr)
+    if (attr->shared != PTHREAD_PROCESS_PRIVATE)
+      {
+	magic = 0;
+	return;
+      }
+
+  if (!pthread_mutex::is_good_object (&verifyable_mutex_obj))
+    {
+      thread_printf ("Internal rwlock mutex is not valid. this %p", this);
+      magic = 0;
+      return;
+    }
+  /* Change the mutex type to NORMAL to speed up mutex operations */
+  mtx.type = PTHREAD_MUTEX_NORMAL;
+
+  verifyable_cond_obj = &cond_readers;
+  if (!pthread_cond::is_good_object (&verifyable_cond_obj))
+    {
+      thread_printf ("Internal rwlock readers cond is not valid. this %p", this);
+      magic = 0;
+      return;
+    }
+
+  verifyable_cond_obj = &cond_writers;
+  if (!pthread_cond::is_good_object (&verifyable_cond_obj))
+    {
+      thread_printf ("Internal rwlock writers cond is not valid. this %p", this);
+      magic = 0;
+      return;
+    }
+
+
+  rwlocks.insert (this);
+}
+
+pthread_rwlock::~pthread_rwlock ()
+{
+  rwlocks.remove (this);
+}
+
+int
+pthread_rwlock::rdlock ()
+{
+  int result = 0;
+  struct RWLOCK_READER *reader;
+  pthread_t self = pthread::self ();
+
+  mtx.lock ();
+
+  if (lookup_reader (self))
+    {
+      result = EDEADLK;
+      goto DONE;
+    }
+
+  reader = new struct RWLOCK_READER;
+  if (!reader)
+    {
+      result = EAGAIN;
+      goto DONE;
+    }
+
+  while (writer || waiting_writers)
+    {
+      pthread_cleanup_push (pthread_rwlock::rdlock_cleanup, this);
+
+      ++waiting_readers;
+      cond_readers.wait (&mtx);
+      --waiting_readers;
+
+      pthread_cleanup_pop (0);
+    }
+
+  reader->thread = self;
+  add_reader (reader);
+
+ DONE:
+  mtx.unlock ();
+
+  return result;
+}
+
+int
+pthread_rwlock::tryrdlock ()
+{
+  int result = 0;
+  pthread_t self = pthread::self ();
+
+  mtx.lock ();
+
+  if (writer || waiting_writers || lookup_reader (self))
+    result = EBUSY;
+  else
+    {
+      struct RWLOCK_READER *reader = new struct RWLOCK_READER;
+      if (reader)
+	{
+	  reader->thread = self;
+	  add_reader (reader);
+	}
+      else
+	result = EAGAIN;
+    }
+
+  mtx.unlock ();
+
+  return result;
+}
+
+int
+pthread_rwlock::wrlock ()
+{
+  int result = 0;
+  pthread_t self = pthread::self ();
+
+  mtx.lock ();
+
+  if (writer == self || lookup_reader (self))
+    {
+      result = EDEADLK;
+      goto DONE;
+    }
+
+  while (writer || readers)
+    {
+      pthread_cleanup_push (pthread_rwlock::wrlock_cleanup, this);
+
+      ++waiting_writers;
+      cond_writers.wait (&mtx);
+      --waiting_writers;
+
+      pthread_cleanup_pop (0);
+    }
+
+  writer = self;
+
+ DONE:
+  mtx.unlock ();
+
+  return result;
+}
+
+int
+pthread_rwlock::trywrlock ()
+{
+  int result = 0;
+  pthread_t self = pthread::self ();
+
+  mtx.lock ();
+
+  if (writer || readers)
+    result = EBUSY;
+  else
+    writer = self;
+
+  mtx.unlock ();
+
+  return result;
+}
+
+int
+pthread_rwlock::unlock ()
+{
+  int result = 0;
+  pthread_t self = pthread::self ();
+
+  mtx.lock ();
+
+  if (writer)
+    {
+      if (writer != self)
+	{
+	  result = EPERM;
+	  goto DONE;
+	}
+
+      writer = NULL;
+    }
+  else
+    {
+      struct RWLOCK_READER *reader = lookup_reader (self);
+
+      if (!reader)
+	{
+	  result = EPERM;
+	  goto DONE;
+	}
+
+      remove_reader (reader);
+      delete reader;
+    }
+
+  release ();
+
+ DONE:
+  mtx.unlock ();
+
+  return result;
+}
+
+void
+pthread_rwlock::add_reader (struct RWLOCK_READER *rd)
+{
+  rd->next = (struct RWLOCK_READER *)
+    InterlockedExchangePointer (&readers, rd);
+}
+
+void
+pthread_rwlock::remove_reader (struct RWLOCK_READER *rd)
+{
+  if (readers == rd)
+    InterlockedExchangePointer (&readers, rd->next);
+  else
+    {
+      struct RWLOCK_READER *temp = readers;
+      while (temp->next && temp->next != rd)
+	temp = temp->next;
+      /* but there may be a race between the loop above and this statement */
+      InterlockedExchangePointer (&temp->next, rd->next);
+    }
+}
+
+struct pthread_rwlock::RWLOCK_READER *
+pthread_rwlock::lookup_reader (pthread_t thread)
+{
+  struct RWLOCK_READER *temp = readers;
+
+  while (temp && temp->thread != thread)
+    temp = temp->next;
+
+  return temp;
+}
+
+void
+pthread_rwlock::rdlock_cleanup (void *arg)
+{
+  pthread_rwlock *rwlock = (pthread_rwlock *) arg;
+
+  --(rwlock->waiting_readers);
+  rwlock->release ();
+  rwlock->mtx.unlock ();
+}
+
+void
+pthread_rwlock::wrlock_cleanup (void *arg)
+{
+  pthread_rwlock *rwlock = (pthread_rwlock *) arg;
+
+  --(rwlock->waiting_writers);
+  rwlock->release ();
+  rwlock->mtx.unlock ();
+}
+
+void
+pthread_rwlock::_fixup_after_fork ()
+{
+  pthread_t self = pthread::self ();
+  struct RWLOCK_READER **temp = &readers;
+
+  waiting_readers = 0;
+  waiting_writers = 0;
+
+  /* Unlock eventually locked mutex */
+  mtx.unlock ();
+  /*
+   * Remove all readers except self
+   */
+  while (*temp)
+    {
+      if ((*temp)->thread == self)
+	temp = &((*temp)->next);
+      else
+	{
+	  struct RWLOCK_READER *cur = *temp;
+	  *temp = (*temp)->next;
+	  delete cur;
+	}
+    }
+}
+
+/* pthread_key */
+/* static members */
+/* This stores pthread_key information across fork() boundaries */
+List<pthread_key> pthread_key::keys;
+
+bool
+pthread_key::is_good_object (pthread_key_t const *key)
+{
+  if (verifyable_object_isvalid (key, PTHREAD_KEY_MAGIC) != VALID_OBJECT)
+    return false;
+  return true;
+}
+
+/* non-static members */
+
+pthread_key::pthread_key (void (*aDestructor) (void *)):verifyable_object (PTHREAD_KEY_MAGIC), destructor (aDestructor)
+{
+  tls_index = TlsAlloc ();
+  if (tls_index == TLS_OUT_OF_INDEXES)
+    magic = 0;
+  else
+    keys.insert (this);
+}
+
+pthread_key::~pthread_key ()
+{
+  /* We may need to make the list code lock the list during operations
+   */
+  if (magic != 0)
+    {
+      keys.remove (this);
+      TlsFree (tls_index);
+    }
+}
+
+int
+pthread_key::set (const void *value)
+{
+  /* the OS function doesn't perform error checking */
+  TlsSetValue (tls_index, (void *) value);
+  return 0;
+}
+
+void *
+pthread_key::get () const
+{
+  int saved_error = ::GetLastError ();
+  void *result = TlsGetValue (tls_index);
+  ::SetLastError (saved_error);
+  return result;
+}
+
+void
+pthread_key::save_key_to_buffer ()
+{
+  fork_buf = get ();
+}
+
+void
+pthread_key::recreate_key_from_buffer ()
+{
+  tls_index = TlsAlloc ();
+  if (tls_index == TLS_OUT_OF_INDEXES)
+    api_fatal ("pthread_key::recreate_key_from_buffer () failed to reallocate Tls storage");
+  set (fork_buf);
+}
+
+void
+pthread_key::run_destructor ()
+{
+  if (destructor)
+    {
+      void *oldValue = get ();
+      if (oldValue)
+	{
+	  set (NULL);
+	  destructor (oldValue);
+	}
+    }
+}
+
+/* pshared mutexs:
+
+   REMOVED FROM CURRENT. These can be reinstated with the daemon, when all the
+   gymnastics can be a lot easier.
+
+   the mutex_t (size 4) is not used as a verifyable object because we cannot
+   guarantee the same address space for all processes.
+   we use the following:
+   high bit set (never a valid address).
+   second byte is reserved for the priority.
+   third byte is reserved
+   fourth byte is the mutex id. (max 255 cygwin mutexs system wide).
+   creating mutex's does get slower and slower, but as creation is a one time
+   job, it should never become an issue
+
+   And if you're looking at this and thinking, why not an array in cygwin for all mutexs,
+   - you incur a penalty on _every_ mutex call and you have toserialise them all.
+   ... Bad karma.
+
+   option 2? put everything in userspace and update the ABI?
+   - bad karma as well - the HANDLE, while identical across process's,
+   Isn't duplicated, it's reopened. */
+
+/* static members */
+bool
+pthread_mutex::is_good_object (pthread_mutex_t const *mutex)
+{
+  if (verifyable_object_isvalid (mutex, PTHREAD_MUTEX_MAGIC) != VALID_OBJECT)
+    return false;
+  return true;
+}
+
+bool
+pthread_mutex::is_good_initializer (pthread_mutex_t const *mutex)
+{
+  if (verifyable_object_isvalid (mutex, PTHREAD_MUTEX_MAGIC, PTHREAD_MUTEX_INITIALIZER) != VALID_STATIC_OBJECT)
+    return false;
+  return true;
+}
+
+bool
+pthread_mutex::is_good_initializer_or_object (pthread_mutex_t const *mutex)
+{
+  if (verifyable_object_isvalid (mutex, PTHREAD_MUTEX_MAGIC, PTHREAD_MUTEX_INITIALIZER) == INVALID_OBJECT)
+    return false;
+  return true;
+}
+
+bool
+pthread_mutex::is_good_initializer_or_bad_object (pthread_mutex_t const *mutex)
+{
+  verifyable_object_state objectState = verifyable_object_isvalid (mutex, PTHREAD_MUTEX_MAGIC, PTHREAD_MUTEX_INITIALIZER);
+  if (objectState == VALID_OBJECT)
+	return false;
+  return true;
+}
+
+bool
+pthread_mutex::can_be_unlocked (pthread_mutex_t const *mutex)
+{
+  pthread_t self = pthread::self ();
+
+  if (!is_good_object (mutex))
+    return false;
+  /*
+   * Check if the mutex is owned by the current thread and can be unlocked
+   */
+  return ((*mutex)->recursion_counter == 1 && pthread::equal ((*mutex)->owner, self));
+}
+
+List<pthread_mutex> pthread_mutex::mutexes;
+
+/* This is used for mutex creation protection within a single process only */
+native_mutex NO_COPY pthread_mutex::mutex_initialization_lock;
+
+/* We can only be called once.
+   TODO: (no rush) use a non copied memory section to
+   hold an initialization flag.  */
+void
+pthread_mutex::init_mutex ()
+{
+  if (!mutex_initialization_lock.init ())
+    api_fatal ("Could not create win32 Mutex for pthread mutex static initializer support.");
+}
+
+pthread_mutex::pthread_mutex (pthread_mutexattr *attr) :
+  verifyable_object (PTHREAD_MUTEX_MAGIC),
+  lock_counter (0),
+  win32_obj_id (NULL), recursion_counter (0),
+  condwaits (0), owner (NULL), type (PTHREAD_MUTEX_DEFAULT),
+  pshared (PTHREAD_PROCESS_PRIVATE)
+{
+  win32_obj_id = ::CreateSemaphore (&sec_none_nih, 0, LONG_MAX, NULL);
+  if (!win32_obj_id)
+    {
+      magic = 0;
+      return;
+    }
+  /*attr checked in the C call */
+  if (attr)
+    {
+      if (attr->pshared == PTHREAD_PROCESS_SHARED)
+	{
+	  // fail
+	  magic = 0;
+	  return;
+	}
+
+      type = attr->mutextype;
+    }
+
+  mutexes.insert (this);
+}
+
+pthread_mutex::~pthread_mutex ()
+{
+  if (win32_obj_id)
+    CloseHandle (win32_obj_id);
+
+  mutexes.remove (this);
+}
+
+int
+pthread_mutex::_lock (pthread_t self)
+{
+  int result = 0;
+
+  if (InterlockedIncrement ((long *)&lock_counter) == 1)
+    set_owner (self);
+  else if (type != PTHREAD_MUTEX_NORMAL && pthread::equal (owner, self))
+    {
+      InterlockedDecrement ((long *) &lock_counter);
+      if (type == PTHREAD_MUTEX_RECURSIVE)
+	result = lock_recursive ();
+      else
+	result = EDEADLK;
+    }
+  else
+    {
+      WaitForSingleObject (win32_obj_id, INFINITE);
+      set_owner (self);
+    }
+
+  return result;
+}
+
+int
+pthread_mutex::_trylock (pthread_t self)
+{
+  int result = 0;
+
+  if (InterlockedCompareExchange ((long *)&lock_counter, 1, 0 ) == 0)
+    set_owner (self);
+  else if (type == PTHREAD_MUTEX_RECURSIVE && pthread::equal (owner, self))
+    result = lock_recursive ();
+  else
+    result = EBUSY;
+
+  return result;
+}
+
+int
+pthread_mutex::_unlock (pthread_t self)
+{
+  if (!pthread::equal (owner, self))
+    return EPERM;
+
+  if (--recursion_counter == 0)
+    {
+      owner = NULL;
+      if (InterlockedDecrement ((long *)&lock_counter))
+	// Another thread is waiting
+	::ReleaseSemaphore (win32_obj_id, 1, NULL);
+    }
+
+  return 0;
+}
+
+int
+pthread_mutex::_destroy (pthread_t self)
+{
+  if (condwaits || _trylock (self))
+    // Do not destroy a condwaited or locked mutex
+    return EBUSY;
+  else if (recursion_counter != 1)
+    {
+      // Do not destroy a recursive locked mutex
+      --recursion_counter;
+      return EBUSY;
+    }
+
+  delete this;
+  return 0;
+}
+
+void
+pthread_mutex::_fixup_after_fork ()
+{
+  debug_printf ("mutex %x in _fixup_after_fork", this);
+  if (pshared != PTHREAD_PROCESS_PRIVATE)
+    api_fatal ("pthread_mutex::_fixup_after_fork () doesn'tunderstand PROCESS_SHARED mutex's");
+
+  if (owner == NULL)
+    /* mutex has no owner, reset to initial */
+    lock_counter = 0;
+  else if (lock_counter != 0)
+    /* All waiting threads are gone after a fork */
+    lock_counter = 1;
+
+  win32_obj_id = ::CreateSemaphore (&sec_none_nih, 0, LONG_MAX, NULL);
+  if (!win32_obj_id)
+    api_fatal ("pthread_mutex::_fixup_after_fork () failed to recreate win32 semaphore for mutex");
+
+  condwaits = 0;
+}
+
+bool
+pthread_mutexattr::is_good_object (pthread_mutexattr_t const * attr)
+{
+  if (verifyable_object_isvalid (attr, PTHREAD_MUTEXATTR_MAGIC) != VALID_OBJECT)
+    return false;
+  return true;
+}
+
+pthread_mutexattr::pthread_mutexattr ():verifyable_object (PTHREAD_MUTEXATTR_MAGIC),
+pshared (PTHREAD_PROCESS_PRIVATE), mutextype (PTHREAD_MUTEX_DEFAULT)
+{
+}
+
+pthread_mutexattr::~pthread_mutexattr ()
+{
+}
+
+List<semaphore> semaphore::semaphores;
+
+semaphore::semaphore (int pshared, unsigned int value):verifyable_object (SEM_MAGIC)
+{
+  this->win32_obj_id = ::CreateSemaphore (&sec_none_nih, value, LONG_MAX,
+					  NULL);
+  if (!this->win32_obj_id)
+    magic = 0;
+  this->shared = pshared;
+  currentvalue = value;
+
+  semaphores.insert (this);
+}
+
+semaphore::~semaphore ()
+{
+  if (win32_obj_id)
+    CloseHandle (win32_obj_id);
+
+  semaphores.remove (this);
+}
+
+void
+semaphore::_post ()
+{
+  /* we can't use the currentvalue, because the wait functions don't let us access it */
+  ReleaseSemaphore (win32_obj_id, 1, NULL);
+  currentvalue++;
+}
+
+int
+semaphore::_trywait ()
+{
+  /* FIXME: signals should be able to interrupt semaphores...
+   *We probably need WaitForMultipleObjects here.
+   */
+  if (WaitForSingleObject (win32_obj_id, 0) == WAIT_TIMEOUT)
+    {
+      set_errno (EAGAIN);
+      return -1;
+    }
+  currentvalue--;
+  return 0;
+}
+
+void
+semaphore::_wait ()
+{
+  switch (pthread::cancelable_wait (win32_obj_id, INFINITE))
+    {
+    case WAIT_OBJECT_0:
+      currentvalue--;
+      break;
+    default:
+      debug_printf ("cancelable_wait failed. %E");
+      return;
+    }
+}
+
+void
+semaphore::_fixup_after_fork ()
+{
+  debug_printf ("sem %x in _fixup_after_fork", this);
+  if (shared != PTHREAD_PROCESS_PRIVATE)
+    api_fatal ("doesn't understand PROCESS_SHARED semaphores variables");
+  /* FIXME: duplicate code here and in the constructor. */
+  this->win32_obj_id = ::CreateSemaphore (&sec_none_nih, currentvalue, LONG_MAX, NULL);
+  if (!win32_obj_id)
+    api_fatal ("failed to create new win32 semaphore");
+}
+
+verifyable_object::verifyable_object (long verifyer):
+magic (verifyer)
+{
+}
+
+verifyable_object::~verifyable_object ()
+{
+  magic = 0;
+}
+
+/* Generic memory acccess routine - where should it live ? */
+int __stdcall
+check_valid_pointer (void const *pointer)
+{
+  if (!pointer || IsBadWritePtr ((void *) pointer, sizeof (verifyable_object)))
+    return EFAULT;
+  return 0;
+}
+
+verifyable_object_state
+verifyable_object_isvalid (void const * objectptr, long magic, void *static_ptr)
+{
+  verifyable_object **object = (verifyable_object **)objectptr;
+  if (check_valid_pointer (object))
+    return INVALID_OBJECT;
+  if (static_ptr && *object == static_ptr)
+    return VALID_STATIC_OBJECT;
+  if (!*object)
+    return INVALID_OBJECT;
+  if (check_valid_pointer (*object))
+    return INVALID_OBJECT;
+  if ((*object)->magic != magic)
+    return INVALID_OBJECT;
+  return VALID_OBJECT;
+}
+
+verifyable_object_state
+verifyable_object_isvalid (void const * objectptr, long magic)
+{
+  return verifyable_object_isvalid (objectptr, magic, NULL);
+}
+
+inline void
+__reent_t::init_clib (struct _reent& var)
+{
+  var = ((struct _reent) _REENT_INIT (var));
+  var._stdin = _GLOBAL_REENT->_stdin;
+  var._stdout = _GLOBAL_REENT->_stdout;
+  var._stderr = _GLOBAL_REENT->_stderr;
+  _clib = &var;
+};
+
+/* Pthreads */
+void *
+pthread::thread_init_wrapper (void *_arg)
+{
+  // Setup the local/global storage of this thread
+
+  pthread *thread = (pthread *) _arg;
+  struct __reent_t local_reent;
+  struct _winsup_t local_winsup;
+  struct _reent local_clib;
+
+  struct sigaction _sigs[NSIG];
+  sigset_t _sig_mask;		/* one set for everything to ignore. */
+  LONG _sigtodo[NSIG + __SIGOFFSET];
+
+  // setup signal structures
+  thread->sigs = _sigs;
+  thread->sigmask = &_sig_mask;
+  thread->sigtodo = _sigtodo;
+
+  memset (&local_winsup, 0, sizeof (struct _winsup_t));
+
+  local_reent.init_clib (local_clib);
+  local_reent._winsup = &local_winsup;
+
+  local_winsup._process_logmask = LOG_UPTO (LOG_DEBUG);
+
+  MT_INTERFACE->reent_key.set (&local_reent);
+
+  thread->set_thread_id_to_current ();
+  set_tls_self_pointer (thread);
+
+  thread->mutex.lock ();
+  // if thread is detached force cleanup on exit
+  if (thread->attr.joinable == PTHREAD_CREATE_DETACHED && thread->joiner == NULL)
+    thread->joiner = thread;
+  thread->mutex.unlock ();
+
+#ifdef _CYG_THREAD_FAILSAFE
+  if (_REENT == _impure_ptr)
+    system_printf ("local storage for thread isn't setup correctly");
+#endif
+
+  thread_printf ("started thread %p %p %p %p %p %p", _arg, &local_clib,
+		 _impure_ptr, thread, thread->function, thread->arg);
+
+  // call the user's thread
+  void *ret = thread->function (thread->arg);
+
+  thread->exit (ret);
+
+#if 0
+// ??? This code only runs if the thread exits by returning.
+// it's all now in __pthread_exit ();
+#endif
+  /* never reached */
+  return 0;
+}
+
+bool
+pthread::is_good_object (pthread_t const *thread)
+{
+  if (verifyable_object_isvalid (thread, PTHREAD_MAGIC) != VALID_OBJECT)
+    return false;
+  return true;
+}
+
+unsigned long
+pthread::getsequence_np ()
+{
+  return get_thread_id ();
+}
+
+int
+pthread::create (pthread_t *thread, const pthread_attr_t *attr,
+		  void *(*start_routine) (void *), void *arg)
+{
+  DECLARE_TLS_STORAGE;
+  if (attr && !pthread_attr::is_good_object (attr))
+    return EINVAL;
+
+  *thread = new pthread ();
+  (*thread)->create (start_routine, attr ? *attr : NULL, arg);
+  if (!is_good_object (thread))
+    {
+      delete (*thread);
+      *thread = NULL;
+      return EAGAIN;
+    }
+
+  return 0;
+}
+
+int
+pthread::once (pthread_once_t *once_control, void (*init_routine) (void))
+{
+  // already done ?
+  if (once_control->state)
+    return 0;
+
+  pthread_mutex_lock (&once_control->mutex);
+  /* Here we must set a cancellation handler to unlock the mutex if needed */
+  /* but a cancellation handler is not the right thing. We need this in the thread
+   *cleanup routine. Assumption: a thread can only be in one pthread_once routine
+   *at a time. Stote a mutex_t *in the pthread_structure. if that's non null unlock
+   *on pthread_exit ();
+   */
+  if (!once_control->state)
+    {
+      init_routine ();
+      once_control->state = 1;
+    }
+  /* Here we must remove our cancellation handler */
+  pthread_mutex_unlock (&once_control->mutex);
+  return 0;
+}
+
+int
+pthread::cancel (pthread_t thread)
+{
+  if (!is_good_object (&thread))
+    return ESRCH;
+
+  return thread->cancel ();
+}
+
+/* Races in pthread_atfork:
+   We are race safe in that any additions to the lists are made via
+   InterlockedExchangePointer.
+   However, if the user application doesn't perform syncronisation of some sort
+   It's not guaranteed that a near simultaneous call to pthread_atfork and fork
+   will result in the new atfork handlers being calls.
+   More rigorous internal syncronisation isn't needed as the user program isn't
+   guaranteeing their own state.
+
+   as far as multiple calls to pthread_atfork, the worst case is simultaneous calls
+   will result in an indeterminate order for parent and child calls (what gets inserted
+   first isn't guaranteed.)
+
+   There is one potential race... Does the result of InterlockedExchangePointer
+   get committed to the return location _before_ any context switches can occur?
+   If yes, we're safe, if no, we're not.  */
+void
+pthread::atforkprepare (void)
+{
+  MT_INTERFACE->fixup_before_fork ();
+
+  callback *cb = MT_INTERFACE->pthread_prepare;
+  while (cb)
+    {
+      cb->cb ();
+      cb = cb->next;
+    }
+}
+
+void
+pthread::atforkparent (void)
+{
+  callback *cb = MT_INTERFACE->pthread_parent;
+  while (cb)
+    {
+      cb->cb ();
+      cb = cb->next;
+    }
+}
+
+void
+pthread::atforkchild (void)
+{
+  MT_INTERFACE->fixup_after_fork ();
+
+  callback *cb = MT_INTERFACE->pthread_child;
+  while (cb)
+    {
+      cb->cb ();
+      cb = cb->next;
+    }
+}
+
+/* Register a set of functions to run before and after fork.
+   prepare calls are called in LI-FC order.
+   parent and child calls are called in FI-FC order.  */
+int
+pthread::atfork (void (*prepare)(void), void (*parent)(void), void (*child)(void))
+{
+  callback *prepcb = NULL, *parentcb = NULL, *childcb = NULL;
+  if (prepare)
+    {
+      prepcb = new callback;
+      if (!prepcb)
+	return ENOMEM;
+    }
+  if (parent)
+    {
+      parentcb = new callback;
+      if (!parentcb)
+	{
+	  if (prepcb)
+	    delete prepcb;
+	  return ENOMEM;
+	}
+    }
+  if (child)
+    {
+      childcb = new callback;
+      if (!childcb)
+	{
+	  if (prepcb)
+	    delete prepcb;
+	  if (parentcb)
+	    delete parentcb;
+	  return ENOMEM;
+	}
+    }
+
+  if (prepcb)
+  {
+    prepcb->cb = prepare;
+    prepcb->next = (callback *) InterlockedExchangePointer ((LONG *) &MT_INTERFACE->pthread_prepare, (long int) prepcb);
+  }
+  if (parentcb)
+  {
+    parentcb->cb = parent;
+    callback **t = &MT_INTERFACE->pthread_parent;
+    while (*t)
+      t = &(*t)->next;
+    /* t = pointer to last next in the list */
+    parentcb->next = (callback *) InterlockedExchangePointer ((LONG *) t, (long int) parentcb);
+  }
+  if (childcb)
+  {
+    childcb->cb = child;
+    callback **t = &MT_INTERFACE->pthread_child;
+    while (*t)
+      t = &(*t)->next;
+    /* t = pointer to last next in the list */
+    childcb->next = (callback *) InterlockedExchangePointer ((LONG *) t, (long int) childcb);
+  }
+  return 0;
+}
+
+extern "C" int
+pthread_attr_init (pthread_attr_t *attr)
+{
+  if (pthread_attr::is_good_object (attr))
+    return EBUSY;
+
+  *attr = new pthread_attr;
+  if (!pthread_attr::is_good_object (attr))
+    {
+      delete (*attr);
+      *attr = NULL;
+      return ENOMEM;
+    }
+  return 0;
+}
+
+extern "C" int
+pthread_attr_getinheritsched (const pthread_attr_t *attr,
+				int *inheritsched)
+{
+  if (!pthread_attr::is_good_object (attr))
+    return EINVAL;
+  *inheritsched = (*attr)->inheritsched;
+  return 0;
+}
+
+extern "C" int
+pthread_attr_getschedparam (const pthread_attr_t *attr,
+			      struct sched_param *param)
+{
+  if (!pthread_attr::is_good_object (attr))
+    return EINVAL;
+  *param = (*attr)->schedparam;
+  return 0;
+}
+
+/* From a pure code point of view, this should call a helper in sched.cc,
+   to allow for someone adding scheduler policy changes to win32 in the future.
+   However that's extremely unlikely, so short and sweet will do us */
+extern "C" int
+pthread_attr_getschedpolicy (const pthread_attr_t *attr, int *policy)
+{
+  if (!pthread_attr::is_good_object (attr))
+    return EINVAL;
+  *policy = SCHED_FIFO;
+  return 0;
+}
+
+
+extern "C" int
+pthread_attr_getscope (const pthread_attr_t *attr, int *contentionscope)
+{
+  if (!pthread_attr::is_good_object (attr))
+    return EINVAL;
+  *contentionscope = (*attr)->contentionscope;
+  return 0;
+}
+
+extern "C" int
+pthread_attr_setdetachstate (pthread_attr_t *attr, int detachstate)
+{
+  if (!pthread_attr::is_good_object (attr))
+    return EINVAL;
+  if (detachstate < 0 || detachstate > 1)
+    return EINVAL;
+  (*attr)->joinable = detachstate;
+  return 0;
+}
+
+extern "C" int
+pthread_attr_getdetachstate (const pthread_attr_t *attr, int *detachstate)
+{
+  if (!pthread_attr::is_good_object (attr))
+    return EINVAL;
+  *detachstate = (*attr)->joinable;
+  return 0;
+}
+
+extern "C" int
+pthread_attr_setinheritsched (pthread_attr_t *attr, int inheritsched)
+{
+  if (!pthread_attr::is_good_object (attr))
+    return EINVAL;
+  if (inheritsched != PTHREAD_INHERIT_SCHED
+      && inheritsched != PTHREAD_EXPLICIT_SCHED)
+    return ENOTSUP;
+  (*attr)->inheritsched = inheritsched;
+  return 0;
+}
+
+extern "C" int
+pthread_attr_setschedparam (pthread_attr_t *attr,
+			      const struct sched_param *param)
+{
+  if (!pthread_attr::is_good_object (attr))
+    return EINVAL;
+  if (!valid_sched_parameters (param))
+    return ENOTSUP;
+  (*attr)->schedparam = *param;
+  return 0;
+}
+
+/* See __pthread_attr_getschedpolicy for some notes */
+extern "C" int
+pthread_attr_setschedpolicy (pthread_attr_t *attr, int policy)
+{
+  if (!pthread_attr::is_good_object (attr))
+    return EINVAL;
+  if (policy != SCHED_FIFO)
+    return ENOTSUP;
+  return 0;
+}
+
+extern "C" int
+pthread_attr_setscope (pthread_attr_t *attr, int contentionscope)
+{
+  if (!pthread_attr::is_good_object (attr))
+    return EINVAL;
+  if (contentionscope != PTHREAD_SCOPE_SYSTEM
+      && contentionscope != PTHREAD_SCOPE_PROCESS)
+    return EINVAL;
+  /* In future, we may be able to support system scope by escalating the thread
+     priority to exceed the priority class. For now we only support PROCESS scope. */
+  if (contentionscope != PTHREAD_SCOPE_PROCESS)
+    return ENOTSUP;
+  (*attr)->contentionscope = contentionscope;
+  return 0;
+}
+
+extern "C" int
+pthread_attr_setstacksize (pthread_attr_t *attr, size_t size)
+{
+  if (!pthread_attr::is_good_object (attr))
+    return EINVAL;
+  (*attr)->stacksize = size;
+  return 0;
+}
+
+extern "C" int
+pthread_attr_getstacksize (const pthread_attr_t *attr, size_t *size)
+{
+  if (!pthread_attr::is_good_object (attr))
+    return EINVAL;
+  *size = (*attr)->stacksize;
+  return 0;
+}
+
+extern "C" int
+pthread_attr_destroy (pthread_attr_t *attr)
+{
+  if (!pthread_attr::is_good_object (attr))
+    return EINVAL;
+  delete (*attr);
+  *attr = NULL;
+  return 0;
+}
+
+int
+pthread::join (pthread_t *thread, void **return_val)
+{
+   pthread_t joiner = self ();
+
+   joiner->testcancel ();
+
+   // Initialize return val with NULL
+   if (return_val)
+     *return_val = NULL;
+
+   if (!is_good_object (&joiner))
+     return EINVAL;
+
+  if (!is_good_object (thread))
+    return ESRCH;
+
+  if (equal (*thread,joiner))
+    return EDEADLK;
+
+  (*thread)->mutex.lock ();
+
+  if ((*thread)->attr.joinable == PTHREAD_CREATE_DETACHED)
+    {
+      (*thread)->mutex.unlock ();
+      return EINVAL;
+    }
+  else
+    {
+      (*thread)->joiner = joiner;
+      (*thread)->attr.joinable = PTHREAD_CREATE_DETACHED;
+      (*thread)->mutex.unlock ();
+
+      switch (cancelable_wait ((*thread)->win32_obj_id, INFINITE, false))
+	{
+	case WAIT_OBJECT_0:
+	  if (return_val)
+	    *return_val = (*thread)->return_ptr;
+	  delete (*thread);
+	  break;
+	case WAIT_CANCELED:
+	  // set joined thread back to joinable since we got canceled
+	  (*thread)->joiner = NULL;
+	  (*thread)->attr.joinable = PTHREAD_CREATE_JOINABLE;
+	  joiner->cancel_self ();
+	  // never reached
+	  break;
+	default:
+	  // should never happen
+	  return EINVAL;
+	}
+    }
+
+  return 0;
+}
+
+int
+pthread::detach (pthread_t *thread)
+{
+  if (!is_good_object (thread))
+    return ESRCH;
+
+  (*thread)->mutex.lock ();
+  if ((*thread)->attr.joinable == PTHREAD_CREATE_DETACHED)
+    {
+      (*thread)->mutex.unlock ();
+      return EINVAL;
+    }
+
+  // check if thread is still alive
+  if ((*thread)->running && WaitForSingleObject ((*thread)->win32_obj_id, 0) == WAIT_TIMEOUT)
+    {
+      // force cleanup on exit
+      (*thread)->joiner = *thread;
+      (*thread)->attr.joinable = PTHREAD_CREATE_DETACHED;
+      (*thread)->mutex.unlock ();
+    }
+  else
+    {
+      // thread has already terminated.
+      (*thread)->mutex.unlock ();
+      delete (*thread);
+    }
+
+  return 0;
+}
+
+int
+pthread::suspend (pthread_t *thread)
+{
+  if (!is_good_object (thread))
+    return ESRCH;
+
+  if ((*thread)->suspended == false)
+    {
+      (*thread)->suspended = true;
+      SuspendThread ((*thread)->win32_obj_id);
+    }
+
+  return 0;
+}
+
+
+int
+pthread::resume (pthread_t *thread)
+{
+  if (!is_good_object (thread))
+    return ESRCH;
+
+  if ((*thread)->suspended == true)
+    ResumeThread ((*thread)->win32_obj_id);
+  (*thread)->suspended = false;
+
+  return 0;
+}
+
+/* provided for source level compatability.
+   See http://www.opengroup.org/onlinepubs/007908799/xsh/pthread_getconcurrency.html
+*/
+extern "C" int
+pthread_getconcurrency (void)
+{
+  return MT_INTERFACE->concurrency;
+}
+
+/* keep this in sync with sched.cc */
+extern "C" int
+pthread_getschedparam (pthread_t thread, int *policy,
+			 struct sched_param *param)
+{
+  if (!pthread::is_good_object (&thread))
+    return ESRCH;
+  *policy = SCHED_FIFO;
+  /* we don't return the current effective priority, we return the current
+     requested priority */
+  *param = thread->attr.schedparam;
+  return 0;
+}
+
+/* Thread SpecificData */
+extern "C" int
+pthread_key_create (pthread_key_t *key, void (*destructor) (void *))
+{
+  /* The opengroup docs don't define if we should check this or not,
+     but creation is relatively rare.  */
+  if (pthread_key::is_good_object (key))
+    return EBUSY;
+
+  *key = new pthread_key (destructor);
+
+  if (!pthread_key::is_good_object (key))
+    {
+      delete (*key);
+      *key = NULL;
+      return EAGAIN;
+    }
+  return 0;
+}
+
+extern "C" int
+pthread_key_delete (pthread_key_t key)
+{
+  if (!pthread_key::is_good_object (&key))
+    return EINVAL;
+
+  delete (key);
+  return 0;
+}
+
+/* provided for source level compatability.  See
+http://www.opengroup.org/onlinepubs/007908799/xsh/pthread_getconcurrency.html
+*/
+extern "C" int
+pthread_setconcurrency (int new_level)
+{
+  if (new_level < 0)
+    return EINVAL;
+  MT_INTERFACE->concurrency = new_level;
+  return 0;
+}
+
+/* keep syncronised with sched.cc */
+extern "C" int
+pthread_setschedparam (pthread_t thread, int policy,
+			 const struct sched_param *param)
+{
+  if (!pthread::is_good_object (&thread))
+    return ESRCH;
+  if (policy != SCHED_FIFO)
+    return ENOTSUP;
+  if (!param)
+    return EINVAL;
+  int rv =
+    sched_set_thread_priority (thread->win32_obj_id, param->sched_priority);
+  if (!rv)
+    thread->attr.schedparam.sched_priority = param->sched_priority;
+  return rv;
+}
+
+
+extern "C" int
+pthread_setspecific (pthread_key_t key, const void *value)
+{
+  if (!pthread_key::is_good_object (&key))
+    return EINVAL;
+  (key)->set (value);
+  return 0;
+}
+
+extern "C" void *
+pthread_getspecific (pthread_key_t key)
+{
+  if (!pthread_key::is_good_object (&key))
+    return NULL;
+
+  return (key)->get ();
+
+}
+
+/* Thread synchronisation */
+bool
+pthread_cond::is_good_object (pthread_cond_t const *cond)
+{
+  if (verifyable_object_isvalid (cond, PTHREAD_COND_MAGIC) != VALID_OBJECT)
+    return false;
+  return true;
+}
+
+bool
+pthread_cond::is_good_initializer (pthread_cond_t const *cond)
+{
+  if (verifyable_object_isvalid (cond, PTHREAD_COND_MAGIC, PTHREAD_COND_INITIALIZER) != VALID_STATIC_OBJECT)
+    return false;
+  return true;
+}
+
+bool
+pthread_cond::is_good_initializer_or_object (pthread_cond_t const *cond)
+{
+  if (verifyable_object_isvalid (cond, PTHREAD_COND_MAGIC, PTHREAD_COND_INITIALIZER) == INVALID_OBJECT)
+    return false;
+  return true;
+}
+
+bool
+pthread_cond::is_good_initializer_or_bad_object (pthread_cond_t const *cond)
+{
+  verifyable_object_state objectState = verifyable_object_isvalid (cond, PTHREAD_COND_MAGIC, PTHREAD_COND_INITIALIZER);
+  if (objectState == VALID_OBJECT)
+	return false;
+  return true;
+}
+
+extern "C" int
+pthread_cond_destroy (pthread_cond_t *cond)
+{
+  if (pthread_cond::is_good_initializer (cond))
+    return 0;
+  if (!pthread_cond::is_good_object (cond))
+    return EINVAL;
+
+  /* reads are atomic */
+  if ((*cond)->waiting)
+    return EBUSY;
+
+  delete (*cond);
+  *cond = NULL;
+
+  return 0;
+}
+
+int
+pthread_cond::init (pthread_cond_t *cond, const pthread_condattr_t *attr)
+{
+  if (attr && !pthread_condattr::is_good_object (attr))
+    return EINVAL;
+  if (!cond_initialization_lock.lock ())
+    return EINVAL;
+
+  if (!is_good_initializer_or_bad_object (cond))
+    {
+      cond_initialization_lock.unlock ();
+      return EBUSY;
+    }
+
+  *cond = new pthread_cond (attr ? (*attr) : NULL);
+  if (!is_good_object (cond))
+    {
+      delete (*cond);
+      *cond = NULL;
+      cond_initialization_lock.unlock ();
+      return EAGAIN;
+    }
+  cond_initialization_lock.unlock ();
+  return 0;
+}
+
+extern "C" int
+pthread_cond_broadcast (pthread_cond_t *cond)
+{
+  if (pthread_cond::is_good_initializer (cond))
+    return 0;
+  if (!pthread_cond::is_good_object (cond))
+    return EINVAL;
+
+  (*cond)->unblock (true);
+
+  return 0;
+}
+
+extern "C" int
+pthread_cond_signal (pthread_cond_t *cond)
+{
+  if (pthread_cond::is_good_initializer (cond))
+    return 0;
+  if (!pthread_cond::is_good_object (cond))
+    return EINVAL;
+
+  (*cond)->unblock (false);
+
+  return 0;
+}
+
+static int
+__pthread_cond_dowait (pthread_cond_t *cond, pthread_mutex_t *mutex,
+		       DWORD waitlength)
+{
+  if (!pthread_mutex::is_good_object (mutex))
+    return EINVAL;
+  if (!pthread_mutex::can_be_unlocked (mutex))
+    return EPERM;
+
+  if (pthread_cond::is_good_initializer (cond))
+    pthread_cond::init (cond, NULL);
+  if (!pthread_cond::is_good_object (cond))
+    return EINVAL;
+
+  return (*cond)->wait (*mutex, waitlength);
+}
+
+extern "C" int
+pthread_cond_timedwait (pthread_cond_t *cond, pthread_mutex_t *mutex,
+			const struct timespec *abstime)
+{
+  struct timeval tv;
+  long waitlength;
+
+  pthread_testcancel ();
+
+  if (check_valid_pointer (abstime))
+    return EINVAL;
+
+  gettimeofday (&tv, NULL);
+  waitlength = abstime->tv_sec * 1000 + abstime->tv_nsec / (1000 * 1000);
+  waitlength -= tv.tv_sec * 1000 + tv.tv_usec / 1000;
+  if (waitlength < 0)
+    return ETIMEDOUT;
+  return __pthread_cond_dowait (cond, mutex, waitlength);
+}
+
+extern "C" int
+pthread_cond_wait (pthread_cond_t *cond, pthread_mutex_t *mutex)
+{
+  pthread_testcancel ();
+
+  return __pthread_cond_dowait (cond, mutex, INFINITE);
+}
+
+extern "C" int
+pthread_condattr_init (pthread_condattr_t *condattr)
+{
+  if (pthread_condattr::is_good_object (condattr))
+    return EBUSY;
+
+  *condattr = new pthread_condattr;
+  if (!pthread_condattr::is_good_object (condattr))
+    {
+      delete (*condattr);
+      *condattr = NULL;
+      return ENOMEM;
+    }
+  return 0;
+}
+
+extern "C" int
+pthread_condattr_getpshared (const pthread_condattr_t *attr, int *pshared)
+{
+  if (!pthread_condattr::is_good_object (attr))
+    return EINVAL;
+  *pshared = (*attr)->shared;
+  return 0;
+}
+
+extern "C" int
+pthread_condattr_setpshared (pthread_condattr_t *attr, int pshared)
+{
+  if (!pthread_condattr::is_good_object (attr))
+    return EINVAL;
+  if ((pshared < 0) || (pshared > 1))
+    return EINVAL;
+  /* shared cond vars not currently supported */
+  if (pshared != PTHREAD_PROCESS_PRIVATE)
+    return EINVAL;
+  (*attr)->shared = pshared;
+  return 0;
+}
+
+extern "C" int
+pthread_condattr_destroy (pthread_condattr_t *condattr)
+{
+  if (!pthread_condattr::is_good_object (condattr))
+    return EINVAL;
+  delete (*condattr);
+  *condattr = NULL;
+  return 0;
+}
+
+/* RW locks */
+bool
+pthread_rwlock::is_good_object (pthread_rwlock_t const *rwlock)
+{
+  if (verifyable_object_isvalid (rwlock, PTHREAD_RWLOCK_MAGIC) != VALID_OBJECT)
+    return false;
+  return true;
+}
+
+bool
+pthread_rwlock::is_good_initializer (pthread_rwlock_t const *rwlock)
+{
+  if (verifyable_object_isvalid (rwlock, PTHREAD_RWLOCK_MAGIC, PTHREAD_RWLOCK_INITIALIZER) != VALID_STATIC_OBJECT)
+    return false;
+  return true;
+}
+
+bool
+pthread_rwlock::is_good_initializer_or_object (pthread_rwlock_t const *rwlock)
+{
+  if (verifyable_object_isvalid (rwlock, PTHREAD_RWLOCK_MAGIC, PTHREAD_RWLOCK_INITIALIZER) == INVALID_OBJECT)
+    return false;
+  return true;
+}
+
+bool
+pthread_rwlock::is_good_initializer_or_bad_object (pthread_rwlock_t const *rwlock)
+{
+  verifyable_object_state objectState = verifyable_object_isvalid (rwlock, PTHREAD_RWLOCK_MAGIC, PTHREAD_RWLOCK_INITIALIZER);
+  if (objectState == VALID_OBJECT)
+	return false;
+  return true;
+}
+
+extern "C" int
+pthread_rwlock_destroy (pthread_rwlock_t *rwlock)
+{
+  if (pthread_rwlock::is_good_initializer (rwlock))
+    return 0;
+  if (!pthread_rwlock::is_good_object (rwlock))
+    return EINVAL;
+
+  if ((*rwlock)->writer || (*rwlock)->readers ||
+      (*rwlock)->waiting_readers || (*rwlock)->waiting_writers)
+    return EBUSY;
+
+  delete (*rwlock);
+  *rwlock = NULL;
+
+  return 0;
+}
+
+int
+pthread_rwlock::init (pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr)
+{
+  if (attr && !pthread_rwlockattr::is_good_object (attr))
+    return EINVAL;
+  if (!rwlock_initialization_lock.lock ())
+    return EINVAL;
+
+  if (!is_good_initializer_or_bad_object (rwlock))
+    {
+      rwlock_initialization_lock.unlock ();
+      return EBUSY;
+    }
+
+  *rwlock = new pthread_rwlock (attr ? (*attr) : NULL);
+  if (!is_good_object (rwlock))
+    {
+      delete (*rwlock);
+      *rwlock = NULL;
+      rwlock_initialization_lock.unlock ();
+      return EAGAIN;
+    }
+  rwlock_initialization_lock.unlock ();
+  return 0;
+}
+
+extern "C" int
+pthread_rwlock_rdlock (pthread_rwlock_t *rwlock)
+{
+  pthread_testcancel ();
+
+  if (pthread_rwlock::is_good_initializer (rwlock))
+    pthread_rwlock::init (rwlock, NULL);
+  if (!pthread_rwlock::is_good_object (rwlock))
+    return EINVAL;
+
+  return (*rwlock)->rdlock ();
+}
+
+extern "C" int
+pthread_rwlock_tryrdlock (pthread_rwlock_t *rwlock)
+{
+  if (pthread_rwlock::is_good_initializer (rwlock))
+    pthread_rwlock::init (rwlock, NULL);
+  if (!pthread_rwlock::is_good_object (rwlock))
+    return EINVAL;
+
+  return (*rwlock)->tryrdlock ();
+}
+
+extern "C" int
+pthread_rwlock_wrlock (pthread_rwlock_t *rwlock)
+{
+  pthread_testcancel ();
+
+  if (pthread_rwlock::is_good_initializer (rwlock))
+    pthread_rwlock::init (rwlock, NULL);
+  if (!pthread_rwlock::is_good_object (rwlock))
+    return EINVAL;
+
+  return (*rwlock)->wrlock ();
+}
+
+extern "C" int
+pthread_rwlock_trywrlock (pthread_rwlock_t *rwlock)
+{
+  if (pthread_rwlock::is_good_initializer (rwlock))
+    pthread_rwlock::init (rwlock, NULL);
+  if (!pthread_rwlock::is_good_object (rwlock))
+    return EINVAL;
+
+  return (*rwlock)->trywrlock ();
+}
+
+extern "C" int
+pthread_rwlock_unlock (pthread_rwlock_t *rwlock)
+{
+  if (pthread_rwlock::is_good_initializer (rwlock))
+    return 0;
+  if (!pthread_rwlock::is_good_object (rwlock))
+    return EINVAL;
+
+  return (*rwlock)->unlock ();
+}
+
+extern "C" int
+pthread_rwlockattr_init (pthread_rwlockattr_t *rwlockattr)
+{
+  if (pthread_rwlockattr::is_good_object (rwlockattr))
+    return EBUSY;
+
+  *rwlockattr = new pthread_rwlockattr;
+  if (!pthread_rwlockattr::is_good_object (rwlockattr))
+    {
+      delete (*rwlockattr);
+      *rwlockattr = NULL;
+      return ENOMEM;
+    }
+  return 0;
+}
+
+extern "C" int
+pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *attr, int *pshared)
+{
+  if (!pthread_rwlockattr::is_good_object (attr))
+    return EINVAL;
+  *pshared = (*attr)->shared;
+  return 0;
+}
+
+extern "C" int
+pthread_rwlockattr_setpshared (pthread_rwlockattr_t *attr, int pshared)
+{
+  if (!pthread_rwlockattr::is_good_object (attr))
+    return EINVAL;
+  if ((pshared < 0) || (pshared > 1))
+    return EINVAL;
+  /* shared rwlock vars not currently supported */
+  if (pshared != PTHREAD_PROCESS_PRIVATE)
+    return EINVAL;
+  (*attr)->shared = pshared;
+  return 0;
+}
+
+extern "C" int
+pthread_rwlockattr_destroy (pthread_rwlockattr_t *rwlockattr)
+{
+  if (!pthread_rwlockattr::is_good_object (rwlockattr))
+    return EINVAL;
+  delete (*rwlockattr);
+  *rwlockattr = NULL;
+  return 0;
+}
+
+/* Thread signal */
+extern "C" int
+pthread_kill (pthread_t thread, int sig)
+{
+  // lock myself, for the use of thread2signal
+  // two different kills might clash: FIXME
+
+  if (!pthread::is_good_object (&thread))
+    return EINVAL;
+
+  if (thread->sigs)
+    myself->setthread2signal (thread);
+
+  int rval = raise (sig);
+
+  // unlock myself
+  return rval;
+}
+
+extern "C" int
+pthread_sigmask (int operation, const sigset_t *set, sigset_t *old_set)
+{
+  pthread *thread = pthread::self ();
+
+  // lock this myself, for the use of thread2signal
+  // two differt kills might clash: FIXME
+
+  if (thread->sigs)
+    myself->setthread2signal (thread);
+
+  int rval = sigprocmask (operation, set, old_set);
+
+  // unlock this myself
+
+  return rval;
+}
+
+/* ID */
+
+extern "C" int
+pthread_equal (pthread_t t1, pthread_t t2)
+{
+  return pthread::equal (t1, t2);
+}
+
+/* Mutexes  */
+
+/* FIXME: there's a potential race with PTHREAD_MUTEX_INITALIZER:
+   the mutex is not actually inited until the first use.
+   So two threads trying to lock/trylock may collide.
+   Solution: we need a global mutex on mutex creation, or possibly simply
+   on all constructors that allow INITIALIZER macros.
+   the lock should be very small: only around the init routine, not
+   every test, or all mutex access will be synchronised.  */
+
+int
+pthread_mutex::init (pthread_mutex_t *mutex,
+		      const pthread_mutexattr_t *attr)
+{
+  if (attr && !pthread_mutexattr::is_good_object (attr) || check_valid_pointer (mutex))
+    return EINVAL;
+  if (!mutex_initialization_lock.lock ())
+    return EINVAL;
+
+  if (!is_good_initializer_or_bad_object (mutex))
+    {
+      mutex_initialization_lock.unlock ();
+      return EBUSY;
+    }
+
+  *mutex = new pthread_mutex (attr ? (*attr) : NULL);
+  if (!is_good_object (mutex))
+    {
+      delete (*mutex);
+      *mutex = NULL;
+      mutex_initialization_lock.unlock ();
+      return EAGAIN;
+    }
+  mutex_initialization_lock.unlock ();
+  return 0;
+}
+
+extern "C" int
+pthread_mutex_getprioceiling (const pthread_mutex_t *mutex,
+				int *prioceiling)
+{
+  pthread_mutex_t *themutex = (pthread_mutex_t *) mutex;
+  if (pthread_mutex::is_good_initializer (mutex))
+    pthread_mutex::init ((pthread_mutex_t *) mutex, NULL);
+  if (!pthread_mutex::is_good_object (themutex))
+    return EINVAL;
+  /* We don't define _POSIX_THREAD_PRIO_PROTECT because we do't currently support
+     mutex priorities.
+
+     We can support mutex priorities in the future though:
+     Store a priority with each mutex.
+     When the mutex is optained, set the thread priority as appropriate
+     When the mutex is released, reset the thread priority.  */
+  return ENOSYS;
+}
+
+extern "C" int
+pthread_mutex_lock (pthread_mutex_t *mutex)
+{
+  pthread_mutex_t *themutex = mutex;
+  /* This could be simplified via is_good_initializer_or_object
+     and is_good_initializer, but in a performance critical call like this....
+     no.  */
+  switch (verifyable_object_isvalid (themutex, PTHREAD_MUTEX_MAGIC, PTHREAD_MUTEX_INITIALIZER))
+    {
+    case INVALID_OBJECT:
+      return EINVAL;
+      break;
+    case VALID_STATIC_OBJECT:
+      if (pthread_mutex::is_good_initializer (mutex))
+	{
+	  int rv = pthread_mutex::init (mutex, NULL);
+	  if (rv && rv != EBUSY)
+	    return rv;
+	}
+      /* No else needed. If it's been initialized while we waited,
+	 we can just attempt to lock it */
+      break;
+    case VALID_OBJECT:
+      break;
+    }
+  return (*themutex)->lock ();
+}
+
+extern "C" int
+pthread_mutex_trylock (pthread_mutex_t *mutex)
+{
+  pthread_mutex_t *themutex = mutex;
+  if (pthread_mutex::is_good_initializer (mutex))
+    pthread_mutex::init (mutex, NULL);
+  if (!pthread_mutex::is_good_object (themutex))
+    return EINVAL;
+  return (*themutex)->trylock ();
+}
+
+extern "C" int
+pthread_mutex_unlock (pthread_mutex_t *mutex)
+{
+  if (pthread_mutex::is_good_initializer (mutex))
+    pthread_mutex::init (mutex, NULL);
+  if (!pthread_mutex::is_good_object (mutex))
+    return EINVAL;
+  return (*mutex)->unlock ();
+}
+
+extern "C" int
+pthread_mutex_destroy (pthread_mutex_t *mutex)
+{
+  int rv;
+
+  if (pthread_mutex::is_good_initializer (mutex))
+    return 0;
+  if (!pthread_mutex::is_good_object (mutex))
+    return EINVAL;
+
+  rv = (*mutex)->destroy ();
+  if (rv)
+    return rv;
+
+  *mutex = NULL;
+  return 0;
+}
+
+extern "C" int
+pthread_mutex_setprioceiling (pthread_mutex_t *mutex, int prioceiling,
+				int *old_ceiling)
+{
+  pthread_mutex_t *themutex = mutex;
+  if (pthread_mutex::is_good_initializer (mutex))
+    pthread_mutex::init (mutex, NULL);
+  if (!pthread_mutex::is_good_object (themutex))
+    return EINVAL;
+  return ENOSYS;
+}
+
+/* Win32 doesn't support mutex priorities - see __pthread_mutex_getprioceiling
+   for more detail */
+extern "C" int
+pthread_mutexattr_getprotocol (const pthread_mutexattr_t *attr,
+				 int *protocol)
+{
+  if (!pthread_mutexattr::is_good_object (attr))
+    return EINVAL;
+  return ENOSYS;
+}
+
+extern "C" int
+pthread_mutexattr_getpshared (const pthread_mutexattr_t *attr,
+				int *pshared)
+{
+  if (!pthread_mutexattr::is_good_object (attr))
+    return EINVAL;
+  *pshared = (*attr)->pshared;
+  return 0;
+}
+
+extern "C" int
+pthread_mutexattr_gettype (const pthread_mutexattr_t *attr, int *type)
+{
+  if (!pthread_mutexattr::is_good_object (attr))
+    return EINVAL;
+  *type = (*attr)->mutextype;
+  return 0;
+}
+
+/* FIXME: write and test process shared mutex's.  */
+extern "C" int
+pthread_mutexattr_init (pthread_mutexattr_t *attr)
+{
+  if (pthread_mutexattr::is_good_object (attr))
+    return EBUSY;
+
+  *attr = new pthread_mutexattr ();
+  if (!pthread_mutexattr::is_good_object (attr))
+    {
+      delete (*attr);
+      *attr = NULL;
+      return ENOMEM;
+    }
+  return 0;
+}
+
+extern "C" int
+pthread_mutexattr_destroy (pthread_mutexattr_t *attr)
+{
+  if (!pthread_mutexattr::is_good_object (attr))
+    return EINVAL;
+  delete (*attr);
+  *attr = NULL;
+  return 0;
+}
+
+
+/* Win32 doesn't support mutex priorities */
+extern "C" int
+pthread_mutexattr_setprotocol (pthread_mutexattr_t *attr, int protocol)
+{
+  if (!pthread_mutexattr::is_good_object (attr))
+    return EINVAL;
+  return ENOSYS;
+}
+
+/* Win32 doesn't support mutex priorities */
+extern "C" int
+pthread_mutexattr_setprioceiling (pthread_mutexattr_t *attr,
+				    int prioceiling)
+{
+  if (!pthread_mutexattr::is_good_object (attr))
+    return EINVAL;
+  return ENOSYS;
+}
+
+extern "C" int
+pthread_mutexattr_getprioceiling (const pthread_mutexattr_t *attr,
+				    int *prioceiling)
+{
+  if (!pthread_mutexattr::is_good_object (attr))
+    return EINVAL;
+  return ENOSYS;
+}
+
+extern "C" int
+pthread_mutexattr_setpshared (pthread_mutexattr_t *attr, int pshared)
+{
+  if (!pthread_mutexattr::is_good_object (attr))
+    return EINVAL;
+  /* we don't use pshared for anything as yet. We need to test PROCESS_SHARED
+   *functionality
+   */
+  if (pshared != PTHREAD_PROCESS_PRIVATE)
+    return EINVAL;
+  (*attr)->pshared = pshared;
+  return 0;
+}
+
+/* see pthread_mutex_gettype */
+extern "C" int
+pthread_mutexattr_settype (pthread_mutexattr_t *attr, int type)
+{
+  if (!pthread_mutexattr::is_good_object (attr))
+    return EINVAL;
+
+  switch (type)
+    {
+    case PTHREAD_MUTEX_ERRORCHECK:
+    case PTHREAD_MUTEX_RECURSIVE:
+    case PTHREAD_MUTEX_NORMAL:
+      (*attr)->mutextype = type;
+      break;
+    default:
+      return EINVAL;
+    }
+
+  return 0;
+}
+
+/* Semaphores */
+
+/* static members */
+bool
+semaphore::is_good_object (sem_t const * sem)
+{
+  if (verifyable_object_isvalid (sem, SEM_MAGIC) != VALID_OBJECT)
+    return false;
+  return true;
+}
+
+int
+semaphore::init (sem_t *sem, int pshared, unsigned int value)
+{
+  /* opengroup calls this undefined */
+  if (is_good_object (sem))
+    return EBUSY;
+
+  if (value > SEM_VALUE_MAX)
+    return EINVAL;
+
+  *sem = new semaphore (pshared, value);
+
+  if (!is_good_object (sem))
+    {
+      delete (*sem);
+      *sem = NULL;
+      return EAGAIN;
+    }
+  return 0;
+}
+
+int
+semaphore::destroy (sem_t *sem)
+{
+  if (!is_good_object (sem))
+    return EINVAL;
+
+  /* FIXME - new feature - test for busy against threads... */
+
+  delete (*sem);
+  *sem = NULL;
+  return 0;
+}
+
+int
+semaphore::wait (sem_t *sem)
+{
+  pthread_testcancel ();
+
+  if (!is_good_object (sem))
+    {
+      set_errno (EINVAL);
+      return -1;
+    }
+
+  (*sem)->_wait ();
+  return 0;
+}
+
+int
+semaphore::trywait (sem_t *sem)
+{
+  if (!is_good_object (sem))
+    {
+      set_errno (EINVAL);
+      return -1;
+    }
+
+  return (*sem)->_trywait ();
+}
+
+int
+semaphore::post (sem_t *sem)
+{
+  if (!is_good_object (sem))
+    return EINVAL;
+
+  (*sem)->_post ();
+  return 0;
+}
+
+/* pthread_null */
+pthread *
+pthread_null::get_null_pthread ()
+{
+  /* because of weird entry points */
+  _instance.magic = 0;
+  return &_instance;
+}
+
+pthread_null::pthread_null ()
+{
+  attr.joinable = PTHREAD_CREATE_DETACHED;
+  /* Mark ourselves as invalid */
+  magic = 0;
+}
+
+pthread_null::~pthread_null ()
+{
+}
+
+void
+pthread_null::create (void *(*)(void *), pthread_attr *, void *)
+{
+}
+
+void
+pthread_null::exit (void *value_ptr)
+{
+  ExitThread (0);
+}
+
+int
+pthread_null::cancel ()
+{
+  return 0;
+}
+
+void
+pthread_null::testcancel ()
+{
+}
+
+int
+pthread_null::setcancelstate (int state, int *oldstate)
+{
+  return EINVAL;
+}
+
+int
+pthread_null::setcanceltype (int type, int *oldtype)
+{
+  return EINVAL;
+}
+
+void
+pthread_null::push_cleanup_handler (__pthread_cleanup_handler *handler)
+{
+}
+
+void
+pthread_null::pop_cleanup_handler (int const execute)
+{
+}
+
+unsigned long
+pthread_null::getsequence_np ()
+{
+  return 0;
+}
+
+pthread_null pthread_null::_instance;
diff --git a/winsup/cygwin/thread.h b/winsup/cygwin/thread.h
new file mode 100644
index 00000000000..a52c0b771c7
--- /dev/null
+++ b/winsup/cygwin/thread.h
@@ -0,0 +1,708 @@
+/* thread.h: Locking and threading module definitions
+
+   Copyright 1998, 1999, 2000, 2001, 2002, 2003 Red Hat, Inc.
+
+   Written by Marco Fuykschot <marco@ddi.nl>
+   Major update 2001 Robert Collins <rbtcollins@hotmail.com>
+
+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. */
+
+#ifndef _CYGNUS_THREADS_
+#define _CYGNUS_THREADS_
+
+#define LOCK_FD_LIST     1
+#define LOCK_MEMORY_LIST 2
+#define LOCK_MMAP_LIST   3
+#define LOCK_DLL_LIST    4
+
+#define WRITE_LOCK 1
+#define READ_LOCK  2
+
+extern "C"
+{
+#if defined (_CYG_THREAD_FAILSAFE) && defined (_MT_SAFE)
+  void AssertResourceOwner (int, int);
+#else
+#define AssertResourceOwner(i,ii)
+#endif
+}
+
+#ifndef _MT_SAFE
+
+#define SetResourceLock(i,n,c)
+#define ReleaseResourceLock(i,n,c)
+
+#else
+
+#include <pthread.h>
+#include <limits.h>
+#include <errno.h>
+#include <signal.h>
+#include <pwd.h>
+#include <grp.h>
+#define _NOMNTENT_FUNCS
+#include <mntent.h>
+
+extern "C"
+{
+
+struct _winsup_t
+{
+  /*
+     Needed for the group functions
+   */
+  struct __group16 _grp;
+  char *_namearray[2];
+  int _grp_pos;
+
+  /* console.cc */
+  unsigned _rarg;
+
+  /* dlfcn.cc */
+  int _dl_error;
+  char _dl_buffer[256];
+
+  /* passwd.cc */
+  struct passwd _res;
+  char _pass[_PASSWORD_LEN];
+  int _pw_pos;
+
+  /* path.cc */
+  struct mntent mntbuf;
+  int _iteration;
+  DWORD available_drives;
+  char mnt_type[80];
+  char mnt_opts[80];
+  char mnt_fsname[MAX_PATH];
+  char mnt_dir[MAX_PATH];
+
+  /* strerror */
+  char _strerror_buf[20];
+
+  /* sysloc.cc */
+  char *_process_ident;
+  int _process_logopt;
+  int _process_facility;
+  int _process_logmask;
+
+  /* times.cc */
+  char timezone_buf[20];
+  struct tm _localtime_buf;
+
+  /* uinfo.cc */
+  char _username[UNLEN + 1];
+
+  /* net.cc */
+  char *_ntoa_buf;
+  struct protoent *_protoent_buf;
+  struct servent *_servent_buf;
+  struct hostent *_hostent_buf;
+};
+
+
+struct __reent_t
+{
+  struct _reent *_clib;
+  struct _winsup_t *_winsup;
+  void init_clib (_reent&);
+};
+
+_winsup_t *_reent_winsup ();
+void SetResourceLock (int, int, const char *) __attribute__ ((regparm (3)));
+void ReleaseResourceLock (int, int, const char *)
+  __attribute__ ((regparm (3)));
+
+#ifdef _CYG_THREAD_FAILSAFE
+void AssertResourceOwner (int, int);
+#else
+#define AssertResourceOwner(i,ii)
+#endif
+}
+
+class native_mutex
+{
+public:
+  bool init ();
+  bool lock ();
+  void unlock ();
+private:
+  HANDLE theHandle;
+};
+
+class per_process;
+class pinfo;
+
+class ResourceLocks
+{
+public:
+  ResourceLocks ()
+  {
+  }
+  LPCRITICAL_SECTION Lock (int);
+  void Init ();
+  void Delete ();
+#ifdef _CYG_THREAD_FAILSAFE
+  DWORD owner;
+  DWORD count;
+#endif
+private:
+  CRITICAL_SECTION lock;
+  bool inited;
+};
+
+#define PTHREAD_MAGIC 0xdf0df045
+#define PTHREAD_MUTEX_MAGIC PTHREAD_MAGIC+1
+#define PTHREAD_KEY_MAGIC PTHREAD_MAGIC+2
+#define PTHREAD_ATTR_MAGIC PTHREAD_MAGIC+3
+#define PTHREAD_MUTEXATTR_MAGIC PTHREAD_MAGIC+4
+#define PTHREAD_COND_MAGIC PTHREAD_MAGIC+5
+#define PTHREAD_CONDATTR_MAGIC PTHREAD_MAGIC+6
+#define SEM_MAGIC PTHREAD_MAGIC+7
+#define PTHREAD_ONCE_MAGIC PTHREAD_MAGIC+8
+#define PTHREAD_RWLOCK_MAGIC PTHREAD_MAGIC+9
+#define PTHREAD_RWLOCKATTR_MAGIC PTHREAD_MAGIC+10
+
+#define MUTEX_OWNER_ANONYMOUS        ((pthread_t) -1)
+
+/* verifyable_object should not be defined here - it's a general purpose class */
+
+class verifyable_object
+{
+public:
+  long magic;
+
+  verifyable_object (long);
+  virtual ~verifyable_object ();
+};
+
+typedef enum
+{
+  VALID_OBJECT,
+  INVALID_OBJECT,
+  VALID_STATIC_OBJECT
+} verifyable_object_state;
+
+verifyable_object_state verifyable_object_isvalid (void const *, long);
+verifyable_object_state verifyable_object_isvalid (void const *, long, void *);
+
+template <class list_node> class List {
+public:
+  List() : head(NULL)
+  {
+  }
+
+  void insert (list_node *node)
+  {
+    if (!node)
+      return;
+    node->next = (list_node *) InterlockedExchangePointer (&head, node);
+  }
+
+  list_node *remove ( list_node *node)
+  {
+    if (!node || !head)
+      return NULL;
+    if (node == head)
+      return pop ();
+
+    list_node *result_prev = head;
+    while (result_prev && result_prev->next && !(node == result_prev->next))
+      result_prev = result_prev->next;
+    if (result_prev)
+      return (list_node *)InterlockedExchangePointer (&result_prev->next, result_prev->next->next);
+    return NULL;
+  }
+
+  list_node *pop ()
+  {
+    return (list_node *) InterlockedExchangePointer (&head, head->next);
+  }
+
+  /* poor mans generic programming. */
+  void for_each (void (list_node::*callback) ())
+  {
+    list_node *node = head;
+    while (node)
+      {
+        (node->*callback) ();
+        node = node->next;
+      }
+  }
+
+protected:
+  list_node *head;
+};
+
+class pthread_key:public verifyable_object
+{
+public:
+  static bool is_good_object (pthread_key_t const *);
+  DWORD tls_index;
+
+  int set (const void *);
+  void *get () const;
+
+  pthread_key (void (*)(void *));
+  ~pthread_key ();
+  static void fixup_before_fork()
+  {
+    keys.for_each (&pthread_key::save_key_to_buffer);
+  }
+
+  static void fixup_after_fork()
+  {
+    keys.for_each (&pthread_key::recreate_key_from_buffer);
+  }
+
+  static void run_all_destructors ()
+  {
+    keys.for_each (&pthread_key::run_destructor);
+  }
+
+  /* List support calls */
+  class pthread_key *next;
+private:
+  static List<pthread_key> keys;
+  void save_key_to_buffer ();
+  void recreate_key_from_buffer ();
+  void (*destructor) (void *);
+  void run_destructor ();
+  void *fork_buf;
+};
+
+class pthread_attr:public verifyable_object
+{
+public:
+  static bool is_good_object(pthread_attr_t const *);
+  int joinable;
+  int contentionscope;
+  int inheritsched;
+  struct sched_param schedparam;
+  size_t stacksize;
+
+  pthread_attr ();
+  ~pthread_attr ();
+};
+
+class pthread_mutexattr:public verifyable_object
+{
+public:
+  static bool is_good_object(pthread_mutexattr_t const *);
+  int pshared;
+  int mutextype;
+  pthread_mutexattr ();
+  ~pthread_mutexattr ();
+};
+
+class pthread_mutex:public verifyable_object
+{
+public:
+  static bool is_good_object (pthread_mutex_t const *);
+  static bool is_good_initializer (pthread_mutex_t const *);
+  static bool is_good_initializer_or_object (pthread_mutex_t const *);
+  static bool is_good_initializer_or_bad_object (pthread_mutex_t const *mutex);
+  static bool can_be_unlocked (pthread_mutex_t const *mutex);
+  static void init_mutex ();
+  static int init (pthread_mutex_t *, const pthread_mutexattr_t *);
+
+  unsigned long lock_counter;
+  HANDLE win32_obj_id;
+  unsigned int recursion_counter;
+  LONG condwaits;
+  pthread_t owner;
+  int type;
+  int pshared;
+
+  pthread_t get_pthread_self () const
+  {
+    return PTHREAD_MUTEX_NORMAL == type ? MUTEX_OWNER_ANONYMOUS :
+      ::pthread_self ();
+  }
+
+  int lock ()
+  {
+    return _lock (get_pthread_self ());
+  }
+  int trylock ()
+  {
+    return _trylock (get_pthread_self ());
+  }
+  int unlock ()
+  {
+    return _unlock (get_pthread_self ());
+  }
+  int destroy ()
+  {
+    return _destroy (get_pthread_self ());
+  }
+
+  void set_owner (pthread_t self)
+  {
+    recursion_counter = 1;
+    owner = self;
+  }
+
+  int lock_recursive ()
+  {
+    if (UINT_MAX == recursion_counter)
+      return EAGAIN;
+    ++recursion_counter;
+    return 0;
+  }
+
+  pthread_mutex (pthread_mutexattr * = NULL);
+  pthread_mutex (pthread_mutex_t *, pthread_mutexattr *);
+  ~pthread_mutex ();
+
+  class pthread_mutex * next;
+  static void fixup_after_fork ()
+  {
+    mutexes.for_each (&pthread_mutex::_fixup_after_fork);
+  }
+
+private:
+  int _lock (pthread_t self);
+  int _trylock (pthread_t self);
+  int _unlock (pthread_t self);
+  int _destroy (pthread_t self);
+
+  void _fixup_after_fork ();
+
+  static List<pthread_mutex> mutexes;
+  static native_mutex mutex_initialization_lock;
+};
+
+#define WAIT_CANCELED   (WAIT_OBJECT_0 + 1)
+
+class pthread:public verifyable_object
+{
+public:
+  HANDLE win32_obj_id;
+  class pthread_attr attr;
+  void *(*function) (void *);
+  void *arg;
+  void *return_ptr;
+  bool running;
+  bool suspended;
+  int cancelstate, canceltype;
+  HANDLE cancel_event;
+  pthread_t joiner;
+
+  /* signal handling */
+  struct sigaction *sigs;
+  sigset_t *sigmask;
+  LONG *sigtodo;
+  virtual void create (void *(*)(void *), pthread_attr *, void *);
+
+  pthread ();
+  virtual ~pthread ();
+
+  static void init_mainthread ();
+  static bool is_good_object(pthread_t const *);
+  static void atforkprepare();
+  static void atforkparent();
+  static void atforkchild();
+
+  /* API calls */
+  static int cancel (pthread_t);
+  static int join (pthread_t * thread, void **return_val);
+  static int detach (pthread_t * thread);
+  static int create (pthread_t * thread, const pthread_attr_t * attr,
+			      void *(*start_routine) (void *), void *arg);
+  static int once (pthread_once_t *, void (*)(void));
+  static int atfork(void (*)(void), void (*)(void), void (*)(void));
+  static int suspend (pthread_t * thread);
+  static int resume (pthread_t * thread);
+
+  virtual void exit (void *value_ptr);
+
+  virtual int cancel ();
+
+  virtual void testcancel ();
+  static void static_cancel_self ();
+
+  static DWORD cancelable_wait (HANDLE object, DWORD timeout, const bool do_cancel = true);
+
+  virtual int setcancelstate (int state, int *oldstate);
+  virtual int setcanceltype (int type, int *oldtype);
+
+  virtual void push_cleanup_handler (__pthread_cleanup_handler *handler);
+  virtual void pop_cleanup_handler (int const execute);
+
+  static pthread* self ();
+  static void *thread_init_wrapper (void *);
+
+  virtual unsigned long getsequence_np();
+
+  static int equal (pthread_t t1, pthread_t t2)
+  {
+    return t1 == t2;
+  }
+
+  /* List support calls */
+  class pthread *next;
+  static void fixup_after_fork ()
+  {
+    threads.for_each (&pthread::_fixup_after_fork);
+  }
+
+private:
+  static List<pthread> threads;
+  DWORD thread_id;
+  __pthread_cleanup_handler *cleanup_stack;
+  pthread_mutex mutex;
+
+  void _fixup_after_fork ();
+
+  void pop_all_cleanup_handlers (void);
+  void precreate (pthread_attr *);
+  void postcreate ();
+  void set_thread_id_to_current ();
+  static void set_tls_self_pointer (pthread *);
+  static pthread *get_tls_self_pointer ();
+  void cancel_self ();
+  DWORD get_thread_id ();
+  void init_current_thread ();
+};
+
+class pthread_null : public pthread
+{
+  public:
+  static pthread *get_null_pthread();
+  ~pthread_null();
+
+  /* From pthread These should never get called
+  * as the ojbect is not verifyable
+  */
+  void create (void *(*)(void *), pthread_attr *, void *);
+  void exit (void *value_ptr);
+  int cancel ();
+  void testcancel ();
+  int setcancelstate (int state, int *oldstate);
+  int setcanceltype (int type, int *oldtype);
+  void push_cleanup_handler (__pthread_cleanup_handler *handler);
+  void pop_cleanup_handler (int const execute);
+  unsigned long getsequence_np();
+
+  private:
+  pthread_null ();
+  static pthread_null _instance;
+};
+
+class pthread_condattr:public verifyable_object
+{
+public:
+  static bool is_good_object(pthread_condattr_t const *);
+  int shared;
+
+  pthread_condattr ();
+  ~pthread_condattr ();
+};
+
+class pthread_cond:public verifyable_object
+{
+public:
+  static bool is_good_object (pthread_cond_t const *);
+  static bool is_good_initializer (pthread_cond_t const *);
+  static bool is_good_initializer_or_object (pthread_cond_t const *);
+  static bool is_good_initializer_or_bad_object (pthread_cond_t const *);
+  static void init_mutex ();
+  static int init (pthread_cond_t *, const pthread_condattr_t *);
+
+  int shared;
+
+  unsigned long waiting;
+  unsigned long pending;
+  HANDLE sem_wait;
+
+  pthread_mutex mtx_in;
+  pthread_mutex mtx_out;
+
+  pthread_mutex_t mtx_cond;
+
+  void unblock (const bool all);
+  int wait (pthread_mutex_t mutex, DWORD dwMilliseconds = INFINITE);
+
+  pthread_cond (pthread_condattr *);
+  ~pthread_cond ();
+
+  class pthread_cond * next;
+  static void fixup_after_fork ()
+  {
+    conds.for_each (&pthread_cond::_fixup_after_fork);
+  }
+
+private:
+  void _fixup_after_fork ();
+
+  static List<pthread_cond> conds;
+  static native_mutex cond_initialization_lock;
+};
+
+class pthread_rwlockattr:public verifyable_object
+{
+public:
+  static bool is_good_object(pthread_rwlockattr_t const *);
+  int shared;
+
+  pthread_rwlockattr ();
+  ~pthread_rwlockattr ();
+};
+
+class pthread_rwlock:public verifyable_object
+{
+public:
+  static bool is_good_object (pthread_rwlock_t const *);
+  static bool is_good_initializer (pthread_rwlock_t const *);
+  static bool is_good_initializer_or_object (pthread_rwlock_t const *);
+  static bool is_good_initializer_or_bad_object (pthread_rwlock_t const *);
+  static void init_mutex ();
+  static int init (pthread_rwlock_t *, const pthread_rwlockattr_t *);
+
+  int shared;
+
+  unsigned long waiting_readers;
+  unsigned long waiting_writers;
+  pthread_t writer;
+  struct RWLOCK_READER
+  {
+    struct RWLOCK_READER *next;
+    pthread_t thread;
+  } *readers;
+
+  int rdlock ();
+  int tryrdlock ();
+
+  int wrlock ();
+  int trywrlock ();
+
+  int unlock ();
+
+  pthread_mutex mtx;
+  pthread_cond cond_readers;
+  pthread_cond cond_writers;
+
+  pthread_rwlock (pthread_rwlockattr *);
+  ~pthread_rwlock ();
+
+  class pthread_rwlock * next;
+  static void fixup_after_fork ()
+  {
+    rwlocks.for_each (&pthread_rwlock::_fixup_after_fork);
+  }
+
+private:
+  static List<pthread_rwlock> rwlocks;
+
+  void add_reader (struct RWLOCK_READER *rd);
+  void remove_reader (struct RWLOCK_READER *rd);
+  struct RWLOCK_READER *lookup_reader (pthread_t thread);
+
+  void release ()
+  {
+    if (waiting_writers)
+      {
+        if (!readers)
+          cond_writers.unblock (false);
+      }
+    else if (waiting_readers)
+      cond_readers.unblock (true);
+  }
+
+
+  static void rdlock_cleanup (void *arg);
+  static void wrlock_cleanup (void *arg);
+
+  void _fixup_after_fork ();
+
+  static native_mutex rwlock_initialization_lock;
+};
+
+class pthread_once
+{
+public:
+  pthread_mutex_t mutex;
+  int state;
+};
+
+/* shouldn't be here */
+class semaphore:public verifyable_object
+{
+public:
+  static bool is_good_object(sem_t const *);
+  /* API calls */
+  static int init (sem_t * sem, int pshared, unsigned int value);
+  static int destroy (sem_t * sem);
+  static int wait (sem_t * sem);
+  static int trywait (sem_t * sem);
+  static int post (sem_t * sem);
+
+  HANDLE win32_obj_id;
+  int shared;
+  long currentvalue;
+
+  semaphore (int, unsigned int);
+  ~semaphore ();
+
+  class semaphore * next;
+  static void fixup_after_fork ()
+  {
+    semaphores.for_each (&semaphore::_fixup_after_fork);
+  }
+
+private:
+  void _wait ();
+  void _post ();
+  int _trywait ();
+
+  void _fixup_after_fork ();
+
+  static List<semaphore> semaphores;
+};
+
+class callback
+{
+public:
+  void (*cb)(void);
+  class callback * next;
+};
+
+class MTinterface
+{
+public:
+  // General
+  int concurrency;
+  long int threadcount;
+
+  // Used for main thread data, and sigproc thread
+  struct __reent_t reents;
+  struct _winsup_t winsup_reent;
+
+  callback *pthread_prepare;
+  callback *pthread_child;
+  callback *pthread_parent;
+
+  pthread_key reent_key;
+  pthread_key thread_self_key;
+
+  void Init ();
+  void fixup_before_fork (void);
+  void fixup_after_fork (void);
+
+  MTinterface () :
+    concurrency (0), threadcount (1),
+    pthread_prepare (NULL), pthread_child (NULL), pthread_parent (NULL),
+    reent_key (NULL), thread_self_key (NULL)
+  {
+  }
+};
+
+#define MT_INTERFACE user_data->threadinterface
+
+#endif // MT_SAFE
+
+#endif // _CYGNUS_THREADS_