From d3bda1df95dd1e368ec03b1a1b9e3f0260b4cbfc Mon Sep 17 00:00:00 2001 From: Christopher Faylor Date: Thu, 24 Feb 2000 19:54:01 +0000 Subject: [PATCH] * exceptions.cc (call_handler): Use new muto linked list to look for all potential mutos owned by suspended thread. Clear waiting threads while thread is stopped. (proc_subproc): Clarify debugging output. * sync.h (class muto): Add 'next' field. (new_muto): Keep linked list alive. --- winsup/cygwin/ChangeLog | 9 +++++++++ winsup/cygwin/exceptions.cc | 18 ++++++++++++------ winsup/cygwin/sigproc.cc | 5 ++++- winsup/cygwin/sync.cc | 4 +++- winsup/cygwin/sync.h | 12 ++++++++---- 5 files changed, 36 insertions(+), 12 deletions(-) diff --git a/winsup/cygwin/ChangeLog b/winsup/cygwin/ChangeLog index bfa930b21..636d59b60 100644 --- a/winsup/cygwin/ChangeLog +++ b/winsup/cygwin/ChangeLog @@ -1,3 +1,12 @@ +Thu Feb 24 14:45:06 2000 Christopher Faylor + + * exceptions.cc (call_handler): Use new muto linked list to look for + all potential mutos owned by suspended thread. Clear waiting threads + while thread is stopped. + (proc_subproc): Clarify debugging output. + * sync.h (class muto): Add 'next' field. + (new_muto): Keep linked list alive. + Thu Feb 24 00:59:15 2000 Christopher Faylor Fix final round of gcc warnings relating to unused parameters. diff --git a/winsup/cygwin/exceptions.cc b/winsup/cygwin/exceptions.cc index 4176f66cc..3213aa972 100644 --- a/winsup/cygwin/exceptions.cc +++ b/winsup/cygwin/exceptions.cc @@ -713,7 +713,6 @@ call_handler (int sig, struct sigaction& siga, void *handler) CONTEXT *cx, orig; int interrupted = 1; int res; - extern muto *sync_proc_subproc; if (hExeced != NULL && hExeced != INVALID_HANDLE_VALUE) { @@ -743,10 +742,13 @@ call_handler (int sig, struct sigaction& siga, void *handler) goto set_pending; /* FIXME: Make multi-thread aware */ - if (!sync_proc_subproc->unstable () && sync_proc_subproc->owner () != maintid && - !mask_sync->unstable () && mask_sync->owner () != maintid) - break; + for (muto *m = muto_start.next; m != NULL; m = m->next) + if (m->unstable () || m->owner () == maintid) + goto keep_looping; + break; + + keep_looping: ResumeThread (hth); Sleep (0); } @@ -781,12 +783,16 @@ call_handler (int sig, struct sigaction& siga, void *handler) interrupted = 0; } - (void) ResumeThread (hth); - if (interrupted) { /* Clear any waiting threads prior to dispatching to handler function */ proc_subproc(PROC_CLEARWAIT, 1); + } + + (void) ResumeThread (hth); + + if (interrupted) + { /* Apparently we have to set signal_arrived after resuming the thread or it is possible that the event will be ignored. */ (void) SetEvent (signal_arrived); // For an EINTR case diff --git a/winsup/cygwin/sigproc.cc b/winsup/cygwin/sigproc.cc index 7c1f449ed..9698a2362 100644 --- a/winsup/cygwin/sigproc.cc +++ b/winsup/cygwin/sigproc.cc @@ -333,7 +333,10 @@ proc_subproc (DWORD what, DWORD val) */ case PROC_CLEARWAIT: /* Clear all "wait"ing threads. */ - sip_printf ("clear waiting threads"); + if (val) + sip_printf ("clear waiting threads"); + else + sip_printf ("looking for processes to reap"); clearing = val; scan_wait: diff --git a/winsup/cygwin/sync.cc b/winsup/cygwin/sync.cc index f9edb9935..744eb8dc7 100644 --- a/winsup/cygwin/sync.cc +++ b/winsup/cygwin/sync.cc @@ -21,8 +21,10 @@ details. */ #include #include "winsup.h" +muto muto_start (0, 0); + /* Constructor */ -muto::muto(int inh, const char *name) : sync (0), visits(0), waiters(-1), tid (0) +muto::muto(int inh, const char *name) : sync (0), visits(0), waiters(-1), tid (0), next (0) { /* Create event which is used in the fallback case when blocking is necessary */ if (!(bruteforce = CreateEvent (inh ? &sec_all_nih : &sec_none_nih, FALSE, FALSE, name))) diff --git a/winsup/cygwin/sync.h b/winsup/cygwin/sync.h index 3dcc915da..7215c2bd7 100644 --- a/winsup/cygwin/sync.h +++ b/winsup/cygwin/sync.h @@ -20,6 +20,7 @@ class muto HANDLE bruteforce; /* event handle used to control waiting for lock. */ DWORD tid; /* Thread Id of lock owner. */ public: + class muto *next; void *operator new (size_t, void *p) {return p;} void *operator new (size_t) {return ::new muto; } void operator delete (void *) {;} /* can't handle allocated mutos @@ -27,7 +28,7 @@ public: /* This simple constructor is used for cases where no bruteforce event handling is required. */ - muto(): sync(0), visits(0), waiters(-1), bruteforce(0), tid(0) {;} + muto(): sync(0), visits(0), waiters(-1), bruteforce(0), tid(0), next (0) {;} /* A more complicated constructor. */ muto(int inh, const char *name); ~muto (); @@ -40,11 +41,14 @@ public: int unstable () {return !tid && (sync || waiters >= 0);} }; +extern muto muto_start; + /* Use a statically allocated buffer as the storage for a muto */ #define new_muto(__inh, __name) \ ({ \ static NO_COPY char __mbuf[sizeof(class muto) + 100] = {0}; \ - muto *m; \ - m = new (__mbuf) muto ((__inh), (__name)); \ - m; \ + muto *m = muto_start.next; \ + muto_start.next = new (__mbuf) muto ((__inh), (__name)); \ + muto_start.next->next = m; \ + muto_start.next; \ })