revert previous not-ready-for-primetime checkin.

diff --git a/winsup/cygwin/cygthread.h b/winsup/cygwin/cygthread.h
index cc8dbc9..9d10bb2 100644 (file)
--- a/winsup/cygwin/cygthread.h
+++ b/winsup/cygwin/cygthread.h
@@ -41,7 +41,6 @@ class cygthread
     (void) CloseHandle (h);
     h = NULL;
   }
-  DWORD tid () const {return id;}
 };
 
 #define cygself NULL

diff --git a/winsup/cygwin/fhandler_socket.cc b/winsup/cygwin/fhandler_socket.cc
index 56b068c..aee32ac 100644 (file)
--- a/winsup/cygwin/fhandler_socket.cc
+++ b/winsup/cygwin/fhandler_socket.cc
@@ -32,7 +32,6 @@
 #include "sigproc.h"
 #include "cygthread.h"
 #include "select.h"
-#include "wininfo.h"
 #include <unistd.h>
 
 extern bool fdsock (cygheap_fdmanip& fd, const device *, SOCKET soc);
@@ -1375,7 +1374,7 @@ fhandler_socket::ioctl (unsigned int cmd, void *p)
        break;
       }
     case FIOASYNC:
-      res = WSAAsyncSelect (get_socket (), winmsg, WM_ASYNCIO,
+      res = WSAAsyncSelect (get_socket (), gethwnd (), WM_ASYNCIO,
              *(int *) p ? ASYNC_MASK : 0);
       syscall_printf ("Async I/O on socket %s",
              *(int *) p ? "started" : "cancelled");
@@ -1391,7 +1390,7 @@ fhandler_socket::ioctl (unsigned int cmd, void *p)
        * blocking mode
        */
       if (cmd == FIONBIO && *(int *) p == 0)
-       WSAAsyncSelect (get_socket (), winmsg, 0, 0);
+       WSAAsyncSelect (get_socket (), gethwnd (), 0, 0);
       res = ioctlsocket (get_socket (), cmd, (unsigned long *) p);
       if (res == SOCKET_ERROR)
          set_winsock_errno ();
@@ -1401,7 +1400,7 @@ fhandler_socket::ioctl (unsigned int cmd, void *p)
                            *(int *) p ? "non" : "");
          /* Start AsyncSelect if async socket unblocked */
          if (*(int *) p && async_io ())
-           WSAAsyncSelect (get_socket (), winmsg, WM_ASYNCIO, ASYNC_MASK);
+           WSAAsyncSelect (get_socket (), gethwnd (), WM_ASYNCIO, ASYNC_MASK);
 
          set_nonblocking (*(int *) p);
        }

diff --git a/winsup/cygwin/sync.cc b/winsup/cygwin/sync.cc
index b3eacd9..bd89793 100644 (file)
--- a/winsup/cygwin/sync.cc
+++ b/winsup/cygwin/sync.cc
@@ -125,16 +125,6 @@ muto::release ()
         threads waiting for the lock, so trigger bruteforce.  */
       if (InterlockedDecrement (&waiters) >= 0)
        (void) SetEvent (bruteforce); /* Wake up one of the waiting threads */
-      else if (*name == '!')
-       {
-         CloseHandle (bruteforce);     /* If *name == '!' and there are no
-                                          other waiters, then this is the
-                                          last time this muto will ever be
-                                          used, so close the handle. */
-#ifdef DEBUGGING
-         bruteforce = NULL;
-#endif
-       }
     }
 
   return 1;    /* success. */

diff --git a/winsup/cygwin/sync.h b/winsup/cygwin/sync.h
index 32ca147..24de974 100644 (file)
--- a/winsup/cygwin/sync.h
+++ b/winsup/cygwin/sync.h
@@ -38,6 +38,7 @@ public:
   /* Return true if caller thread owns the lock. */
   int ismine () {return tid == GetCurrentThreadId ();}
   DWORD owner () {return tid;}
+  int unstable () {return !tid && (sync || waiters >= 0);}
   void reset () __attribute__ ((regparm (1)));
   bool acquired ();
   static void set_exiting_thread () {exiting_thread = GetCurrentThreadId ();}
@@ -58,11 +59,4 @@ extern muto muto_start;
   static muto __storage __attribute__((nocommon)) __attribute__((section(".data_cygwin_nocopy1"))); \
   __name = __storage.init (#__name); \
 })
-
-/* Use a statically allocated buffer as the storage for a muto */
-#define new_muto_name(__var, __name) \
-({ \
-  static muto __var##_storage __attribute__((nocommon)) __attribute__((section(".data_cygwin_nocopy1"))); \
-  __var = __var##_storage.init (__name); \
-})
 #endif /*_SYNC_H*/

diff --git a/winsup/cygwin/window.cc b/winsup/cygwin/window.cc
index 554be3a..d005ae6 100644 (file)
--- a/winsup/cygwin/window.cc
+++ b/winsup/cygwin/window.cc
@@ -24,21 +24,14 @@ details. */
 #include "perprocess.h"
 #include "security.h"
 #include "cygthread.h"
-#include "sync.h"
-static DWORD WINAPI winthread (VOID *);
-#include "wininfo.h"
 
-wininfo NO_COPY winmsg;
+static NO_COPY UINT timer_active = 0;
+static NO_COPY struct itimerval itv;
+static NO_COPY DWORD start_time;
+static NO_COPY HWND ourhwnd = NULL;
 
-muto NO_COPY *wininfo::lock;
-
-wininfo::wininfo ()
-{
-  new_muto_name (lock, "!winlock");
-}
-
-int __stdcall
-wininfo::process (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+static LRESULT CALLBACK
+WndProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 {
 #ifndef NOSTRACE
   strace.wm (uMsg, wParam, lParam);
@@ -57,7 +50,9 @@ wininfo::process (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
                        itv.it_interval.tv_usec / 1000;
          KillTimer (hwnd, timer_active);
          if (!elapse)
-           timer_active = 0;
+           {
+             timer_active = 0;
+           }
          else
            {
              timer_active = SetTimer (hwnd, 1, elapse, NULL);
@@ -78,15 +73,10 @@ wininfo::process (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
     }
 }
 
-static LRESULT CALLBACK
-process_window_events (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
-{
-  return winmsg.process (hwnd, uMsg, wParam, lParam);
-}
+static HANDLE window_started;
 
-/* Handle windows events.  Inherits ownership of the wininfo lock */
 static DWORD WINAPI
-winthread (VOID *arg)
+Winmain (VOID *)
 {
   MSG msg;
   WNDCLASS wc;
@@ -95,7 +85,7 @@ winthread (VOID *arg)
   /* Register the window class for the main window. */
 
   wc.style = 0;
-  wc.lpfnWndProc = (WNDPROC) process_window_events;
+  wc.lpfnWndProc = (WNDPROC) WndProc;
   wc.cbClsExtra = 0;
   wc.cbWndExtra = 0;
   wc.hInstance = user_data->hmodule;
@@ -106,64 +96,60 @@ winthread (VOID *arg)
   wc.lpszClassName = classname;
 
   if (!RegisterClass (&wc))
-    api_fatal ("cannot register window class, %E");
+    {
+      system_printf ("Cannot register window class, %E");
+      return FALSE;
+    }
 
-  wininfo *wi = (wininfo *) arg;
   /* Create hidden window. */
-  wi->hwnd = CreateWindow (classname, classname, WS_POPUP, CW_USEDEFAULT,
-                          CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
-                          (HWND) NULL, (HMENU) NULL, user_data->hmodule,
-                          (LPVOID) NULL);
-  if (!wi->hwnd)
-    api_fatal ("couldn't create window, %E");
-  wi->lock->release ();
-
-  while (GetMessage (&msg, (HWND) arg, 0, 0) == TRUE)
+  ourhwnd = CreateWindow (classname, classname, WS_POPUP, CW_USEDEFAULT,
+                         CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
+                         (HWND) NULL, (HMENU) NULL, user_data->hmodule,
+                         (LPVOID) NULL);
+
+  SetEvent (window_started);
+
+  if (!ourhwnd)
+    {
+      system_printf ("Cannot create window");
+      return FALSE;
+    }
+
+  /* Start the message loop. */
+
+  while (GetMessage (&msg, ourhwnd, 0, 0) == TRUE)
     DispatchMessage (&msg);
 
   return 0;
 }
 
-wininfo::operator
-HWND ()
+HWND __stdcall
+gethwnd ()
 {
-  if (hwnd)
-    return hwnd;
-
-console_printf ("hwnd is NULL\n");
-  lock->acquire ();
-  if (hwnd)
-    {
-console_printf ("hwnd acquired %p\n", hwnd);
-      lock->release ();
-      return  hwnd;
-    }
+  if (ourhwnd != NULL)
+    return ourhwnd;
 
-console_printf ("creating window\n");
+  cygthread *h;
 
-  cygthread *h = new cygthread (winthread, this, "win");
+  window_started = CreateEvent (&sec_none_nih, TRUE, FALSE, NULL);
+  h = new cygthread (Winmain, NULL, "win");
   h->SetThreadPriority (THREAD_PRIORITY_HIGHEST);
+  WaitForSingleObject (window_started, INFINITE);
+  CloseHandle (window_started);
   h->zap_h ();
-  while (!hwnd)
-    low_priority_sleep (0);
-  return hwnd;
+  return ourhwnd;
 }
 
 extern "C" int
 setitimer (int which, const struct itimerval *value, struct itimerval *oldvalue)
 {
+  UINT elapse;
+
   if (which != ITIMER_REAL)
     {
       set_errno (ENOSYS);
       return -1;
     }
-  return winmsg.setitimer (value, oldvalue);
-}
-
-/* FIXME: Very racy */
-int __stdcall
-wininfo::setitimer (const struct itimerval *value, struct itimerval *oldvalue)
-{
   /* Check if we will wrap */
   if (itv.it_value.tv_sec >= (long) (UINT_MAX / 1000))
     {
@@ -172,7 +158,7 @@ wininfo::setitimer (const struct itimerval *value, struct itimerval *oldvalue)
     }
   if (timer_active)
     {
-      KillTimer (winmsg, timer_active);
+      KillTimer (gethwnd (), timer_active);
       timer_active = 0;
     }
   if (oldvalue)
@@ -183,13 +169,13 @@ wininfo::setitimer (const struct itimerval *value, struct itimerval *oldvalue)
       return -1;
     }
   itv = *value;
-  UINT elapse = itv.it_value.tv_sec * 1000 + itv.it_value.tv_usec / 1000;
+  elapse = itv.it_value.tv_sec * 1000 + itv.it_value.tv_usec / 1000;
   if (elapse == 0)
     if (itv.it_value.tv_usec)
       elapse = 1;
     else
       return 0;
-  if (!(timer_active = SetTimer (winmsg, 1, elapse, NULL)))
+  if (!(timer_active = SetTimer (gethwnd (), 1, elapse, NULL)))
     {
       __seterrno ();
       return -1;
@@ -201,6 +187,8 @@ wininfo::setitimer (const struct itimerval *value, struct itimerval *oldvalue)
 extern "C" int
 getitimer (int which, struct itimerval *value)
 {
+  UINT elapse, val;
+
   if (which != ITIMER_REAL)
     {
       set_errno (EINVAL);
@@ -211,13 +199,6 @@ getitimer (int which, struct itimerval *value)
       set_errno (EFAULT);
       return -1;
     }
-  return winmsg.getitimer (value);
-}
-
-/* FIXME: racy */
-int __stdcall
-wininfo::getitimer (struct itimerval *value)
-{
   *value = itv;
   if (!timer_active)
     {
@@ -225,9 +206,6 @@ wininfo::getitimer (struct itimerval *value)
       value->it_value.tv_usec = 0;
       return 0;
     }
-
-  UINT elapse, val;
-
   elapse = GetTickCount () - start_time;
   val = itv.it_value.tv_sec * 1000 + itv.it_value.tv_usec / 1000;
   val -= elapse;

diff --git a/winsup/cygwin/winsup.h b/winsup/cygwin/winsup.h
index cd698ba..4c57c37 100644 (file)
--- a/winsup/cygwin/winsup.h
+++ b/winsup/cygwin/winsup.h
@@ -217,6 +217,8 @@ void events_terminate (void);
 
 void __stdcall close_all_files ();
 
+/* Invisible window initialization/termination. */
+HWND __stdcall gethwnd (void);
 /* Check if running in a visible window station. */
 extern bool has_visible_window_station (void);