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

Timestamp:

Apr 21, 2017, 11:35:42 AM (8 years ago)

Author:

[email protected]

Message:

Add signaling API
​https://bugs.webkit.org/show_bug.cgi?id=170976

Reviewed by Filip Pizlo.

Source/JavaScriptCore:

Update various uses of sigaction to use the new signaling API.
Also switch VMTraps to use the thread message system instead of
rolling it's own.

• jit/ExecutableAllocator.h:

(JSC::isJITPC):

• runtime/VMTraps.cpp:

(JSC::installSignalHandler):
(JSC::VMTraps::VMTraps):
(JSC::VMTraps::SignalSender::send):
(JSC::handleSigusr1): Deleted.
(JSC::handleSigtrap): Deleted.
(JSC::installSignalHandlers): Deleted.

• runtime/VMTraps.h:
• tools/SigillCrashAnalyzer.cpp:

(JSC::installCrashHandler):
(JSC::handleCrash): Deleted.

• wasm/WasmFaultSignalHandler.cpp:

(JSC::Wasm::trapHandler):
(JSC::Wasm::enableFastMemory):

Source/WTF:

This patch adds a bunch of new functionality to WTF. First, it add
a new data structure of a lockless bag. The LocklessBag class can
be used as either a multi-writer multi-reader lockless bag or a
multi-writer single consumer lockless bag.

Next, this patch adds an abstraction around sigaction in WTF.
Basically, you can add a handler, which can be an arbitrary
lambda. Although it should still be safe for the signal you are
handling. the signal handler manager will then do all the
appropriate handling of chaining:

In the SIGUSR case we always forward the signal to any other
non-default handler installed before us. We need to do this,
otherwise, since it's not possible to tell if a SIGUSR was
intended exlusively for our handlers. Signal handlers don't record
how many times they were sent only that there is at least one
unhandled signal.

In the faulting cases we require that every handle be able to
recognise a fault they installed, vs crashes. If none of our
handlers claim to have handled the fault we will forward the
fault. If a handler was installed before the first fault handler
we simply call that handler and rely on them to take the
appropriate action. If no handler was installed before our first
handler we restore the default handler and allow the fault to
happen again.

Finally, this patch adds a signal based messaging system. This
system allows the user to run an arbitrary lambda from the SIGUSR2
signal handler of any target WTF::Thread. This is already in use
for the VMTraps API which allows us to kill rogue VMs by sending
the VM's running WTF::Thread a SIGUSR and requesting it jetison
all optimized code and throw an uncatchable exception from all
function entries/loop backedges. In the future, we will also use
this API for Wasm to reset the instruction caches in currently
executing Wasm threads.

• WTF.xcodeproj/project.pbxproj:
• wtf/Atomics.h:

(WTF::Atomic::Atomic):

• wtf/LocklessBag.h: Added.

(WTF::LocklessBag::LocklessBag):
(WTF::LocklessBag::add):
(WTF::LocklessBag::iterate):
(WTF::LocklessBag::consumeAll):

• wtf/ThreadMessage.cpp: Added.

(WTF::ThreadMessageData::ThreadMessageData):
(WTF::initializeThreadMessages):
(WTF::sendMessageScoped):

• wtf/ThreadMessage.h: Added.

(WTF::sendMessage):

• wtf/Threading.cpp:

(WTF::initializeThreading):

• wtf/Threading.h:

(WTF::Thread::threadMessages):

• wtf/ThreadingPthreads.cpp:

(WTF::Thread::currentMayBeNull):
(WTF::Thread::current):
(WTF::Thread::signal):

• wtf/threads/Signals.cpp: Added.

(WTF::jscSignalHandler):
(WTF::installSignalHandler):

• wtf/threads/Signals.h: Added.

(WTF::toSystemSignal):
(WTF::fromSystemSignal):

Tools:

Add tests for ThreadMessages.

• TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj:
• TestWebKitAPI/Tests/WTF/ThreadMessages.cpp: Added.

(runThreadMessageTest):
(TEST):

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>
-
-#if OS(DARWIN)
-#include <signal.h>
-#endif
+#include <wtf/ThreadMessage.h>
+#include <wtf/threads/Signals.h>
 
 namespace JSC {
@@ -54 +52 @@
 
 #if ENABLE(SIGNAL_BASED_VM_TRAPS)
-
-struct sigaction originalSigusr1Action;
-struct sigaction originalSigtrapAction;
 
 struct SignalContext {
@@ -133 +128 @@
 }
 
-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) {
+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.
+
         VM* vm = activeVMAndStackBounds.value().vm;
         if (vm) {
-            StackBounds stackBounds = activeVMAndStackBounds.value().stackBounds;
             VMTraps& traps = vm->traps();
-            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);
+            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;
+    });
 }
 
@@ -401 +344 @@
         static std::once_flag once;
         std::call_once(once, [] {
-            installSignalHandlers();
+            installSignalHandler();
         });
     }
@@ -461 +404 @@
             auto optionalOwnerThread = vm.ownerThread();
             if (optionalOwnerThread) {
-                optionalOwnerThread.value()->signal(SIGUSR1);
+                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);
+                        }
+                    }
+                });
                 break;
             }