Changeset 216808 in webkit for trunk/Source/JavaScriptCore/tools/SigillCrashAnalyzer.cpp

Timestamp:

May 12, 2017, 6:30:13 PM (8 years ago)

Author:

[email protected]

Message:

Use Mach exceptions instead of signals where possible
​https://bugs.webkit.org/show_bug.cgi?id=171865

Reviewed by Mark Lam.

Source/JavaScriptCore:

This patch adds some new JSC options. The first is an option that
enables or disables web assembly tier up. The second controls
whether or not we use mach exceptions (where available).

• API/tests/ExecutionTimeLimitTest.cpp:

(dispatchTermitateCallback):
(testExecutionTimeLimit):

• runtime/JSLock.cpp:

(JSC::JSLock::didAcquireLock):

• runtime/Options.cpp:

(JSC::overrideDefaults):
(JSC::Options::initialize):

• runtime/Options.h:
• runtime/VMTraps.cpp:

(JSC::SignalContext::SignalContext):
(JSC::SignalContext::adjustPCToPointToTrappingInstruction):
(JSC::installSignalHandler):
(JSC::VMTraps::SignalSender::send):

• tools/SigillCrashAnalyzer.cpp:

(JSC::SignalContext::SignalContext):
(JSC::SignalContext::dump):
(JSC::installCrashHandler):

• wasm/WasmBBQPlan.cpp:

(JSC::Wasm::BBQPlan::compileFunctions):

• wasm/WasmFaultSignalHandler.cpp:

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

• wasm/WasmMachineThreads.cpp:

(JSC::Wasm::resetInstructionCacheOnAllThreads):

Source/WTF:

This patch enables using mach exceptions on darwin. The way the
mach exception api works is that we create a mach port, which is
like a file descriptor. We then wait for a message to arrive on
that port in a thread. When another thread raises an exception (say
due to a bad memory access) the OS sends our thread a message. The
payload of that message is the register file of the crashing
thread. We then call our custom handlers that change the state as
needed. In order to restart the thread we send a payload back to
the OS with an updated register file along with a success message
header.

This patch also makes thread messages work without signals by
simply suspending the thread, and then running the message at that
time.

You can read more about mach exceptions here:
​http://www.cs.cmu.edu/afs/cs/project/mach/public/doc/unpublished/exception.ps
and the Mach interface Generator (MiG) here:
​http://www.cs.cmu.edu/afs/cs/project/mach/public/doc/unpublished/mig.ps

• Configurations/WTF.xcconfig:
• WTF.xcodeproj/project.pbxproj:
• wtf/Platform.h:
• wtf/PlatformRegisters.h:

(WTF::registersFromUContext):

• wtf/StackBounds.h:

(WTF::StackBounds::StackBounds):

• wtf/ThreadHolder.cpp:

(WTF::ThreadHolder::~ThreadHolder):

• wtf/ThreadMessage.cpp:

(WTF::sendMessageUsingSignal):
(WTF::sendMessageUsingMach):
(WTF::deliverMessagesUsingMach):
(WTF::sendMessageScoped):

• wtf/ThreadMessage.h:

(WTF::sendMessage):

• wtf/Threading.h:

(WTF::Thread::machThread):

• wtf/mac/MachExceptions.defs: Copied from Source/WTF/wtf/ThreadMessage.h.
• wtf/threads/Signals.cpp:

(WTF::startMachExceptionHandlerThread):
(WTF::fromMachException):
(WTF::toMachMask):
(WTF::handleSignalsWithMach):
(WTF::setExceptionPorts):
(WTF::activeThreads):
(WTF::registerThreadForMachExceptionHandling):
(WTF::unregisterThreadForMachExceptionHandling):
(WTF::installSignalHandler):
(WTF::jscSignalHandler):

• wtf/threads/Signals.h:

Tools:

• TestWebKitAPI/Tests/WTF/ThreadMessages.cpp:

(runThreadMessageTest):
(TEST):

File:

• trunk/Source/JavaScriptCore/tools/SigillCrashAnalyzer.cpp (modified) (4 diffs)

trunk/Source/JavaScriptCore/tools/SigillCrashAnalyzer.cpp

@@ -79 +79 @@
 
 struct SignalContext {
-    SignalContext(mcontext_t& mcontext)
-        : mcontext(mcontext)
-        , machinePC(MachineContext::instructionPointer(mcontext))
-        , stackPointer(MachineContext::stackPointer(mcontext))
-        , framePointer(MachineContext::framePointer(mcontext))
+    SignalContext(PlatformRegisters& registers)
+        : registers(registers)
+        , machinePC(MachineContext::instructionPointer(registers))
+        , stackPointer(MachineContext::stackPointer(registers))
+        , framePointer(MachineContext::framePointer(registers))
     { }
 
@@ -113 +113 @@
 
 #define DUMP_REGISTER(__reg) \
-        log("Register " #__reg ": %p", reinterpret_cast<void*>(mcontext->__ss.__##__reg));
+        log("Register " #__reg ": %p", reinterpret_cast<void*>(registers.__##__reg));
         FOR_EACH_REGISTER(DUMP_REGISTER)
 #undef FOR_EACH_REGISTER
@@ -121 +121 @@
         for (i = 0; i < 28; i += 4) {
             log("x%d: %016llx x%d: %016llx x%d: %016llx x%d: %016llx",
-                i, mcontext->__ss.__x[i],
-                i+1, mcontext->__ss.__x[i+1],
-                i+2, mcontext->__ss.__x[i+2],
-                i+3, mcontext->__ss.__x[i+3]);
+                i, registers.__x[i],
+                i+1, registers.__x[i+1],
+                i+2, registers.__x[i+2],
+                i+3, registers.__x[i+3]);
         }
         ASSERT(i < 29);
         log("x%d: %016llx fp: %016llx lr: %016llx",
-            i, mcontext->__ss.__x[i], mcontext->__ss.__fp, mcontext->__ss.__lr);
+            i, registers.__x[i], registers.__fp, registers.__lr);
         log("sp: %016llx pc: %016llx cpsr: %08x",
-            mcontext->__ss.__sp, mcontext->__ss.__pc, mcontext->__ss.__cpsr);
+            registers.__sp, registers.__pc, registers.__cpsr);
 #endif
     }
 
-    mcontext_t& mcontext;
+    PlatformRegisters& registers;
     void* machinePC;
     void* stackPointer;
@@ -143 +143 @@
 {
 #if CPU(X86_64) || CPU(ARM64)
-    installSignalHandler(Signal::Ill, [] (int, siginfo_t*, void* uap) {
-        SignalContext context(static_cast<ucontext_t*>(uap)->uc_mcontext);
+    installSignalHandler(Signal::Ill, [] (Signal, SigInfo&, PlatformRegisters& registers) {
+        SignalContext context(registers);
 
         if (!isJITPC(context.machinePC))