Date: Thursday, April 6, 2017 @ 14:14:15 Author: jgc Revision: 292232
upgpkg: webkit2gtk 2.16.1-1 Added: webkit2gtk/trunk/0001-Merge-r214319-JSC-MachineThreads-does-not-consider-s.patch webkit2gtk/trunk/0001-Show-a-log-message-when-an-invalid-message-is-receiv.patch Modified: webkit2gtk/trunk/PKGBUILD -----------------------------------------------------------------+ 0001-Merge-r214319-JSC-MachineThreads-does-not-consider-s.patch | 390 ++++++++++ 0001-Show-a-log-message-when-an-invalid-message-is-receiv.patch | 38 PKGBUILD | 14 3 files changed, 438 insertions(+), 4 deletions(-) Added: 0001-Merge-r214319-JSC-MachineThreads-does-not-consider-s.patch =================================================================== --- 0001-Merge-r214319-JSC-MachineThreads-does-not-consider-s.patch (rev 0) +++ 0001-Merge-r214319-JSC-MachineThreads-does-not-consider-s.patch 2017-04-06 14:14:15 UTC (rev 292232) @@ -0,0 +1,390 @@ +From 70c605847496766b0ca59bee03ecadb74e54a159 Mon Sep 17 00:00:00 2001 +From: "carlo...@webkit.org" + <carlo...@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc> +Date: Tue, 4 Apr 2017 16:12:17 +0000 +Subject: [PATCH] Merge r214319 - [JSC] MachineThreads does not consider + situation that one thread has multiple VMs + https://bugs.webkit.org/show_bug.cgi?id=169819 + +Reviewed by Mark Lam. + +The Linux port of PlatformThread suspend/resume mechanism relies on having a thread +specific singleton thread data, and was relying on MachineThreads::Thread to be this +thread specific singleton. But because MachineThreads::Thread is not a thread specific +singleton, we can get a deadlock in the GTK port's DatabaseProcess. + +This patch fixes this issue by moving per thread data from MachineThreads::Thread to +MachineThreads::ThreadData, where there will only be one instance of +MachineThreads::ThreadData per thread. Each MachineThreads::Thread will now point to +the same MachineThreads::ThreadData for any given thread. + +* heap/MachineStackMarker.cpp: +(pthreadSignalHandlerSuspendResume): +(JSC::threadData): +(JSC::MachineThreads::Thread::Thread): +(JSC::MachineThreads::Thread::createForCurrentThread): +(JSC::MachineThreads::Thread::operator==): +(JSC::MachineThreads::ThreadData::ThreadData): +(JSC::MachineThreads::ThreadData::~ThreadData): +(JSC::MachineThreads::ThreadData::suspend): +(JSC::MachineThreads::ThreadData::resume): +(JSC::MachineThreads::ThreadData::getRegisters): +(JSC::MachineThreads::ThreadData::Registers::stackPointer): +(JSC::MachineThreads::ThreadData::Registers::framePointer): +(JSC::MachineThreads::ThreadData::Registers::instructionPointer): +(JSC::MachineThreads::ThreadData::Registers::llintPC): +(JSC::MachineThreads::ThreadData::freeRegisters): +(JSC::MachineThreads::ThreadData::captureStack): +(JSC::MachineThreads::tryCopyOtherThreadStacks): +(JSC::MachineThreads::Thread::~Thread): Deleted. +(JSC::MachineThreads::Thread::suspend): Deleted. +(JSC::MachineThreads::Thread::resume): Deleted. +(JSC::MachineThreads::Thread::getRegisters): Deleted. +(JSC::MachineThreads::Thread::Registers::stackPointer): Deleted. +(JSC::MachineThreads::Thread::Registers::framePointer): Deleted. +(JSC::MachineThreads::Thread::Registers::instructionPointer): Deleted. +(JSC::MachineThreads::Thread::Registers::llintPC): Deleted. +(JSC::MachineThreads::Thread::freeRegisters): Deleted. +(JSC::MachineThreads::Thread::captureStack): Deleted. +* heap/MachineStackMarker.h: +(JSC::MachineThreads::Thread::operator!=): +(JSC::MachineThreads::Thread::suspend): +(JSC::MachineThreads::Thread::resume): +(JSC::MachineThreads::Thread::getRegisters): +(JSC::MachineThreads::Thread::freeRegisters): +(JSC::MachineThreads::Thread::captureStack): +(JSC::MachineThreads::Thread::platformThread): +(JSC::MachineThreads::Thread::stackBase): +(JSC::MachineThreads::Thread::stackEnd): +* runtime/SamplingProfiler.cpp: +(JSC::FrameWalker::isValidFramePointer): +* runtime/VMTraps.cpp: +(JSC::findActiveVMAndStackBounds): + +git-svn-id: http://svn.webkit.org/repository/webkit/releases/WebKitGTK/webkit-2.16@214882 268f45cc-cd09-0410-ab3c-d52691b4dbfc +--- + Source/JavaScriptCore/heap/MachineStackMarker.cpp | 73 +++++++++++++--------- + Source/JavaScriptCore/heap/MachineStackMarker.h | 41 +++++++++--- + Source/JavaScriptCore/runtime/SamplingProfiler.cpp | 4 +- + 4 files changed, 137 insertions(+), 41 deletions(-) + +diff --git a/Source/JavaScriptCore/heap/MachineStackMarker.cpp b/Source/JavaScriptCore/heap/MachineStackMarker.cpp +index 65eb0cf0d9b..5fea745d2ad 100644 +--- a/Source/JavaScriptCore/heap/MachineStackMarker.cpp ++++ b/Source/JavaScriptCore/heap/MachineStackMarker.cpp +@@ -33,6 +33,7 @@ + #include <setjmp.h> + #include <stdlib.h> + #include <wtf/MainThread.h> ++#include <wtf/NeverDestroyed.h> + #include <wtf/StdLibExtras.h> + + #if OS(DARWIN) +@@ -69,14 +70,14 @@ + // We use SIGUSR2 to suspend and resume machine threads in JavaScriptCore. + static const int SigThreadSuspendResume = SIGUSR2; + static StaticLock globalSignalLock; +-thread_local static std::atomic<JSC::MachineThreads::Thread*> threadLocalCurrentThread; ++thread_local static std::atomic<JSC::MachineThreads::ThreadData*> threadLocalCurrentThread { nullptr }; + + static void pthreadSignalHandlerSuspendResume(int, siginfo_t*, void* ucontext) + { + // Touching thread local atomic types from signal handlers is allowed. +- JSC::MachineThreads::Thread* thread = threadLocalCurrentThread.load(); ++ JSC::MachineThreads::ThreadData* threadData = threadLocalCurrentThread.load(); + +- if (thread->suspended.load(std::memory_order_acquire)) { ++ if (threadData->suspended.load(std::memory_order_acquire)) { + // This is signal handler invocation that is intended to be used to resume sigsuspend. + // So this handler invocation itself should not process. + // +@@ -88,9 +89,9 @@ static void pthreadSignalHandlerSuspendResume(int, siginfo_t*, void* ucontext) + + ucontext_t* userContext = static_cast<ucontext_t*>(ucontext); + #if CPU(PPC) +- thread->suspendedMachineContext = *userContext->uc_mcontext.uc_regs; ++ threadData->suspendedMachineContext = *userContext->uc_mcontext.uc_regs; + #else +- thread->suspendedMachineContext = userContext->uc_mcontext; ++ threadData->suspendedMachineContext = userContext->uc_mcontext; + #endif + + // Allow suspend caller to see that this thread is suspended. +@@ -99,7 +100,7 @@ static void pthreadSignalHandlerSuspendResume(int, siginfo_t*, void* ucontext) + // + // And sem_post emits memory barrier that ensures that suspendedMachineContext is correctly saved. + // http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap04.html#tag_04_11 +- sem_post(&thread->semaphoreForSuspendResume); ++ sem_post(&threadData->semaphoreForSuspendResume); + + // Reaching here, SigThreadSuspendResume is blocked in this handler (this is configured by sigaction's sa_mask). + // So before calling sigsuspend, SigThreadSuspendResume to this thread is deferred. This ensures that the handler is not executed recursively. +@@ -109,7 +110,7 @@ static void pthreadSignalHandlerSuspendResume(int, siginfo_t*, void* ucontext) + sigsuspend(&blockedSignalSet); + + // Allow resume caller to see that this thread is resumed. +- sem_post(&thread->semaphoreForSuspendResume); ++ sem_post(&threadData->semaphoreForSuspendResume); + } + #endif // USE(PTHREADS) && !OS(WINDOWS) && !OS(DARWIN) + +@@ -215,18 +216,29 @@ MachineThreads::~MachineThreads() + } + } + ++static MachineThreads::ThreadData* threadData() ++{ ++ static NeverDestroyed<ThreadSpecific<MachineThreads::ThreadData, CanBeGCThread::True>> threadData; ++ return threadData.get(); ++} ++ ++MachineThreads::Thread::Thread(ThreadData* threadData) ++ : data(threadData) ++{ ++ ASSERT(threadData); ++} ++ + Thread* MachineThreads::Thread::createForCurrentThread() + { +- auto stackBounds = wtfThreadData().stack(); +- return new Thread(getCurrentPlatformThread(), stackBounds.origin(), stackBounds.end()); ++ return new Thread(threadData()); + } + + bool MachineThreads::Thread::operator==(const PlatformThread& other) const + { + #if OS(DARWIN) || OS(WINDOWS) +- return platformThread == other; ++ return data->platformThread == other; + #elif USE(PTHREADS) +- return !!pthread_equal(platformThread, other); ++ return !!pthread_equal(data->platformThread, other); + #else + #error Need a way to compare threads on this platform + #endif +@@ -325,11 +337,13 @@ void MachineThreads::gatherFromCurrentThread(ConservativeRoots& conservativeRoot + conservativeRoots.add(currentThreadState.stackTop, currentThreadState.stackOrigin, jitStubRoutines, codeBlocks); + } + +-MachineThreads::Thread::Thread(const PlatformThread& platThread, void* base, void* end) +- : platformThread(platThread) +- , stackBase(base) +- , stackEnd(end) ++MachineThreads::ThreadData::ThreadData() + { ++ auto stackBounds = wtfThreadData().stack(); ++ platformThread = getCurrentPlatformThread(); ++ stackBase = stackBounds.origin(); ++ stackEnd = stackBounds.end(); ++ + #if OS(WINDOWS) + ASSERT(platformThread == GetCurrentThreadId()); + bool isSuccessful = +@@ -362,7 +376,7 @@ MachineThreads::Thread::Thread(const PlatformThread& platThread, void* base, voi + #endif + } + +-MachineThreads::Thread::~Thread() ++MachineThreads::ThreadData::~ThreadData() + { + #if OS(WINDOWS) + CloseHandle(platformThreadHandle); +@@ -371,7 +385,7 @@ MachineThreads::Thread::~Thread() + #endif + } + +-bool MachineThreads::Thread::suspend() ++bool MachineThreads::ThreadData::suspend() + { + #if OS(DARWIN) + kern_return_t result = thread_suspend(platformThread); +@@ -408,7 +422,7 @@ bool MachineThreads::Thread::suspend() + #endif + } + +-void MachineThreads::Thread::resume() ++void MachineThreads::ThreadData::resume() + { + #if OS(DARWIN) + thread_resume(platformThread); +@@ -439,9 +453,9 @@ void MachineThreads::Thread::resume() + #endif + } + +-size_t MachineThreads::Thread::getRegisters(Thread::Registers& registers) ++size_t MachineThreads::ThreadData::getRegisters(ThreadData::Registers& registers) + { +- Thread::Registers::PlatformRegisters& regs = registers.regs; ++ ThreadData::Registers::PlatformRegisters& regs = registers.regs; + #if OS(DARWIN) + #if CPU(X86) + unsigned user_count = sizeof(regs)/sizeof(int); +@@ -496,7 +510,7 @@ size_t MachineThreads::Thread::getRegisters(Thread::Registers& registers) + #endif + } + +-void* MachineThreads::Thread::Registers::stackPointer() const ++void* MachineThreads::ThreadData::Registers::stackPointer() const + { + #if OS(DARWIN) + +@@ -601,7 +615,7 @@ void* MachineThreads::Thread::Registers::stackPointer() const + } + + #if ENABLE(SAMPLING_PROFILER) +-void* MachineThreads::Thread::Registers::framePointer() const ++void* MachineThreads::ThreadData::Registers::framePointer() const + { + #if OS(DARWIN) + +@@ -684,7 +698,7 @@ void* MachineThreads::Thread::Registers::framePointer() const + #endif + } + +-void* MachineThreads::Thread::Registers::instructionPointer() const ++void* MachineThreads::ThreadData::Registers::instructionPointer() const + { + #if OS(DARWIN) + +@@ -765,7 +779,8 @@ void* MachineThreads::Thread::Registers::instructionPointer() const + #error Need a way to get the instruction pointer for another thread on this platform + #endif + } +-void* MachineThreads::Thread::Registers::llintPC() const ++ ++void* MachineThreads::ThreadData::Registers::llintPC() const + { + // LLInt uses regT4 as PC. + #if OS(DARWIN) +@@ -858,9 +873,9 @@ void* MachineThreads::Thread::Registers::llintPC() const + } + #endif // ENABLE(SAMPLING_PROFILER) + +-void MachineThreads::Thread::freeRegisters(Thread::Registers& registers) ++void MachineThreads::ThreadData::freeRegisters(ThreadData::Registers& registers) + { +- Thread::Registers::PlatformRegisters& regs = registers.regs; ++ ThreadData::Registers::PlatformRegisters& regs = registers.regs; + #if USE(PTHREADS) && !OS(WINDOWS) && !OS(DARWIN) + pthread_attr_destroy(®s.attribute); + #else +@@ -883,7 +898,7 @@ static inline int osRedZoneAdjustment() + return redZoneAdjustment; + } + +-std::pair<void*, size_t> MachineThreads::Thread::captureStack(void* stackTop) ++std::pair<void*, size_t> MachineThreads::ThreadData::captureStack(void* stackTop) + { + char* begin = reinterpret_cast_ptr<char*>(stackBase); + char* end = bitwise_cast<char*>(WTF::roundUpToMultipleOf<sizeof(void*)>(reinterpret_cast<uintptr_t>(stackTop))); +@@ -971,12 +986,12 @@ bool MachineThreads::tryCopyOtherThreadStacks(LockHolder&, void* buffer, size_t + } + + // Re-do the suspension to get the actual failure result for logging. +- kern_return_t error = thread_suspend(thread->platformThread); ++ kern_return_t error = thread_suspend(thread->platformThread()); + ASSERT(error != KERN_SUCCESS); + + WTFReportError(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, + "JavaScript garbage collection encountered an invalid thread (err 0x%x): Thread [%d/%d: %p] platformThread %p.", +- error, index, numberOfThreads, thread, reinterpret_cast<void*>(thread->platformThread)); ++ error, index, numberOfThreads, thread, reinterpret_cast<void*>(thread->platformThread())); + + // Put the invalid thread on the threadsToBeDeleted list. + // We can't just delete it here because we have suspended other +diff --git a/Source/JavaScriptCore/heap/MachineStackMarker.h b/Source/JavaScriptCore/heap/MachineStackMarker.h +index a5a50870922..da979c582ec 100644 +--- a/Source/JavaScriptCore/heap/MachineStackMarker.h ++++ b/Source/JavaScriptCore/heap/MachineStackMarker.h +@@ -74,14 +74,13 @@ public: + + JS_EXPORT_PRIVATE void addCurrentThread(); // Only needs to be called by clients that can use the same heap from multiple threads. + +- class Thread { ++ class ThreadData { + WTF_MAKE_FAST_ALLOCATED; +- Thread(const PlatformThread& platThread, void* base, void* end); +- + public: +- ~Thread(); ++ ThreadData(); ++ ~ThreadData(); + +- static Thread* createForCurrentThread(); ++ static ThreadData* createForCurrentThread(); + + struct Registers { + void* stackPointer() const; +@@ -118,12 +117,9 @@ public: + #else + #error Need a thread register struct for this platform + #endif +- ++ + PlatformRegisters regs; + }; +- +- bool operator==(const PlatformThread& other) const; +- bool operator!=(const PlatformThread& other) const { return !(*this == other); } + + bool suspend(); + void resume(); +@@ -131,7 +127,6 @@ public: + void freeRegisters(Registers&); + std::pair<void*, size_t> captureStack(void* stackTop); + +- Thread* next; + PlatformThread platformThread; + void* stackBase; + void* stackEnd; +@@ -145,6 +140,32 @@ public: + #endif + }; + ++ class Thread { ++ WTF_MAKE_FAST_ALLOCATED; ++ Thread(ThreadData*); ++ ++ public: ++ using Registers = ThreadData::Registers; ++ ++ static Thread* createForCurrentThread(); ++ ++ bool operator==(const PlatformThread& other) const; ++ bool operator!=(const PlatformThread& other) const { return !(*this == other); } ++ ++ bool suspend() { return data->suspend(); } ++ void resume() { data->resume(); } ++ size_t getRegisters(Registers& regs) { return data->getRegisters(regs); } ++ void freeRegisters(Registers& regs) { data->freeRegisters(regs); } ++ std::pair<void*, size_t> captureStack(void* stackTop) { return data->captureStack(stackTop); } ++ ++ const PlatformThread& platformThread() { return data->platformThread; } ++ void* stackBase() const { return data->stackBase; } ++ void* stackEnd() const { return data->stackEnd; } ++ ++ Thread* next; ++ ThreadData* data; ++ }; ++ + Lock& getLock() { return m_registeredThreadsMutex; } + Thread* threadsListHead(const LockHolder&) const { ASSERT(m_registeredThreadsMutex.isLocked()); return m_registeredThreads; } + Thread* machineThreadForCurrentThread(); +diff --git a/Source/JavaScriptCore/runtime/SamplingProfiler.cpp b/Source/JavaScriptCore/runtime/SamplingProfiler.cpp +index a8d953d6622..9326d7a0fc9 100644 +--- a/Source/JavaScriptCore/runtime/SamplingProfiler.cpp ++++ b/Source/JavaScriptCore/runtime/SamplingProfiler.cpp +@@ -169,8 +169,8 @@ protected: + { + uint8_t* fpCast = bitwise_cast<uint8_t*>(exec); + for (MachineThreads::Thread* thread = m_vm.heap.machineThreads().threadsListHead(m_machineThreadsLocker); thread; thread = thread->next) { +- uint8_t* stackBase = static_cast<uint8_t*>(thread->stackBase); +- uint8_t* stackLimit = static_cast<uint8_t*>(thread->stackEnd); ++ uint8_t* stackBase = static_cast<uint8_t*>(thread->stackBase()); ++ uint8_t* stackLimit = static_cast<uint8_t*>(thread->stackEnd()); + RELEASE_ASSERT(stackBase); + RELEASE_ASSERT(stackLimit); + if (fpCast <= stackBase && fpCast >= stackLimit) +-- +2.12.2 + Added: 0001-Show-a-log-message-when-an-invalid-message-is-receiv.patch =================================================================== --- 0001-Show-a-log-message-when-an-invalid-message-is-receiv.patch (rev 0) +++ 0001-Show-a-log-message-when-an-invalid-message-is-receiv.patch 2017-04-06 14:14:15 UTC (rev 292232) @@ -0,0 +1,38 @@ +From 7a4822f02bd724c1eb3079158f93331c4090b9ad Mon Sep 17 00:00:00 2001 +From: "commit-qu...@webkit.org" + <commit-qu...@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc> +Date: Wed, 5 Apr 2017 16:50:03 +0000 +Subject: [PATCH] Show a log message when an invalid message is received in non + cocoa ports https://bugs.webkit.org/show_bug.cgi?id=170506 + +Patch by Carlos Garcia Campos <cgar...@igalia.com> on 2017-04-05 +Reviewed by Michael Catanzaro. + +We just crash, but without knowing the details about the message it's impossible to debug. + +* Shared/ChildProcess.cpp: +(WebKit::ChildProcess::didReceiveInvalidMessage): + +git-svn-id: http://svn.webkit.org/repository/webkit/trunk@214947 268f45cc-cd09-0410-ab3c-d52691b4dbfc +--- + Source/WebKit2/Shared/ChildProcess.cpp | 3 ++- + 2 files changed, 14 insertions(+), 1 deletion(-) + +diff --git a/Source/WebKit2/Shared/ChildProcess.cpp b/Source/WebKit2/Shared/ChildProcess.cpp +index 060c63ae792..bc1f2d6ab6a 100644 +--- a/Source/WebKit2/Shared/ChildProcess.cpp ++++ b/Source/WebKit2/Shared/ChildProcess.cpp +@@ -197,8 +197,9 @@ void ChildProcess::initializeSandbox(const ChildProcessInitializationParameters& + { + } + +-void ChildProcess::didReceiveInvalidMessage(IPC::Connection&, IPC::StringReference, IPC::StringReference) ++void ChildProcess::didReceiveInvalidMessage(IPC::Connection&, IPC::StringReference messageReceiverName, IPC::StringReference messageName) + { ++ WTFLogAlways("Received invalid message: '%s::%s'", messageReceiverName.toString().data(), messageName.toString().data()); + CRASH(); + } + #endif +-- +2.12.2 + Modified: PKGBUILD =================================================================== --- PKGBUILD 2017-04-06 13:25:05 UTC (rev 292231) +++ PKGBUILD 2017-04-06 14:14:15 UTC (rev 292232) @@ -2,7 +2,7 @@ # Contributor: Eric BĂ©langer <e...@archlinux.org> pkgname=webkit2gtk -pkgver=2.16.0 +pkgver=2.16.1 pkgrel=1 pkgdesc="GTK+ Web content engine library" arch=(i686 x86_64) @@ -16,9 +16,13 @@ 'gst-plugins-good: media decoding' 'gst-libav: nonfree media decoding') options=(!emptydirs) -source=(https://webkitgtk.org/releases/webkitgtk-${pkgver}.tar.xz{,.asc}) -sha256sums=('5ea371d8910ef3ce7f7d087242c5646f8f3073a5298287c9eb60e055ec107cdc' - 'SKIP') +source=(https://webkitgtk.org/releases/webkitgtk-${pkgver}.tar.xz{,.asc} + 0001-Merge-r214319-JSC-MachineThreads-does-not-consider-s.patch + 0001-Show-a-log-message-when-an-invalid-message-is-receiv.patch) +sha256sums=('eb92383232328ce655b703c64370ed3795662479719ad1b4a869ed46769d2945' + 'SKIP' + '51541d4cb1f58d3b7c7112948ce0588e45ca445434350aec3e47c227651ff19f' + '18219f8a016eeb001efb4788891d18d83804f03bda537da621bcf73615a68e2f') validpgpkeys=('D7FCF61CF9A2DEAB31D81BD3F3D322D0EC4582C3') prepare() { @@ -28,6 +32,8 @@ sed -i '1s/python$/&2/' Tools/gtk/generate-gtkdoc rm -r Source/ThirdParty/gtest/ #rm -r Source/ThirdParty/qunit/ + patch -Np1 -i ../0001-Merge-r214319-JSC-MachineThreads-does-not-consider-s.patch + patch -Np1 -i ../0001-Show-a-log-message-when-an-invalid-message-is-receiv.patch } build() {