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