Changeset 15148

Timestamp:

Dec 21, 2011, 10:35:27 AM (13 years ago)

Author:

Gary Byers

Message:

Try to fix ticket:862 and some related problems.

If GetThreadContext() claims that we've suspended a thread at a UUO,
don't interpret that as "about to execute the UUO"; we may have executed
the UUO and not have reentered user mode, and there seems to be reason
to believe that setting the thread's context while it's suspended won't
have the desired effect. Set the tcr's "pending suspend" bit and resume
the thread in this case. Note that there are other situations where
we may be in the process of taking an exception but it's much harder
to tell (e.g., if the instruction causes a memory fault or arithmetic
exception or ...); it'd be nicer if there was a reliable way to detect
that. Win32 doesn't seem to have this problem at all, AFAICT.

If we let a thread continue until it reaches the exception handler and
checks the pending suspend bit, don't set its tcr.suspend_context slot.
When resuming such a thread, just raise its resume semaphore.

Do a little more pc-lusering when suspending Windows threads, e.g.,
if suspended in the first few instructions of restore_windows_context(),
emulate the effect of those instructions.

File:

• trunk/source/lisp-kernel/thread_manager.c (modified) (4 diffs)

trunk/source/lisp-kernel/thread_manager.c

@@ -2027 +2027 @@
     where = (pc)(xpPC(pcontext));
 
+    if ((where >= restore_windows_context_start) &&
+        (where < restore_windows_context_end) &&
+        (tcr->valence != TCR_STATE_LISP)) {
+#ifdef WIN_64
+      tcr->valence = xpGPR(pcontext,REG_R8);
+#else
+      tcr->valence = ((LispObj *)(xpGPR(pcontext,Isp)))[3];
+#endif
+      pcontext = tcr->pending_exception_context;
+      tcr->pending_exception_context = NULL; 
+      where = (pc)(xpPC(pcontext));
+    }
     if (tcr->valence == TCR_STATE_LISP) {
       if ((where >= restore_windows_context_start) &&
@@ -2061 +2073 @@
           ResumeThread(hthread);
           SEM_WAIT_FOREVER(TCR_AUX(tcr)->suspend);
-          SuspendThread(hthread);
-          /* The thread is either waiting for its resume semaphore to
-             be signaled or is about to wait.  Signal it now, while
-             the thread's suspended. */
-          SEM_RAISE(TCR_AUX(tcr)->resume);
-          pcontext->ContextFlags = CONTEXT_ALL;
-          GetThreadContext(hthread, pcontext);
+          pcontext = NULL;
         }
       }
-#if 0
-    } else {
-      if (tcr->valence == TCR_STATE_EXCEPTION_RETURN) {
-        if (!tcr->pending_exception_context) {
-          FBug(pcontext, "we're confused here.");
-        }
-        *pcontext = *tcr->pending_exception_context;
-        tcr->pending_exception_context = NULL;
-        tcr->valence = TCR_STATE_LISP;
-      }
-#endif
+    }
+    /* If we're really running lisp code, there's some reason to
+       suspect that Windows is lying about that; the thread may have
+       already committed to processing an exception and just not have
+       reentered user mode.  If there's a way to determine that more
+       reliably, I don't know what it is.  We can catch some cases of
+       that by looking at whether the PC is at a UUO or other
+       "intentional" illegal instruction and letting the thread enter
+       exception handling, treating this case just like the case
+       above.  
+
+       When people say that Windows sucks, they aren't always just
+       talking about all of the other ways that it sucks.
+    */
+    if ((*where == INTN_OPCODE) ||
+        ((*where == XUUO_OPCODE_0) && (where[1] == XUUO_OPCODE_1))) {
+      SET_TCR_FLAG(tcr,TCR_FLAG_BIT_PENDING_SUSPEND);
+      ResumeThread(hthread);
+      SEM_WAIT_FOREVER(TCR_AUX(tcr)->suspend);
+      pcontext = NULL;
     }
     TCR_AUX(tcr)->suspend_context = pcontext;
@@ -2194 +2209 @@
     HANDLE hthread = (HANDLE)(TCR_AUX(tcr)->osid);
 
+
+    TCR_AUX(tcr)->suspend_context = NULL;
     if (context) {
-      context->ContextFlags = CONTEXT_ALL;
-      TCR_AUX(tcr)->suspend_context = NULL;
-      SetThreadContext(hthread,context);
+      if (tcr->valence == TCR_STATE_LISP) {
+        rc = SetThreadContext(hthread,context);
+        if (! rc) {
+          Bug(NULL,"SetThreadContext");
+          return false;
+        }
+      }
       rc = ResumeThread(hthread);
       if (rc == -1) {
-        wperror("ResumeThread");
+        Bug(NULL,"ResumeThread");
         return false;
       }
+      return true;
+    } else {
+      SEM_RAISE(TCR_AUX(tcr)->resume);
       return true;
     }
@@ -2354 +2378 @@
 {
   TCR *current = get_tcr(true), *other;
+
   for (other = TCR_AUX(current)->next; other != current; other = TCR_AUX(other)->next) {
     if ((TCR_AUX(other)->osid != 0)) {