Changeset 215634 in webkit for trunk/Source/JavaScriptCore/runtime/VMTraps.cpp

Timestamp:

Apr 21, 2017, 1:31:39 PM (8 years ago)

Author:

[email protected]

Message:

Unreviewed, rolling out r215620 and r215623.
​https://bugs.webkit.org/show_bug.cgi?id=171139

broke arm64 build (Requested by keith_miller on #webkit).

Reverted changesets:

"Add signaling API"
​https://bugs.webkit.org/show_bug.cgi?id=170976
​http://trac.webkit.org/changeset/215620

"Unreviewed, fix Cloop build."
​http://trac.webkit.org/changeset/215623

File:

• trunk/Source/JavaScriptCore/runtime/VMTraps.cpp (modified) (5 diffs)

trunk/Source/JavaScriptCore/runtime/VMTraps.cpp

@@ -41 +41 @@
 #include "Watchdog.h"
 #include <wtf/ProcessID.h>
-#include <wtf/ThreadMessage.h>
-#include <wtf/threads/Signals.h>
+
+#if OS(DARWIN)
+#include <signal.h>
+#endif
 
 namespace JSC {
@@ -52 +54 @@
 
 #if ENABLE(SIGNAL_BASED_VM_TRAPS)
+
+struct sigaction originalSigusr1Action;
+struct sigaction originalSigtrapAction;
 
 struct SignalContext {
@@ -128 +133 @@
 }
 
-static void installSignalHandler()
-{
-    installSignalHandler(Signal::Trap, [] (int, siginfo_t*, void* uap) -> SignalAction {
-        SignalContext context(static_cast<ucontext_t*>(uap)->uc_mcontext);
-
-        if (!isJITPC(context.trapPC))
-            return SignalAction::NotHandled;
-
-        // FIXME: This currently eats all traps including jit asserts we should make sure this
-        // always works. https://bugs.webkit.org/show_bug.cgi?id=171039
-        auto activeVMAndStackBounds = findActiveVMAndStackBounds(context);
-        if (!activeVMAndStackBounds)
-            return SignalAction::Handled; // Let the SignalSender try again later.
-
+static void handleSigusr1(int signalNumber, siginfo_t* info, void* uap)
+{
+    SignalContext context(static_cast<ucontext_t*>(uap)->uc_mcontext);
+    auto activeVMAndStackBounds = findActiveVMAndStackBounds(context);
+    if (activeVMAndStackBounds) {
         VM* vm = activeVMAndStackBounds.value().vm;
         if (vm) {
+            StackBounds stackBounds = activeVMAndStackBounds.value().stackBounds;
             VMTraps& traps = vm->traps();
-            if (!traps.needTrapHandling())
-                return SignalAction::Handled; // The polling code beat us to handling the trap already.
-
-            auto expectedSuccess = traps.tryJettisonCodeBlocksOnStack(context);
-            if (!expectedSuccess)
-                return SignalAction::Handled; // Let the SignalSender try again later.
-            if (expectedSuccess.value())
-                return SignalAction::Handled; // We've success jettison the codeBlocks.
-        }
-
-        return SignalAction::Handled;
-    });
+            if (traps.needTrapHandling())
+                traps.tryInstallTrapBreakpoints(context, stackBounds);
+        }
+    }
+
+    auto originalAction = originalSigusr1Action.sa_sigaction;
+    if (originalAction)
+        originalAction(signalNumber, info, uap);
+}
+
+static void handleSigtrap(int signalNumber, siginfo_t* info, void* uap)
+{
+    SignalContext context(static_cast<ucontext_t*>(uap)->uc_mcontext);
+    auto activeVMAndStackBounds = findActiveVMAndStackBounds(context);
+    if (!activeVMAndStackBounds)
+        return; // Let the SignalSender try again later.
+
+    VM* vm = activeVMAndStackBounds.value().vm;
+    if (vm) {
+        VMTraps& traps = vm->traps();
+        if (!traps.needTrapHandling())
+            return; // The polling code beat us to handling the trap already.
+
+        auto expectedSuccess = traps.tryJettisonCodeBlocksOnStack(context);
+        if (!expectedSuccess)
+            return; // Let the SignalSender try again later.
+        if (expectedSuccess.value())
+            return; // We've success jettison the codeBlocks.
+    }
+
+    // If we get here, then this SIGTRAP is not due to a VMTrap. Let's do the default action.
+    auto originalAction = originalSigtrapAction.sa_sigaction;
+    if (originalAction) {
+        // It is always safe to just invoke the original handler using the sa_sigaction form
+        // without checking for the SA_SIGINFO flag. If the original handler is of the
+        // sa_handler form, it will just ignore the 2nd and 3rd arguments since sa_handler is a
+        // subset of sa_sigaction. This is what the man pages says the OS does anyway.
+        originalAction(signalNumber, info, uap);
+    }
+    
+    // Pre-emptively restore the default handler but we may roll it back below.
+    struct sigaction currentAction;
+    struct sigaction defaultAction;
+    defaultAction.sa_handler = SIG_DFL;
+    sigfillset(&defaultAction.sa_mask);
+    defaultAction.sa_flags = 0;
+    sigaction(SIGTRAP, &defaultAction, &currentAction);
+    
+    if (currentAction.sa_sigaction != handleSigtrap) {
+        // This means that there's a client handler installed after us. This also means
+        // that the client handler thinks it was able to recover from the SIGTRAP, and
+        // did not uninstall itself. We can't argue with this because the signal isn't
+        // known to be from a VMTraps signal. Hence, restore the client handler
+        // and keep going.
+        sigaction(SIGTRAP, &currentAction, nullptr);
+    }
+}
+
+static void installSignalHandlers()
+{
+    typedef void (* SigactionHandler)(int, siginfo_t *, void *);
+    struct sigaction action;
+
+    action.sa_sigaction = reinterpret_cast<SigactionHandler>(handleSigusr1);
+    sigfillset(&action.sa_mask);
+    action.sa_flags = SA_SIGINFO;
+    sigaction(SIGUSR1, &action, &originalSigusr1Action);
+
+    action.sa_sigaction = reinterpret_cast<SigactionHandler>(handleSigtrap);
+    sigfillset(&action.sa_mask);
+    action.sa_flags = SA_SIGINFO;
+    sigaction(SIGTRAP, &action, &originalSigtrapAction);
 }
 
@@ -344 +401 @@
         static std::once_flag once;
         std::call_once(once, [] {
-            installSignalHandler();
+            installSignalHandlers();
         });
     }
@@ -404 +461 @@
             auto optionalOwnerThread = vm.ownerThread();
             if (optionalOwnerThread) {
-                sendMessage(*optionalOwnerThread.value().get(), [] (siginfo_t*, ucontext_t* ucontext) -> void {
-                    SignalContext context(ucontext->uc_mcontext);
-                    auto activeVMAndStackBounds = findActiveVMAndStackBounds(context);
-                    if (activeVMAndStackBounds) {
-                        VM* vm = activeVMAndStackBounds.value().vm;
-                        if (vm) {
-                            StackBounds stackBounds = activeVMAndStackBounds.value().stackBounds;
-                            VMTraps& traps = vm->traps();
-                            if (traps.needTrapHandling())
-                                traps.tryInstallTrapBreakpoints(context, stackBounds);
-                        }
-                    }
-                });
+                optionalOwnerThread.value()->signal(SIGUSR1);
                 break;
             }