83b9d5099525b06b60e91103ddf52649ba90803c
[WebKit.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/NeverDestroyed.h>
41 #include <wtf/RawPointer.h>
42 #include <wtf/StdLibExtras.h>
43 #include <wtf/ThreadGroup.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 <semaphore.h>
60 #include <sys/mman.h>
61 #include <unistd.h>
62 #include <pthread.h>
63
64 #if HAVE(PTHREAD_NP_H)
65 #include <pthread_np.h>
66 #endif
67
68 #endif
69
70 namespace WTF {
71
72 static StaticLock globalSuspendLock;
73
74 Thread::~Thread()
75 {
76 }
77
78 #if !OS(DARWIN)
79 class Semaphore {
80     WTF_MAKE_NONCOPYABLE(Semaphore);
81     WTF_MAKE_FAST_ALLOCATED;
82 public:
83     explicit Semaphore(unsigned initialValue)
84     {
85         int sharedBetweenProcesses = 0;
86         sem_init(&m_platformSemaphore, sharedBetweenProcesses, initialValue);
87     }
88
89     ~Semaphore()
90     {
91         sem_destroy(&m_platformSemaphore);
92     }
93
94     void wait()
95     {
96         sem_wait(&m_platformSemaphore);
97     }
98
99     void post()
100     {
101         sem_post(&m_platformSemaphore);
102     }
103
104 private:
105     sem_t m_platformSemaphore;
106 };
107 static LazyNeverDestroyed<Semaphore> globalSemaphoreForSuspendResume;
108
109 // We use SIGUSR1 to suspend and resume machine threads in JavaScriptCore.
110 static constexpr const int SigThreadSuspendResume = SIGUSR1;
111 static std::atomic<Thread*> targetThread { nullptr };
112
113 #if COMPILER(GCC)
114 #pragma GCC diagnostic push
115 #pragma GCC diagnostic ignored "-Wreturn-local-addr"
116 #endif // COMPILER(GCC)
117
118 #if COMPILER(CLANG)
119 #pragma clang diagnostic push
120 #pragma clang diagnostic ignored "-Wreturn-stack-address"
121 #endif // COMPILER(CLANG)
122
123 static UNUSED_FUNCTION NEVER_INLINE void* getApproximateStackPointer()
124 {
125     volatile void* stackLocation = nullptr;
126     return &stackLocation;
127 }
128
129 #if COMPILER(GCC)
130 #pragma GCC diagnostic pop
131 #endif // COMPILER(GCC)
132
133 #if COMPILER(CLANG)
134 #pragma clang diagnostic pop
135 #endif // COMPILER(CLANG)
136
137 static UNUSED_FUNCTION bool isOnAlternativeSignalStack()
138 {
139     stack_t stack { };
140     int ret = sigaltstack(nullptr, &stack);
141     RELEASE_ASSERT(!ret);
142     return stack.ss_flags == SS_ONSTACK;
143 }
144
145 void Thread::signalHandlerSuspendResume(int, siginfo_t*, void* ucontext)
146 {
147     // Touching thread local atomic types from signal handlers is allowed.
148     Thread* thread = targetThread.load();
149
150     if (thread->m_suspended.load(std::memory_order_acquire)) {
151         // This is signal handler invocation that is intended to be used to resume sigsuspend.
152         // So this handler invocation itself should not process.
153         //
154         // When signal comes, first, the system calls signal handler. And later, sigsuspend will be resumed. Signal handler invocation always precedes.
155         // So, the problem never happens that suspended.store(true, ...) will be executed before the handler is called.
156         // http://pubs.opengroup.org/onlinepubs/009695399/functions/sigsuspend.html
157         return;
158     }
159
160     ucontext_t* userContext = static_cast<ucontext_t*>(ucontext);
161     ASSERT_WITH_MESSAGE(!isOnAlternativeSignalStack(), "Using an alternative signal stack is not supported. Consider disabling the concurrent GC.");
162
163 #if HAVE(MACHINE_CONTEXT)
164     thread->m_platformRegisters = &registersFromUContext(userContext);
165 #else
166     PlatformRegisters platformRegisters { getApproximateStackPointer() };
167     thread->m_platformRegisters = &platformRegisters;
168 #endif
169
170     // Allow suspend caller to see that this thread is suspended.
171     // sem_post is async-signal-safe function. It means that we can call this from a signal handler.
172     // http://pubs.opengroup.org/onlinepubs/009695399/functions/xsh_chap02_04.html#tag_02_04_03
173     //
174     // And sem_post emits memory barrier that ensures that PlatformRegisters are correctly saved.
175     // http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap04.html#tag_04_11
176     globalSemaphoreForSuspendResume->post();
177
178     // Reaching here, SigThreadSuspendResume is blocked in this handler (this is configured by sigaction's sa_mask).
179     // So before calling sigsuspend, SigThreadSuspendResume to this thread is deferred. This ensures that the handler is not executed recursively.
180     sigset_t blockedSignalSet;
181     sigfillset(&blockedSignalSet);
182     sigdelset(&blockedSignalSet, SigThreadSuspendResume);
183     sigsuspend(&blockedSignalSet);
184
185     thread->m_platformRegisters = nullptr;
186
187     // Allow resume caller to see that this thread is resumed.
188     globalSemaphoreForSuspendResume->post();
189 }
190
191 #endif // !OS(DARWIN)
192
193 void Thread::initializePlatformThreading()
194 {
195 #if !OS(DARWIN)
196     globalSemaphoreForSuspendResume.construct(0);
197
198     // Signal handlers are process global configuration.
199     // Intentionally block SigThreadSuspendResume in the handler.
200     // SigThreadSuspendResume will be allowed in the handler by sigsuspend.
201     struct sigaction action;
202     sigemptyset(&action.sa_mask);
203     sigaddset(&action.sa_mask, SigThreadSuspendResume);
204
205     action.sa_sigaction = &signalHandlerSuspendResume;
206     action.sa_flags = SA_RESTART | SA_SIGINFO;
207     sigaction(SigThreadSuspendResume, &action, 0);
208 #endif
209 }
210
211 void Thread::initializeCurrentThreadEvenIfNonWTFCreated()
212 {
213 #if !OS(DARWIN)
214     sigset_t mask;
215     sigemptyset(&mask);
216     sigaddset(&mask, SigThreadSuspendResume);
217     pthread_sigmask(SIG_UNBLOCK, &mask, 0);
218 #endif
219 }
220
221 static void* wtfThreadEntryPoint(void* context)
222 {
223     Thread::entryPoint(reinterpret_cast<Thread::NewThreadContext*>(context));
224     return nullptr;
225 }
226
227 bool Thread::establishHandle(NewThreadContext* context)
228 {
229     pthread_t threadHandle;
230     pthread_attr_t attr;
231     pthread_attr_init(&attr);
232 #if HAVE(QOS_CLASSES)
233     pthread_attr_set_qos_class_np(&attr, adjustedQOSClass(QOS_CLASS_USER_INITIATED), 0);
234 #endif
235     int error = pthread_create(&threadHandle, &attr, wtfThreadEntryPoint, context);
236     pthread_attr_destroy(&attr);
237     if (error) {
238         LOG_ERROR("Failed to create pthread at entry point %p with context %p", wtfThreadEntryPoint, context);
239         return false;
240     }
241     establishPlatformSpecificHandle(threadHandle);
242     return true;
243 }
244
245 void Thread::initializeCurrentThreadInternal(const char* threadName)
246 {
247 #if HAVE(PTHREAD_SETNAME_NP)
248     pthread_setname_np(normalizeThreadName(threadName));
249 #elif OS(LINUX)
250     prctl(PR_SET_NAME, normalizeThreadName(threadName));
251 #else
252     UNUSED_PARAM(threadName);
253 #endif
254     initializeCurrentThreadEvenIfNonWTFCreated();
255 }
256
257 void Thread::changePriority(int delta)
258 {
259     std::lock_guard<std::mutex> locker(m_mutex);
260
261     int policy;
262     struct sched_param param;
263
264     if (pthread_getschedparam(m_handle, &policy, &param))
265         return;
266
267     param.sched_priority += delta;
268
269     pthread_setschedparam(m_handle, policy, &param);
270 }
271
272 int Thread::waitForCompletion()
273 {
274     pthread_t handle;
275     {
276         std::lock_guard<std::mutex> locker(m_mutex);
277         handle = m_handle;
278     }
279
280     int joinResult = pthread_join(handle, 0);
281
282     if (joinResult == EDEADLK)
283         LOG_ERROR("ThreadIdentifier %u was found to be deadlocked trying to quit", m_id);
284     else if (joinResult)
285         LOG_ERROR("ThreadIdentifier %u was unable to be joined.\n", m_id);
286
287     std::lock_guard<std::mutex> locker(m_mutex);
288     ASSERT(joinableState() == Joinable);
289
290     // 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.
291     // In both cases, Thread::destructTLS() will take care of destroying Thread.
292     if (!hasExited())
293         didJoin();
294
295     return joinResult;
296 }
297
298 void Thread::detach()
299 {
300     std::lock_guard<std::mutex> locker(m_mutex);
301     int detachResult = pthread_detach(m_handle);
302     if (detachResult)
303         LOG_ERROR("ThreadIdentifier %u was unable to be detached\n", m_id);
304
305     if (!hasExited())
306         didBecomeDetached();
307 }
308
309 Thread& Thread::initializeCurrentTLS()
310 {
311     // Not a WTF-created thread, ThreadIdentifier is not established yet.
312     Ref<Thread> thread = adoptRef(*new Thread());
313     thread->establishPlatformSpecificHandle(pthread_self());
314     thread->initializeInThread();
315     initializeCurrentThreadEvenIfNonWTFCreated();
316
317     return initializeTLS(WTFMove(thread));
318 }
319
320 ThreadIdentifier Thread::currentID()
321 {
322     return current().id();
323 }
324
325 bool Thread::signal(int signalNumber)
326 {
327     std::lock_guard<std::mutex> locker(m_mutex);
328     if (hasExited())
329         return false;
330     int errNo = pthread_kill(m_handle, signalNumber);
331     return !errNo; // A 0 errNo means success.
332 }
333
334 auto Thread::suspend() -> Expected<void, PlatformSuspendError>
335 {
336     RELEASE_ASSERT_WITH_MESSAGE(id() != currentThread(), "We do not support suspending the current thread itself.");
337     // During suspend, suspend or resume should not be executed from the other threads.
338     // We use global lock instead of per thread lock.
339     // Consider the following case, there are threads A and B.
340     // And A attempt to suspend B and B attempt to suspend A.
341     // A and B send signals. And later, signals are delivered to A and B.
342     // In that case, both will be suspended.
343     //
344     // And it is important to use a global lock to suspend and resume. Let's consider using per-thread lock.
345     // Your issuing thread (A) attempts to suspend the target thread (B). Then, you will suspend the thread (C) additionally.
346     // This case frequently happens if you stop threads to perform stack scanning. But thread (B) may hold the lock of thread (C).
347     // In that case, dead lock happens. Using global lock here avoids this dead lock.
348     LockHolder locker(globalSuspendLock);
349 #if OS(DARWIN)
350     kern_return_t result = thread_suspend(m_platformThread);
351     if (result != KERN_SUCCESS)
352         return makeUnexpected(result);
353     return { };
354 #else
355     if (!m_suspendCount) {
356         // Ideally, we would like to use pthread_sigqueue. It allows us to pass the argument to the signal handler.
357         // But it can be used in a few platforms, like Linux.
358         // Instead, we use Thread* stored in the thread local storage to pass it to the signal handler.
359         targetThread.store(this);
360         int result = pthread_kill(m_handle, SigThreadSuspendResume);
361         if (result)
362             return makeUnexpected(result);
363         globalSemaphoreForSuspendResume->wait();
364         // Release barrier ensures that this operation is always executed after all the above processing is done.
365         m_suspended.store(true, std::memory_order_release);
366     }
367     ++m_suspendCount;
368     return { };
369 #endif
370 }
371
372 void Thread::resume()
373 {
374     // During resume, suspend or resume should not be executed from the other threads.
375     LockHolder locker(globalSuspendLock);
376 #if OS(DARWIN)
377     thread_resume(m_platformThread);
378 #else
379     if (m_suspendCount == 1) {
380         // When allowing SigThreadSuspendResume interrupt in the signal handler by sigsuspend and SigThreadSuspendResume is actually issued,
381         // the signal handler itself will be called once again.
382         // There are several ways to distinguish the handler invocation for suspend and resume.
383         // 1. Use different signal numbers. And check the signal number in the handler.
384         // 2. Use some arguments to distinguish suspend and resume in the handler. If pthread_sigqueue can be used, we can take this.
385         // 3. Use thread local storage with atomic variables in the signal handler.
386         // In this implementaiton, we take (3). suspended flag is used to distinguish it.
387         targetThread.store(this);
388         if (pthread_kill(m_handle, SigThreadSuspendResume) == ESRCH)
389             return;
390         globalSemaphoreForSuspendResume->wait();
391         // Release barrier ensures that this operation is always executed after all the above processing is done.
392         m_suspended.store(false, std::memory_order_release);
393     }
394     --m_suspendCount;
395 #endif
396 }
397
398 #if OS(DARWIN)
399 struct ThreadStateMetadata {
400     unsigned userCount;
401     thread_state_flavor_t flavor;
402 };
403
404 static ThreadStateMetadata threadStateMetadata()
405 {
406 #if CPU(X86)
407     unsigned userCount = sizeof(PlatformRegisters) / sizeof(int);
408     thread_state_flavor_t flavor = i386_THREAD_STATE;
409 #elif CPU(X86_64)
410     unsigned userCount = x86_THREAD_STATE64_COUNT;
411     thread_state_flavor_t flavor = x86_THREAD_STATE64;
412 #elif CPU(PPC)
413     unsigned userCount = PPC_THREAD_STATE_COUNT;
414     thread_state_flavor_t flavor = PPC_THREAD_STATE;
415 #elif CPU(PPC64)
416     unsigned userCount = PPC_THREAD_STATE64_COUNT;
417     thread_state_flavor_t flavor = PPC_THREAD_STATE64;
418 #elif CPU(ARM)
419     unsigned userCount = ARM_THREAD_STATE_COUNT;
420     thread_state_flavor_t flavor = ARM_THREAD_STATE;
421 #elif CPU(ARM64)
422     unsigned userCount = ARM_THREAD_STATE64_COUNT;
423     thread_state_flavor_t flavor = ARM_THREAD_STATE64;
424 #else
425 #error Unknown Architecture
426 #endif
427     return ThreadStateMetadata { userCount, flavor };
428 }
429 #endif // OS(DARWIN)
430
431 size_t Thread::getRegisters(PlatformRegisters& registers)
432 {
433     LockHolder locker(globalSuspendLock);
434 #if OS(DARWIN)
435     auto metadata = threadStateMetadata();
436     kern_return_t result = thread_get_state(m_platformThread, metadata.flavor, (thread_state_t)&registers, &metadata.userCount);
437     if (result != KERN_SUCCESS) {
438         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);
439         CRASH();
440     }
441     return metadata.userCount * sizeof(uintptr_t);
442 #else
443     ASSERT_WITH_MESSAGE(m_suspendCount, "We can get registers only if the thread is suspended.");
444     ASSERT(m_platformRegisters);
445     registers = *m_platformRegisters;
446     return sizeof(PlatformRegisters);
447 #endif
448 }
449
450 void Thread::establishPlatformSpecificHandle(pthread_t handle)
451 {
452     std::lock_guard<std::mutex> locker(m_mutex);
453     m_handle = handle;
454     if (!m_id) {
455         static std::atomic<ThreadIdentifier> provider { 0 };
456         m_id = ++provider;
457 #if OS(DARWIN)
458         m_platformThread = pthread_mach_thread_np(handle);
459 #endif
460     }
461 }
462
463 #if !HAVE(FAST_TLS)
464 void Thread::initializeTLSKey()
465 {
466     threadSpecificKeyCreate(&s_key, destructTLS);
467 }
468 #endif
469
470 Thread& Thread::initializeTLS(Ref<Thread>&& thread)
471 {
472     // We leak the ref to keep the Thread alive while it is held in TLS. destructTLS will deref it later at thread destruction time.
473     auto& threadInTLS = thread.leakRef();
474 #if !HAVE(FAST_TLS)
475     ASSERT(s_key != InvalidThreadSpecificKey);
476     threadSpecificSet(s_key, &threadInTLS);
477 #else
478     _pthread_setspecific_direct(WTF_THREAD_DATA_KEY, &threadInTLS);
479     pthread_key_init_np(WTF_THREAD_DATA_KEY, &destructTLS);
480 #endif
481     return threadInTLS;
482 }
483
484 void Thread::destructTLS(void* data)
485 {
486     Thread* thread = static_cast<Thread*>(data);
487     ASSERT(thread);
488
489     if (thread->m_isDestroyedOnce) {
490         thread->didExit();
491         thread->deref();
492         return;
493     }
494
495     thread->m_isDestroyedOnce = true;
496     // Re-setting the value for key causes another destructTLS() call after all other thread-specific destructors were called.
497 #if !HAVE(FAST_TLS)
498     ASSERT(s_key != InvalidThreadSpecificKey);
499     threadSpecificSet(s_key, thread);
500 #else
501     _pthread_setspecific_direct(WTF_THREAD_DATA_KEY, thread);
502     pthread_key_init_np(WTF_THREAD_DATA_KEY, &destructTLS);
503 #endif
504 }
505
506 Mutex::Mutex()
507 {
508     pthread_mutexattr_t attr;
509     pthread_mutexattr_init(&attr);
510     pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
511
512     int result = pthread_mutex_init(&m_mutex, &attr);
513     ASSERT_UNUSED(result, !result);
514
515     pthread_mutexattr_destroy(&attr);
516 }
517
518 Mutex::~Mutex()
519 {
520     int result = pthread_mutex_destroy(&m_mutex);
521     ASSERT_UNUSED(result, !result);
522 }
523
524 void Mutex::lock()
525 {
526     int result = pthread_mutex_lock(&m_mutex);
527     ASSERT_UNUSED(result, !result);
528 }
529
530 bool Mutex::tryLock()
531 {
532     int result = pthread_mutex_trylock(&m_mutex);
533
534     if (result == 0)
535         return true;
536     if (result == EBUSY)
537         return false;
538
539     ASSERT_NOT_REACHED();
540     return false;
541 }
542
543 void Mutex::unlock()
544 {
545     int result = pthread_mutex_unlock(&m_mutex);
546     ASSERT_UNUSED(result, !result);
547 }
548
549 ThreadCondition::ThreadCondition()
550
551     pthread_cond_init(&m_condition, NULL);
552 }
553
554 ThreadCondition::~ThreadCondition()
555 {
556     pthread_cond_destroy(&m_condition);
557 }
558     
559 void ThreadCondition::wait(Mutex& mutex)
560 {
561     int result = pthread_cond_wait(&m_condition, &mutex.impl());
562     ASSERT_UNUSED(result, !result);
563 }
564
565 bool ThreadCondition::timedWait(Mutex& mutex, double absoluteTime)
566 {
567     if (absoluteTime < currentTime())
568         return false;
569
570     if (absoluteTime > INT_MAX) {
571         wait(mutex);
572         return true;
573     }
574
575     int timeSeconds = static_cast<int>(absoluteTime);
576     int timeNanoseconds = static_cast<int>((absoluteTime - timeSeconds) * 1E9);
577
578     timespec targetTime;
579     targetTime.tv_sec = timeSeconds;
580     targetTime.tv_nsec = timeNanoseconds;
581
582     return pthread_cond_timedwait(&m_condition, &mutex.impl(), &targetTime) == 0;
583 }
584
585 void ThreadCondition::signal()
586 {
587     int result = pthread_cond_signal(&m_condition);
588     ASSERT_UNUSED(result, !result);
589 }
590
591 void ThreadCondition::broadcast()
592 {
593     int result = pthread_cond_broadcast(&m_condition);
594     ASSERT_UNUSED(result, !result);
595 }
596
597 void Thread::yield()
598 {
599     sched_yield();
600 }
601
602 } // namespace WTF
603
604 #endif // USE(PTHREADS)