It should be easy to decide how WebKit yields
[WebKit-https.git] / Source / WTF / wtf / ThreadingPthreads.cpp
1 /*
2  * Copyright (C) 2007, 2009, 2015 Apple Inc. All rights reserved.
3  * Copyright (C) 2007 Justin Haygood <jhaygood@reaktix.com>
4  * Copyright (C) 2011 Research In Motion Limited. All rights reserved.
5  * Copyright (C) 2017 Yusuke Suzuki <utatane.tea@gmail.com>
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * 1.  Redistributions of source code must retain the above copyright
12  *     notice, this list of conditions and the following disclaimer. 
13  * 2.  Redistributions in binary form must reproduce the above copyright
14  *     notice, this list of conditions and the following disclaimer in the
15  *     documentation and/or other materials provided with the distribution. 
16  * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
17  *     its contributors may be used to endorse or promote products derived
18  *     from this software without specific prior written permission. 
19  *
20  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
21  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
22  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
23  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
24  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
25  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
26  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
27  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
29  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  */
31
32 #include "config.h"
33 #include "Threading.h"
34
35 #if USE(PTHREADS)
36
37 #include <errno.h>
38 #include <wtf/CurrentTime.h>
39 #include <wtf/DataLog.h>
40 #include <wtf/RawPointer.h>
41 #include <wtf/StdLibExtras.h>
42 #include <wtf/ThreadGroup.h>
43 #include <wtf/ThreadHolder.h>
44 #include <wtf/ThreadingPrimitives.h>
45 #include <wtf/WordLock.h>
46
47 #if OS(LINUX)
48 #include <sys/prctl.h>
49 #endif
50
51 #if !COMPILER(MSVC)
52 #include <limits.h>
53 #include <sched.h>
54 #include <sys/time.h>
55 #endif
56
57 #if !OS(DARWIN) && OS(UNIX)
58
59 #include <sys/mman.h>
60 #include <unistd.h>
61
62 #if OS(SOLARIS)
63 #include <thread.h>
64 #else
65 #include <pthread.h>
66 #endif
67
68 #if HAVE(PTHREAD_NP_H)
69 #include <pthread_np.h>
70 #endif
71
72 #endif
73
74 namespace WTF {
75
76 static StaticLock globalSuspendLock;
77
78 Thread::Thread()
79 {
80 #if !OS(DARWIN)
81     sem_init(&m_semaphoreForSuspendResume, /* Only available in this process. */ 0, /* Initial value for the semaphore. */ 0);
82 #endif
83 }
84
85 Thread::~Thread()
86 {
87 #if !OS(DARWIN)
88     sem_destroy(&m_semaphoreForSuspendResume);
89 #endif
90 }
91
92 #if !OS(DARWIN)
93
94 // We use SIGUSR1 to suspend and resume machine threads in JavaScriptCore.
95 static constexpr const int SigThreadSuspendResume = SIGUSR1;
96 static std::atomic<Thread*> targetThread { nullptr };
97
98 #if COMPILER(GCC)
99 #pragma GCC diagnostic push
100 #pragma GCC diagnostic ignored "-Wreturn-local-addr"
101 #endif // COMPILER(GCC)
102
103 #if COMPILER(CLANG)
104 #pragma clang diagnostic push
105 #pragma clang diagnostic ignored "-Wreturn-stack-address"
106 #endif // COMPILER(CLANG)
107
108 static UNUSED_FUNCTION NEVER_INLINE void* getApproximateStackPointer()
109 {
110     volatile void* stackLocation = nullptr;
111     return &stackLocation;
112 }
113
114 #if COMPILER(GCC)
115 #pragma GCC diagnostic pop
116 #endif // COMPILER(GCC)
117
118 #if COMPILER(CLANG)
119 #pragma clang diagnostic pop
120 #endif // COMPILER(CLANG)
121
122 static UNUSED_FUNCTION bool isOnAlternativeSignalStack()
123 {
124     stack_t stack { };
125     int ret = sigaltstack(nullptr, &stack);
126     RELEASE_ASSERT(!ret);
127     return stack.ss_flags == SS_ONSTACK;
128 }
129
130 void Thread::signalHandlerSuspendResume(int, siginfo_t*, void* ucontext)
131 {
132     // Touching thread local atomic types from signal handlers is allowed.
133     Thread* thread = targetThread.load();
134
135     if (thread->m_suspended.load(std::memory_order_acquire)) {
136         // This is signal handler invocation that is intended to be used to resume sigsuspend.
137         // So this handler invocation itself should not process.
138         //
139         // When signal comes, first, the system calls signal handler. And later, sigsuspend will be resumed. Signal handler invocation always precedes.
140         // So, the problem never happens that suspended.store(true, ...) will be executed before the handler is called.
141         // http://pubs.opengroup.org/onlinepubs/009695399/functions/sigsuspend.html
142         return;
143     }
144
145     ucontext_t* userContext = static_cast<ucontext_t*>(ucontext);
146     ASSERT_WITH_MESSAGE(!isOnAlternativeSignalStack(), "Using an alternative signal stack is not supported. Consider disabling the concurrent GC.");
147
148 #if HAVE(MACHINE_CONTEXT)
149     thread->m_platformRegisters = registersFromUContext(userContext);
150 #else
151     thread->m_platformRegisters = PlatformRegisters { getApproximateStackPointer() };
152 #endif
153
154     // Allow suspend caller to see that this thread is suspended.
155     // sem_post is async-signal-safe function. It means that we can call this from a signal handler.
156     // http://pubs.opengroup.org/onlinepubs/009695399/functions/xsh_chap02_04.html#tag_02_04_03
157     //
158     // And sem_post emits memory barrier that ensures that suspendedMachineContext is correctly saved.
159     // http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap04.html#tag_04_11
160     sem_post(&thread->m_semaphoreForSuspendResume);
161
162     // Reaching here, SigThreadSuspendResume is blocked in this handler (this is configured by sigaction's sa_mask).
163     // So before calling sigsuspend, SigThreadSuspendResume to this thread is deferred. This ensures that the handler is not executed recursively.
164     sigset_t blockedSignalSet;
165     sigfillset(&blockedSignalSet);
166     sigdelset(&blockedSignalSet, SigThreadSuspendResume);
167     sigsuspend(&blockedSignalSet);
168
169     // Allow resume caller to see that this thread is resumed.
170     sem_post(&thread->m_semaphoreForSuspendResume);
171 }
172
173 #endif // !OS(DARWIN)
174
175 void Thread::initializePlatformThreading()
176 {
177 #if !OS(DARWIN)
178     // Signal handlers are process global configuration.
179     // Intentionally block SigThreadSuspendResume in the handler.
180     // SigThreadSuspendResume will be allowed in the handler by sigsuspend.
181     struct sigaction action;
182     sigemptyset(&action.sa_mask);
183     sigaddset(&action.sa_mask, SigThreadSuspendResume);
184
185     action.sa_sigaction = &signalHandlerSuspendResume;
186     action.sa_flags = SA_RESTART | SA_SIGINFO;
187     sigaction(SigThreadSuspendResume, &action, 0);
188 #endif
189 }
190
191 void Thread::initializeCurrentThreadEvenIfNonWTFCreated(Thread& thread)
192 {
193     thread.initialize();
194 #if !OS(DARWIN)
195     sigset_t mask;
196     sigemptyset(&mask);
197     sigaddset(&mask, SigThreadSuspendResume);
198     pthread_sigmask(SIG_UNBLOCK, &mask, 0);
199 #endif
200 }
201
202 static void* wtfThreadEntryPoint(void* data)
203 {
204     Thread::entryPoint(reinterpret_cast<Thread::NewThreadContext*>(data));
205     return nullptr;
206 }
207
208 bool Thread::establishHandle(NewThreadContext* data)
209 {
210     pthread_t threadHandle;
211     pthread_attr_t attr;
212     pthread_attr_init(&attr);
213 #if HAVE(QOS_CLASSES)
214     pthread_attr_set_qos_class_np(&attr, adjustedQOSClass(QOS_CLASS_USER_INITIATED), 0);
215 #endif
216     int error = pthread_create(&threadHandle, &attr, wtfThreadEntryPoint, data);
217     pthread_attr_destroy(&attr);
218     if (error) {
219         LOG_ERROR("Failed to create pthread at entry point %p with data %p", wtfThreadEntryPoint, data);
220         return false;
221     }
222     establishPlatformSpecificHandle(threadHandle);
223     return true;
224 }
225
226 void Thread::initializeCurrentThreadInternal(Thread& thread, const char* threadName)
227 {
228 #if HAVE(PTHREAD_SETNAME_NP)
229     pthread_setname_np(normalizeThreadName(threadName));
230 #elif OS(LINUX)
231     prctl(PR_SET_NAME, normalizeThreadName(threadName));
232 #else
233     UNUSED_PARAM(threadName);
234 #endif
235     initializeCurrentThreadEvenIfNonWTFCreated(thread);
236 }
237
238 void Thread::changePriority(int delta)
239 {
240     std::lock_guard<std::mutex> locker(m_mutex);
241
242     int policy;
243     struct sched_param param;
244
245     if (pthread_getschedparam(m_handle, &policy, &param))
246         return;
247
248     param.sched_priority += delta;
249
250     pthread_setschedparam(m_handle, policy, &param);
251 }
252
253 int Thread::waitForCompletion()
254 {
255     pthread_t handle;
256     {
257         std::lock_guard<std::mutex> locker(m_mutex);
258         handle = m_handle;
259     }
260
261     int joinResult = pthread_join(handle, 0);
262
263     if (joinResult == EDEADLK)
264         LOG_ERROR("ThreadIdentifier %u was found to be deadlocked trying to quit", m_id);
265     else if (joinResult)
266         LOG_ERROR("ThreadIdentifier %u was unable to be joined.\n", m_id);
267
268     std::lock_guard<std::mutex> locker(m_mutex);
269     ASSERT(joinableState() == Joinable);
270
271     // If the thread has already exited, then do nothing. If the thread hasn't exited yet, then just signal that we've already joined on it.
272     // In both cases, ThreadHolder::destruct() will take care of destroying Thread.
273     if (!hasExited())
274         didJoin();
275
276     return joinResult;
277 }
278
279 void Thread::detach()
280 {
281     std::lock_guard<std::mutex> locker(m_mutex);
282     int detachResult = pthread_detach(m_handle);
283     if (detachResult)
284         LOG_ERROR("ThreadIdentifier %u was unable to be detached\n", m_id);
285
286     if (!hasExited())
287         didBecomeDetached();
288 }
289
290 Thread& Thread::current()
291 {
292     if (Thread* current = currentMayBeNull())
293         return *current;
294
295     // Not a WTF-created thread, ThreadIdentifier is not established yet.
296     Ref<Thread> thread = adoptRef(*new Thread());
297     thread->establishPlatformSpecificHandle(pthread_self());
298     ThreadHolder::initialize(thread.get());
299     initializeCurrentThreadEvenIfNonWTFCreated(thread.get());
300     return thread.get();
301 }
302
303 ThreadIdentifier Thread::currentID()
304 {
305     return current().id();
306 }
307
308 bool Thread::signal(int signalNumber)
309 {
310     std::lock_guard<std::mutex> locker(m_mutex);
311     if (hasExited())
312         return false;
313     int errNo = pthread_kill(m_handle, signalNumber);
314     return !errNo; // A 0 errNo means success.
315 }
316
317 auto Thread::suspend() -> Expected<void, PlatformSuspendError>
318 {
319     RELEASE_ASSERT_WITH_MESSAGE(id() != currentThread(), "We do not support suspending the current thread itself.");
320     // During suspend, suspend or resume should not be executed from the other threads.
321     // We use global lock instead of per thread lock.
322     // Consider the following case, there are threads A and B.
323     // And A attempt to suspend B and B attempt to suspend A.
324     // A and B send signals. And later, signals are delivered to A and B.
325     // In that case, both will be suspended.
326     //
327     // And it is important to use a global lock to suspend and resume. Let's consider using per-thread lock.
328     // Your issuing thread (A) attempts to suspend the target thread (B). Then, you will suspend the thread (C) additionally.
329     // This case frequently happens if you stop threads to perform stack scanning. But thread (B) may hold the lock of thread (C).
330     // In that case, dead lock happens. Using global lock here avoids this dead lock.
331     LockHolder locker(globalSuspendLock);
332 #if OS(DARWIN)
333     kern_return_t result = thread_suspend(m_platformThread);
334     if (result != KERN_SUCCESS)
335         return makeUnexpected(result);
336     return { };
337 #else
338     if (!m_suspendCount) {
339         // Ideally, we would like to use pthread_sigqueue. It allows us to pass the argument to the signal handler.
340         // But it can be used in a few platforms, like Linux.
341         // Instead, we use Thread* stored in the thread local storage to pass it to the signal handler.
342         targetThread.store(this);
343         int result = pthread_kill(m_handle, SigThreadSuspendResume);
344         if (result)
345             return makeUnexpected(result);
346         sem_wait(&m_semaphoreForSuspendResume);
347         // Release barrier ensures that this operation is always executed after all the above processing is done.
348         m_suspended.store(true, std::memory_order_release);
349     }
350     ++m_suspendCount;
351     return { };
352 #endif
353 }
354
355 void Thread::resume()
356 {
357     // During resume, suspend or resume should not be executed from the other threads.
358     LockHolder locker(globalSuspendLock);
359 #if OS(DARWIN)
360     thread_resume(m_platformThread);
361 #else
362     if (m_suspendCount == 1) {
363         // When allowing SigThreadSuspendResume interrupt in the signal handler by sigsuspend and SigThreadSuspendResume is actually issued,
364         // the signal handler itself will be called once again.
365         // There are several ways to distinguish the handler invocation for suspend and resume.
366         // 1. Use different signal numbers. And check the signal number in the handler.
367         // 2. Use some arguments to distinguish suspend and resume in the handler. If pthread_sigqueue can be used, we can take this.
368         // 3. Use thread local storage with atomic variables in the signal handler.
369         // In this implementaiton, we take (3). suspended flag is used to distinguish it.
370         targetThread.store(this);
371         if (pthread_kill(m_handle, SigThreadSuspendResume) == ESRCH)
372             return;
373         sem_wait(&m_semaphoreForSuspendResume);
374         // Release barrier ensures that this operation is always executed after all the above processing is done.
375         m_suspended.store(false, std::memory_order_release);
376     }
377     --m_suspendCount;
378 #endif
379 }
380
381 #if OS(DARWIN)
382 struct ThreadStateMetadata {
383     unsigned userCount;
384     thread_state_flavor_t flavor;
385 };
386
387 static ThreadStateMetadata threadStateMetadata()
388 {
389 #if CPU(X86)
390     unsigned userCount = sizeof(PlatformRegisters) / sizeof(int);
391     thread_state_flavor_t flavor = i386_THREAD_STATE;
392 #elif CPU(X86_64)
393     unsigned userCount = x86_THREAD_STATE64_COUNT;
394     thread_state_flavor_t flavor = x86_THREAD_STATE64;
395 #elif CPU(PPC)
396     unsigned userCount = PPC_THREAD_STATE_COUNT;
397     thread_state_flavor_t flavor = PPC_THREAD_STATE;
398 #elif CPU(PPC64)
399     unsigned userCount = PPC_THREAD_STATE64_COUNT;
400     thread_state_flavor_t flavor = PPC_THREAD_STATE64;
401 #elif CPU(ARM)
402     unsigned userCount = ARM_THREAD_STATE_COUNT;
403     thread_state_flavor_t flavor = ARM_THREAD_STATE;
404 #elif CPU(ARM64)
405     unsigned userCount = ARM_THREAD_STATE64_COUNT;
406     thread_state_flavor_t flavor = ARM_THREAD_STATE64;
407 #else
408 #error Unknown Architecture
409 #endif
410     return ThreadStateMetadata { userCount, flavor };
411 }
412 #endif // OS(DARWIN)
413
414 size_t Thread::getRegisters(PlatformRegisters& registers)
415 {
416     LockHolder locker(globalSuspendLock);
417 #if OS(DARWIN)
418     auto metadata = threadStateMetadata();
419     kern_return_t result = thread_get_state(m_platformThread, metadata.flavor, (thread_state_t)&registers, &metadata.userCount);
420     if (result != KERN_SUCCESS) {
421         WTFReportFatalError(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, "JavaScript garbage collection failed because thread_get_state returned an error (%d). This is probably the result of running inside Rosetta, which is not supported.", result);
422         CRASH();
423     }
424     return metadata.userCount * sizeof(uintptr_t);
425 #else
426     ASSERT_WITH_MESSAGE(m_suspendCount, "We can get registers only if the thread is suspended.");
427     registers = m_platformRegisters;
428     return sizeof(PlatformRegisters);
429 #endif
430 }
431
432 void Thread::establishPlatformSpecificHandle(pthread_t handle)
433 {
434     std::lock_guard<std::mutex> locker(m_mutex);
435     m_handle = handle;
436     if (!m_id) {
437         static std::atomic<ThreadIdentifier> provider { 0 };
438         m_id = ++provider;
439 #if OS(DARWIN)
440         m_platformThread = pthread_mach_thread_np(handle);
441 #endif
442     }
443 }
444
445 Mutex::Mutex()
446 {
447     pthread_mutexattr_t attr;
448     pthread_mutexattr_init(&attr);
449     pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
450
451     int result = pthread_mutex_init(&m_mutex, &attr);
452     ASSERT_UNUSED(result, !result);
453
454     pthread_mutexattr_destroy(&attr);
455 }
456
457 Mutex::~Mutex()
458 {
459     int result = pthread_mutex_destroy(&m_mutex);
460     ASSERT_UNUSED(result, !result);
461 }
462
463 void Mutex::lock()
464 {
465     int result = pthread_mutex_lock(&m_mutex);
466     ASSERT_UNUSED(result, !result);
467 }
468
469 bool Mutex::tryLock()
470 {
471     int result = pthread_mutex_trylock(&m_mutex);
472
473     if (result == 0)
474         return true;
475     if (result == EBUSY)
476         return false;
477
478     ASSERT_NOT_REACHED();
479     return false;
480 }
481
482 void Mutex::unlock()
483 {
484     int result = pthread_mutex_unlock(&m_mutex);
485     ASSERT_UNUSED(result, !result);
486 }
487
488 ThreadCondition::ThreadCondition()
489
490     pthread_cond_init(&m_condition, NULL);
491 }
492
493 ThreadCondition::~ThreadCondition()
494 {
495     pthread_cond_destroy(&m_condition);
496 }
497     
498 void ThreadCondition::wait(Mutex& mutex)
499 {
500     int result = pthread_cond_wait(&m_condition, &mutex.impl());
501     ASSERT_UNUSED(result, !result);
502 }
503
504 bool ThreadCondition::timedWait(Mutex& mutex, double absoluteTime)
505 {
506     if (absoluteTime < currentTime())
507         return false;
508
509     if (absoluteTime > INT_MAX) {
510         wait(mutex);
511         return true;
512     }
513
514     int timeSeconds = static_cast<int>(absoluteTime);
515     int timeNanoseconds = static_cast<int>((absoluteTime - timeSeconds) * 1E9);
516
517     timespec targetTime;
518     targetTime.tv_sec = timeSeconds;
519     targetTime.tv_nsec = timeNanoseconds;
520
521     return pthread_cond_timedwait(&m_condition, &mutex.impl(), &targetTime) == 0;
522 }
523
524 void ThreadCondition::signal()
525 {
526     int result = pthread_cond_signal(&m_condition);
527     ASSERT_UNUSED(result, !result);
528 }
529
530 void ThreadCondition::broadcast()
531 {
532     int result = pthread_cond_broadcast(&m_condition);
533     ASSERT_UNUSED(result, !result);
534 }
535
536 void Thread::yield()
537 {
538     sched_yield();
539 }
540
541 } // namespace WTF
542
543 #endif // USE(PTHREADS)