1 /* Copyright (C) 2002-2021 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Lesser General Public
6 License as published by the Free Software Foundation; either
7 version 2.1 of the License, or (at your option) any later version.
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Lesser General Public License for more details.
14 You should have received a copy of the GNU Lesser General Public
15 License along with the GNU C Library; if not, see
16 <https://www.gnu.org/licenses/>. */
25 #include <hp-timing.h>
28 #include <libc-diag.h>
29 #include <libc-internal.h>
31 #include <kernel-features.h>
32 #include <default-sched.h>
33 #include <futex-internal.h>
34 #include <tls-setup.h>
35 #include <rseq-internal.h>
37 #include <sys/single_threaded.h>
39 #include <clone_internal.h>
40 #include <futex-internal.h>
42 #include <shlib-compat.h>
44 #include <stap-probe.h>
47 /* Globally enabled events. */
48 td_thr_events_t __nptl_threads_events
;
49 libc_hidden_proto (__nptl_threads_events
)
50 libc_hidden_data_def (__nptl_threads_events
)
52 /* Pointer to descriptor with the last event. */
53 struct pthread
*__nptl_last_event
;
54 libc_hidden_proto (__nptl_last_event
)
55 libc_hidden_data_def (__nptl_last_event
)
58 /* This variable is used to access _rtld_global from libthread_db. If
59 GDB loads libpthread before ld.so, it is not possible to resolve
60 _rtld_global directly during libpthread initialization. */
61 struct rtld_global
*__nptl_rtld_global
= &_rtld_global
;
64 /* Version of the library, used in libthread_db to detect mismatches. */
65 const char __nptl_version
[] = VERSION
;
67 /* This performs the initialization necessary when going from
68 single-threaded to multi-threaded mode for the first time. */
73 __sigemptyset (&sa
.sa_mask
);
75 /* Install the handle to change the threads' uid/gid. Use
76 SA_ONSTACK because the signal may be sent to threads that are
77 running with custom stacks. (This is less likely for
79 sa
.sa_sigaction
= __nptl_setxid_sighandler
;
80 sa
.sa_flags
= SA_ONSTACK
| SA_SIGINFO
| SA_RESTART
;
81 (void) __libc_sigaction (SIGSETXID
, &sa
, NULL
);
83 /* The parent process might have left the signals blocked. Just in
84 case, unblock it. We reuse the signal mask in the sigaction
85 structure. It is already cleared. */
86 __sigaddset (&sa
.sa_mask
, SIGCANCEL
);
87 __sigaddset (&sa
.sa_mask
, SIGSETXID
);
88 INTERNAL_SYSCALL_CALL (rt_sigprocmask
, SIG_UNBLOCK
, &sa
.sa_mask
,
92 /* Code to allocate and deallocate a stack. */
93 #include "allocatestack.c"
97 Understanding who is the owner of the 'struct pthread' or 'PD'
98 (refers to the value of the 'struct pthread *pd' function argument)
99 is critically important in determining exactly which operations are
100 allowed and which are not and when, particularly when it comes to the
101 implementation of pthread_create, pthread_join, pthread_detach, and
102 other functions which all operate on PD.
104 The owner of PD is responsible for freeing the final resources
105 associated with PD, and may examine the memory underlying PD at any
106 point in time until it frees it back to the OS or to reuse by the
109 The thread which calls pthread_create is called the creating thread.
110 The creating thread begins as the owner of PD.
112 During startup the new thread may examine PD in coordination with the
113 owner thread (which may be itself).
115 The four cases of ownership transfer are:
117 (1) Ownership of PD is released to the process (all threads may use it)
118 after the new thread starts in a joinable state
119 i.e. pthread_create returns a usable pthread_t.
121 (2) Ownership of PD is released to the new thread starting in a detached
124 (3) Ownership of PD is dynamically released to a running thread via
127 (4) Ownership of PD is acquired by the thread which calls pthread_join.
129 Implementation notes:
131 The PD->stopped_start and thread_ran variables are used to determine
132 exactly which of the four ownership states we are in and therefore
133 what actions can be taken. For example after (2) we cannot read or
134 write from PD anymore since the thread may no longer exist and the
135 memory may be unmapped.
137 It is important to point out that PD->lock is being used both
138 similar to a one-shot semaphore and subsequently as a mutex. The
139 lock is taken in the parent to force the child to wait, and then the
140 child releases the lock. However, this semaphore-like effect is used
141 only for synchronizing the parent and child. After startup the lock
142 is used like a mutex to create a critical section during which a
143 single owner modifies the thread parameters.
145 The most complicated cases happen during thread startup:
147 (a) If the created thread is in a detached (PTHREAD_CREATE_DETACHED),
148 or joinable (default PTHREAD_CREATE_JOINABLE) state and
149 STOPPED_START is true, then the creating thread has ownership of
150 PD until the PD->lock is released by pthread_create. If any
151 errors occur we are in states (c) or (d) below.
153 (b) If the created thread is in a detached state
154 (PTHREAD_CREATED_DETACHED), and STOPPED_START is false, then the
155 creating thread has ownership of PD until it invokes the OS
156 kernel's thread creation routine. If this routine returns
157 without error, then the created thread owns PD; otherwise, see
160 (c) If either a joinable or detached thread setup failed and THREAD_RAN
161 is true, then the creating thread releases ownership to the new thread,
162 the created thread sees the failed setup through PD->setup_failed
163 member, releases the PD ownership, and exits. The creating thread will
164 be responsible for cleanup the allocated resources. The THREAD_RAN is
165 local to creating thread and indicate whether thread creation or setup
168 (d) If the thread creation failed and THREAD_RAN is false (meaning
169 ARCH_CLONE has failed), then the creating thread retains ownership
170 of PD and must cleanup he allocated resource. No waiting for the new
171 thread is required because it never started.
173 The nptl_db interface:
175 The interface with nptl_db requires that we enqueue PD into a linked
176 list and then call a function which the debugger will trap. The PD
177 will then be dequeued and control returned to the thread. The caller
178 at the time must have ownership of PD and such ownership remains
179 after control returns to thread. The enqueued PD is removed from the
180 linked list by the nptl_db callback td_thr_event_getmsg. The debugger
181 must ensure that the thread does not resume execution, otherwise
182 ownership of PD may be lost and examining PD will not be possible.
184 Note that the GNU Debugger as of (December 10th 2015) commit
185 c2c2a31fdb228d41ce3db62b268efea04bd39c18 no longer uses
186 td_thr_event_getmsg and several other related nptl_db interfaces. The
187 principal reason for this is that nptl_db does not support non-stop
188 mode where other threads can run concurrently and modify runtime
189 structures currently in use by the debugger and the nptl_db
194 * The create_thread function can never set stopped_start to false.
195 * The created thread can read stopped_start but never write to it.
196 * The variable thread_ran is set some time after the OS thread
197 creation routine returns, how much time after the thread is created
198 is unspecified, but it should be as quickly as possible.
202 /* CREATE THREAD NOTES:
204 create_thread must initialize PD->stopped_start. It should be true
205 if the STOPPED_START parameter is true, or if create_thread needs the
206 new thread to synchronize at startup for some other implementation
207 reason. If STOPPED_START will be true, then create_thread is obliged
208 to lock PD->lock before starting the thread. Then pthread_create
209 unlocks PD->lock which synchronizes-with create_thread in the
210 child thread which does an acquire/release of PD->lock as the last
211 action before calling the user entry point. The goal of all of this
212 is to ensure that the required initial thread attributes are applied
213 (by the creating thread) before the new thread runs user code. Note
214 that the the functions pthread_getschedparam, pthread_setschedparam,
215 pthread_setschedprio, __pthread_tpp_change_priority, and
216 __pthread_current_priority reuse the same lock, PD->lock, for a
217 similar purpose e.g. synchronizing the setting of similar thread
218 attributes. These functions are never called before the thread is
219 created, so don't participate in startup syncronization, but given
220 that the lock is present already and in the unlocked state, reusing
223 The return value is zero for success or an errno code for failure.
224 If the return value is ENOMEM, that will be translated to EAGAIN,
225 so create_thread need not do that. On failure, *THREAD_RAN should
226 be set to true iff the thread actually started up but before calling
227 the user code (*PD->start_routine). */
229 static int _Noreturn
start_thread (void *arg
);
231 static int create_thread (struct pthread
*pd
, const struct pthread_attr
*attr
,
232 bool *stopped_start
, void *stackaddr
,
233 size_t stacksize
, bool *thread_ran
)
235 /* Determine whether the newly created threads has to be started
236 stopped since we have to set the scheduling parameters or set the
238 bool need_setaffinity
= (attr
!= NULL
&& attr
->extension
!= NULL
239 && attr
->extension
->cpuset
!= 0);
241 && (__glibc_unlikely (need_setaffinity
)
242 || __glibc_unlikely ((attr
->flags
& ATTR_FLAG_NOTINHERITSCHED
) != 0)))
243 *stopped_start
= true;
245 pd
->stopped_start
= *stopped_start
;
246 if (__glibc_unlikely (*stopped_start
))
247 lll_lock (pd
->lock
, LLL_PRIVATE
);
249 /* We rely heavily on various flags the CLONE function understands:
251 CLONE_VM, CLONE_FS, CLONE_FILES
252 These flags select semantics with shared address space and
253 file descriptors according to what POSIX requires.
255 CLONE_SIGHAND, CLONE_THREAD
256 This flag selects the POSIX signal semantics and various
257 other kinds of sharing (itimers, POSIX timers, etc.).
260 The sixth parameter to CLONE determines the TLS area for the
264 The kernels writes the thread ID of the newly created thread
265 into the location pointed to by the fifth parameters to CLONE.
267 Note that it would be semantically equivalent to use
268 CLONE_CHILD_SETTID but it is be more expensive in the kernel.
271 The kernels clears the thread ID of a thread that has called
272 sys_exit() in the location pointed to by the seventh parameter
275 The termination signal is chosen to be zero which means no signal
277 const int clone_flags
= (CLONE_VM
| CLONE_FS
| CLONE_FILES
| CLONE_SYSVSEM
278 | CLONE_SIGHAND
| CLONE_THREAD
279 | CLONE_SETTLS
| CLONE_PARENT_SETTID
280 | CLONE_CHILD_CLEARTID
283 TLS_DEFINE_INIT_TP (tp
, pd
);
285 struct clone_args args
=
287 .flags
= clone_flags
,
288 .pidfd
= (uintptr_t) &pd
->tid
,
289 .parent_tid
= (uintptr_t) &pd
->tid
,
290 .child_tid
= (uintptr_t) &pd
->tid
,
291 .stack
= (uintptr_t) stackaddr
,
292 .stack_size
= stacksize
,
293 .tls
= (uintptr_t) tp
,
295 int ret
= __clone_internal (&args
, &start_thread
, pd
);
296 if (__glibc_unlikely (ret
== -1))
299 /* It's started now, so if we fail below, we'll have to let it clean itself
303 /* Now we have the possibility to set scheduling parameters etc. */
306 /* Set the affinity mask if necessary. */
307 if (need_setaffinity
)
309 assert (*stopped_start
);
311 int res
= INTERNAL_SYSCALL_CALL (sched_setaffinity
, pd
->tid
,
312 attr
->extension
->cpusetsize
,
313 attr
->extension
->cpuset
);
314 if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (res
)))
315 return INTERNAL_SYSCALL_ERRNO (res
);
318 /* Set the scheduling parameters. */
319 if ((attr
->flags
& ATTR_FLAG_NOTINHERITSCHED
) != 0)
321 assert (*stopped_start
);
323 int res
= INTERNAL_SYSCALL_CALL (sched_setscheduler
, pd
->tid
,
324 pd
->schedpolicy
, &pd
->schedparam
);
325 if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (res
)))
326 return INTERNAL_SYSCALL_ERRNO (res
);
333 /* Local function to start thread and handle cleanup. */
335 start_thread (void *arg
)
337 struct pthread
*pd
= arg
;
339 /* We are either in (a) or (b), and in either case we either own PD already
340 (2) or are about to own PD (1), and so our only restriction would be that
341 we can't free PD until we know we have ownership (see CONCURRENCY NOTES
343 if (pd
->stopped_start
)
345 bool setup_failed
= false;
347 /* Get the lock the parent locked to force synchronization. */
348 lll_lock (pd
->lock
, LLL_PRIVATE
);
350 /* We have ownership of PD now, for detached threads with setup failure
351 we set it as joinable so the creating thread could synchronous join
352 and free any resource prior return to the pthread_create caller. */
353 setup_failed
= pd
->setup_failed
== 1;
357 /* And give it up right away. */
358 lll_unlock (pd
->lock
, LLL_PRIVATE
);
364 /* Initialize resolver state pointer. */
367 /* Initialize pointers to locale data. */
370 /* Register rseq TLS to the kernel. */
372 bool do_rseq
= THREAD_GETMEM (pd
, flags
) & ATTR_FLAG_DO_RSEQ
;
373 rseq_register_current_thread (pd
, do_rseq
);
376 #ifndef __ASSUME_SET_ROBUST_LIST
377 if (__nptl_set_robust_list_avail
)
380 /* This call should never fail because the initial call in init.c
382 INTERNAL_SYSCALL_CALL (set_robust_list
, &pd
->robust_head
,
383 sizeof (struct robust_list_head
));
386 /* This is where the try/finally block should be created. For
387 compilers without that support we do use setjmp. */
388 struct pthread_unwind_buf unwind_buf
;
391 DIAG_PUSH_NEEDS_COMMENT
;
392 #if __GNUC_PREREQ (7, 0)
393 /* This call results in a -Wstringop-overflow warning because struct
394 pthread_unwind_buf is smaller than jmp_buf. setjmp and longjmp
395 do not use anything beyond the common prefix (they never access
396 the saved signal mask), so that is a false positive. */
397 DIAG_IGNORE_NEEDS_COMMENT (11, "-Wstringop-overflow=");
399 not_first_call
= setjmp ((struct __jmp_buf_tag
*) unwind_buf
.cancel_jmp_buf
);
400 DIAG_POP_NEEDS_COMMENT
;
402 /* No previous handlers. NB: This must be done after setjmp since the
403 private space in the unwind jump buffer may overlap space used by
404 setjmp to store extra architecture-specific information which is
405 never used by the cancellation-specific __libc_unwind_longjmp.
407 The private space is allowed to overlap because the unwinder never
408 has to return through any of the jumped-to call frames, and thus
409 only a minimum amount of saved data need be stored, and for example,
410 need not include the process signal mask information. This is all
411 an optimization to reduce stack usage when pushing cancellation
413 unwind_buf
.priv
.data
.prev
= NULL
;
414 unwind_buf
.priv
.data
.cleanup
= NULL
;
416 /* Allow setxid from now onwards. */
417 if (__glibc_unlikely (atomic_exchange_acq (&pd
->setxid_futex
, 0) == -2))
418 futex_wake (&pd
->setxid_futex
, 1, FUTEX_PRIVATE
);
420 if (__glibc_likely (! not_first_call
))
422 /* Store the new cleanup handler info. */
423 THREAD_SETMEM (pd
, cleanup_jmp_buf
, &unwind_buf
);
425 __libc_signal_restore_set (&pd
->sigmask
);
427 LIBC_PROBE (pthread_start
, 3, (pthread_t
) pd
, pd
->start_routine
, pd
->arg
);
429 /* Run the code the user provided. */
433 /* The function pointer of the c11 thread start is cast to an incorrect
434 type on __pthread_create_2_1 call, however it is casted back to correct
435 one so the call behavior is well-defined (it is assumed that pointers
436 to void are able to represent all values of int. */
437 int (*start
)(void*) = (int (*) (void*)) pd
->start_routine
;
438 ret
= (void*) (uintptr_t) start (pd
->arg
);
441 ret
= pd
->start_routine (pd
->arg
);
442 THREAD_SETMEM (pd
, result
, ret
);
445 /* Call destructors for the thread_local TLS variables. */
447 if (&__call_tls_dtors
!= NULL
)
451 /* Run the destructor for the thread-local data. */
452 __nptl_deallocate_tsd ();
454 /* Clean up any state libc stored in thread-local variables. */
455 __libc_thread_freeres ();
457 /* Report the death of the thread if this is wanted. */
458 if (__glibc_unlikely (pd
->report_events
))
460 /* See whether TD_DEATH is in any of the mask. */
461 const int idx
= __td_eventword (TD_DEATH
);
462 const uint32_t mask
= __td_eventmask (TD_DEATH
);
464 if ((mask
& (__nptl_threads_events
.event_bits
[idx
]
465 | pd
->eventbuf
.eventmask
.event_bits
[idx
])) != 0)
467 /* Yep, we have to signal the death. Add the descriptor to
468 the list but only if it is not already on it. */
469 if (pd
->nextevent
== NULL
)
471 pd
->eventbuf
.eventnum
= TD_DEATH
;
472 pd
->eventbuf
.eventdata
= pd
;
475 pd
->nextevent
= __nptl_last_event
;
476 while (atomic_compare_and_exchange_bool_acq (&__nptl_last_event
,
480 /* Now call the function which signals the event. See
481 CONCURRENCY NOTES for the nptl_db interface comments. */
482 __nptl_death_event ();
486 /* The thread is exiting now. Don't set this bit until after we've hit
487 the event-reporting breakpoint, so that td_thr_get_info on us while at
488 the breakpoint reports TD_THR_RUN state rather than TD_THR_ZOMBIE. */
489 atomic_bit_set (&pd
->cancelhandling
, EXITING_BIT
);
491 if (__glibc_unlikely (atomic_decrement_and_test (&__nptl_nthreads
)))
492 /* This was the last thread. */
495 /* This prevents sending a signal from this thread to itself during
496 its final stages. This must come after the exit call above
497 because atexit handlers must not run with signals blocked.
499 Do not block SIGSETXID. The setxid handshake below expects the
500 signal to be delivered. (SIGSETXID cannot run application code,
501 nor does it use pthread_kill.) Reuse the pd->sigmask space for
502 computing the signal mask, to save stack space. */
503 __sigfillset (&pd
->sigmask
);
504 __sigdelset (&pd
->sigmask
, SIGSETXID
);
505 INTERNAL_SYSCALL_CALL (rt_sigprocmask
, SIG_BLOCK
, &pd
->sigmask
, NULL
,
508 /* Tell __pthread_kill_internal that this thread is about to exit.
509 If there is a __pthread_kill_internal in progress, this delays
510 the thread exit until the signal has been queued by the kernel
511 (so that the TID used to send it remains valid). */
512 __libc_lock_lock (pd
->exit_lock
);
514 __libc_lock_unlock (pd
->exit_lock
);
516 #ifndef __ASSUME_SET_ROBUST_LIST
517 /* If this thread has any robust mutexes locked, handle them now. */
518 # if __PTHREAD_MUTEX_HAVE_PREV
519 void *robust
= pd
->robust_head
.list
;
521 __pthread_slist_t
*robust
= pd
->robust_list
.__next
;
523 /* We let the kernel do the notification if it is able to do so.
524 If we have to do it here there for sure are no PI mutexes involved
525 since the kernel support for them is even more recent. */
526 if (!__nptl_set_robust_list_avail
527 && __builtin_expect (robust
!= (void *) &pd
->robust_head
, 0))
531 struct __pthread_mutex_s
*this = (struct __pthread_mutex_s
*)
532 ((char *) robust
- offsetof (struct __pthread_mutex_s
,
534 robust
= *((void **) robust
);
536 # if __PTHREAD_MUTEX_HAVE_PREV
537 this->__list
.__prev
= NULL
;
539 this->__list
.__next
= NULL
;
541 atomic_or (&this->__lock
, FUTEX_OWNER_DIED
);
542 futex_wake ((unsigned int *) &this->__lock
, 1,
543 /* XYZ */ FUTEX_SHARED
);
545 while (robust
!= (void *) &pd
->robust_head
);
550 advise_stack_range (pd
->stackblock
, pd
->stackblock_size
, (uintptr_t) pd
,
553 if (__glibc_unlikely (pd
->cancelhandling
& SETXID_BITMASK
))
555 /* Some other thread might call any of the setXid functions and expect
556 us to reply. In this case wait until we did that. */
558 /* XXX This differs from the typical futex_wait_simple pattern in that
559 the futex_wait condition (setxid_futex) is different from the
560 condition used in the surrounding loop (cancelhandling). We need
561 to check and document why this is correct. */
562 futex_wait_simple (&pd
->setxid_futex
, 0, FUTEX_PRIVATE
);
563 while (pd
->cancelhandling
& SETXID_BITMASK
);
565 /* Reset the value so that the stack can be reused. */
566 pd
->setxid_futex
= 0;
569 /* If the thread is detached free the TCB. */
570 if (IS_DETACHED (pd
))
572 __nptl_free_tcb (pd
);
575 /* We cannot call '_exit' here. '_exit' will terminate the process.
577 The 'exit' implementation in the kernel will signal when the
578 process is really dead since 'clone' got passed the CLONE_CHILD_CLEARTID
579 flag. The 'tid' field in the TCB will be set to zero.
581 rseq TLS is still registered at this point. Rely on implicit
582 unregistration performed by the kernel on thread teardown. This is not a
583 problem because the rseq TLS lives on the stack, and the stack outlives
584 the thread. If TCB allocation is ever changed, additional steps may be
585 required, such as performing explicit rseq unregistration before
586 reclaiming the rseq TLS area memory. It is NOT sufficient to block
587 signals because the kernel may write to the rseq area even without
590 The exit code is zero since in case all threads exit by calling
591 'pthread_exit' the exit status must be 0 (zero). */
593 INTERNAL_SYSCALL_CALL (exit
, 0);
599 /* Return true iff obliged to report TD_CREATE events. */
601 report_thread_creation (struct pthread
*pd
)
603 if (__glibc_unlikely (THREAD_GETMEM (THREAD_SELF
, report_events
)))
605 /* The parent thread is supposed to report events.
606 Check whether the TD_CREATE event is needed, too. */
607 const size_t idx
= __td_eventword (TD_CREATE
);
608 const uint32_t mask
= __td_eventmask (TD_CREATE
);
610 return ((mask
& (__nptl_threads_events
.event_bits
[idx
]
611 | pd
->eventbuf
.eventmask
.event_bits
[idx
])) != 0);
618 __pthread_create_2_1 (pthread_t
*newthread
, const pthread_attr_t
*attr
,
619 void *(*start_routine
) (void *), void *arg
)
621 void *stackaddr
= NULL
;
622 size_t stacksize
= 0;
624 /* Avoid a data race in the multi-threaded case, and call the
625 deferred initialization only once. */
626 if (__libc_single_threaded
)
629 __libc_single_threaded
= 0;
632 const struct pthread_attr
*iattr
= (struct pthread_attr
*) attr
;
633 union pthread_attr_transparent default_attr
;
634 bool destroy_default_attr
= false;
635 bool c11
= (attr
== ATTR_C11_THREAD
);
636 if (iattr
== NULL
|| c11
)
638 int ret
= __pthread_getattr_default_np (&default_attr
.external
);
641 destroy_default_attr
= true;
642 iattr
= &default_attr
.internal
;
645 struct pthread
*pd
= NULL
;
646 int err
= allocate_stack (iattr
, &pd
, &stackaddr
, &stacksize
);
649 if (__glibc_unlikely (err
!= 0))
650 /* Something went wrong. Maybe a parameter of the attributes is
651 invalid or we could not allocate memory. Note we have to
652 translate error codes. */
654 retval
= err
== ENOMEM
? EAGAIN
: err
;
659 /* Initialize the TCB. All initializations with zero should be
660 performed in 'get_cached_stack'. This way we avoid doing this if
661 the stack freshly allocated with 'mmap'. */
664 /* Reference to the TCB itself. */
665 pd
->header
.self
= pd
;
667 /* Self-reference for TLS. */
671 /* Store the address of the start routine and the parameter. Since
672 we do not start the function directly the stillborn thread will
673 get the information from its thread descriptor. */
674 pd
->start_routine
= start_routine
;
678 /* Copy the thread attribute flags. */
679 struct pthread
*self
= THREAD_SELF
;
680 pd
->flags
= ((iattr
->flags
& ~(ATTR_FLAG_SCHED_SET
| ATTR_FLAG_POLICY_SET
))
681 | (self
->flags
& (ATTR_FLAG_SCHED_SET
| ATTR_FLAG_POLICY_SET
)));
683 /* Inherit rseq registration state. Without seccomp filters, rseq
684 registration will either always fail or always succeed. */
685 if ((int) THREAD_GETMEM_VOLATILE (self
, rseq_area
.cpu_id
) >= 0)
686 pd
->flags
|= ATTR_FLAG_DO_RSEQ
;
688 /* Initialize the field for the ID of the thread which is waiting
689 for us. This is a self-reference in case the thread is created
691 pd
->joinid
= iattr
->flags
& ATTR_FLAG_DETACHSTATE
? pd
: NULL
;
693 /* The debug events are inherited from the parent. */
694 pd
->eventbuf
= self
->eventbuf
;
697 /* Copy the parent's scheduling parameters. The flags will say what
698 is valid and what is not. */
699 pd
->schedpolicy
= self
->schedpolicy
;
700 pd
->schedparam
= self
->schedparam
;
702 /* Copy the stack guard canary. */
703 #ifdef THREAD_COPY_STACK_GUARD
704 THREAD_COPY_STACK_GUARD (pd
);
707 /* Copy the pointer guard value. */
708 #ifdef THREAD_COPY_POINTER_GUARD
709 THREAD_COPY_POINTER_GUARD (pd
);
713 tls_setup_tcbhead (pd
);
715 /* Verify the sysinfo bits were copied in allocate_stack if needed. */
716 #ifdef NEED_DL_SYSINFO
717 CHECK_THREAD_SYSINFO (pd
);
720 /* Determine scheduling parameters for the thread. */
721 if (__builtin_expect ((iattr
->flags
& ATTR_FLAG_NOTINHERITSCHED
) != 0, 0)
722 && (iattr
->flags
& (ATTR_FLAG_SCHED_SET
| ATTR_FLAG_POLICY_SET
)) != 0)
724 /* Use the scheduling parameters the user provided. */
725 if (iattr
->flags
& ATTR_FLAG_POLICY_SET
)
727 pd
->schedpolicy
= iattr
->schedpolicy
;
728 pd
->flags
|= ATTR_FLAG_POLICY_SET
;
730 if (iattr
->flags
& ATTR_FLAG_SCHED_SET
)
732 /* The values were validated in pthread_attr_setschedparam. */
733 pd
->schedparam
= iattr
->schedparam
;
734 pd
->flags
|= ATTR_FLAG_SCHED_SET
;
737 if ((pd
->flags
& (ATTR_FLAG_SCHED_SET
| ATTR_FLAG_POLICY_SET
))
738 != (ATTR_FLAG_SCHED_SET
| ATTR_FLAG_POLICY_SET
))
739 collect_default_sched (pd
);
742 if (__glibc_unlikely (__nptl_nthreads
== 1))
745 /* Pass the descriptor to the caller. */
746 *newthread
= (pthread_t
) pd
;
748 LIBC_PROBE (pthread_create
, 4, newthread
, attr
, start_routine
, arg
);
750 /* One more thread. We cannot have the thread do this itself, since it
751 might exist but not have been scheduled yet by the time we've returned
752 and need to check the value to behave correctly. We must do it before
753 creating the thread, in case it does get scheduled first and then
754 might mistakenly think it was the only thread. In the failure case,
755 we momentarily store a false value; this doesn't matter because there
756 is no kosher thing a signal handler interrupting us right here can do
757 that cares whether the thread count is correct. */
758 atomic_increment (&__nptl_nthreads
);
760 /* Our local value of stopped_start and thread_ran can be accessed at
761 any time. The PD->stopped_start may only be accessed if we have
762 ownership of PD (see CONCURRENCY NOTES above). */
763 bool stopped_start
= false; bool thread_ran
= false;
765 /* Block all signals, so that the new thread starts out with
766 signals disabled. This avoids race conditions in the thread
768 sigset_t original_sigmask
;
769 __libc_signal_block_all (&original_sigmask
);
771 if (iattr
->extension
!= NULL
&& iattr
->extension
->sigmask_set
)
772 /* Use the signal mask in the attribute. The internal signals
773 have already been filtered by the public
774 pthread_attr_setsigmask_np interface. */
775 pd
->sigmask
= iattr
->extension
->sigmask
;
778 /* Conceptually, the new thread needs to inherit the signal mask
779 of this thread. Therefore, it needs to restore the saved
780 signal mask of this thread, so save it in the startup
782 pd
->sigmask
= original_sigmask
;
783 /* Reset the cancellation signal mask in case this thread is
784 running cancellation. */
785 __sigdelset (&pd
->sigmask
, SIGCANCEL
);
788 /* Start the thread. */
789 if (__glibc_unlikely (report_thread_creation (pd
)))
791 stopped_start
= true;
793 /* We always create the thread stopped at startup so we can
794 notify the debugger. */
795 retval
= create_thread (pd
, iattr
, &stopped_start
, stackaddr
,
796 stacksize
, &thread_ran
);
799 /* We retain ownership of PD until (a) (see CONCURRENCY NOTES
802 /* Assert stopped_start is true in both our local copy and the
804 assert (stopped_start
);
805 assert (pd
->stopped_start
);
807 /* Now fill in the information about the new thread in
808 the newly created thread's data structure. We cannot let
809 the new thread do this since we don't know whether it was
810 already scheduled when we send the event. */
811 pd
->eventbuf
.eventnum
= TD_CREATE
;
812 pd
->eventbuf
.eventdata
= pd
;
814 /* Enqueue the descriptor. */
816 pd
->nextevent
= __nptl_last_event
;
817 while (atomic_compare_and_exchange_bool_acq (&__nptl_last_event
,
821 /* Now call the function which signals the event. See
822 CONCURRENCY NOTES for the nptl_db interface comments. */
823 __nptl_create_event ();
827 retval
= create_thread (pd
, iattr
, &stopped_start
, stackaddr
,
828 stacksize
, &thread_ran
);
830 /* Return to the previous signal mask, after creating the new
832 __libc_signal_restore_set (&original_sigmask
);
834 if (__glibc_unlikely (retval
!= 0))
837 /* State (c) and we not have PD ownership (see CONCURRENCY NOTES
838 above). We can assert that STOPPED_START must have been true
839 because thread creation didn't fail, but thread attribute setting
842 assert (stopped_start
);
843 /* Signal the created thread to release PD ownership and early
844 exit so it could be joined. */
845 pd
->setup_failed
= 1;
846 lll_unlock (pd
->lock
, LLL_PRIVATE
);
848 /* Similar to pthread_join, but since thread creation has failed at
849 startup there is no need to handle all the steps. */
851 while ((tid
= atomic_load_acquire (&pd
->tid
)) != 0)
852 __futex_abstimed_wait_cancelable64 ((unsigned int *) &pd
->tid
,
853 tid
, 0, NULL
, LLL_SHARED
);
856 /* State (c) or (d) and we have ownership of PD (see CONCURRENCY
859 /* Oops, we lied for a second. */
860 atomic_decrement (&__nptl_nthreads
);
862 /* Free the resources. */
863 __nptl_deallocate_stack (pd
);
865 /* We have to translate error codes. */
866 if (retval
== ENOMEM
)
871 /* We don't know if we have PD ownership. Once we check the local
872 stopped_start we'll know if we're in state (a) or (b) (see
873 CONCURRENCY NOTES above). */
875 /* State (a), we own PD. The thread blocked on this lock either
876 because we're doing TD_CREATE event reporting, or for some
877 other reason that create_thread chose. Now let it run
879 lll_unlock (pd
->lock
, LLL_PRIVATE
);
881 /* We now have for sure more than one thread. The main thread might
882 not yet have the flag set. No need to set the global variable
883 again if this is what we use. */
884 THREAD_SETMEM (THREAD_SELF
, header
.multiple_threads
, 1);
888 if (destroy_default_attr
)
889 __pthread_attr_destroy (&default_attr
.external
);
893 versioned_symbol (libc
, __pthread_create_2_1
, pthread_create
, GLIBC_2_34
);
894 libc_hidden_ver (__pthread_create_2_1
, __pthread_create
)
896 strong_alias (__pthread_create_2_1
, __pthread_create
)
899 #if OTHER_SHLIB_COMPAT (libpthread, GLIBC_2_1, GLIBC_2_34)
900 compat_symbol (libpthread
, __pthread_create_2_1
, pthread_create
, GLIBC_2_1
);
903 #if OTHER_SHLIB_COMPAT (libpthread, GLIBC_2_0, GLIBC_2_1)
905 __pthread_create_2_0 (pthread_t
*newthread
, const pthread_attr_t
*attr
,
906 void *(*start_routine
) (void *), void *arg
)
908 /* The ATTR attribute is not really of type `pthread_attr_t *'. It has
909 the old size and access to the new members might crash the program.
910 We convert the struct now. */
911 struct pthread_attr new_attr
;
915 struct pthread_attr
*iattr
= (struct pthread_attr
*) attr
;
916 size_t ps
= __getpagesize ();
918 /* Copy values from the user-provided attributes. */
919 new_attr
.schedparam
= iattr
->schedparam
;
920 new_attr
.schedpolicy
= iattr
->schedpolicy
;
921 new_attr
.flags
= iattr
->flags
;
923 /* Fill in default values for the fields not present in the old
925 new_attr
.guardsize
= ps
;
926 new_attr
.stackaddr
= NULL
;
927 new_attr
.stacksize
= 0;
928 new_attr
.extension
= NULL
;
930 /* We will pass this value on to the real implementation. */
931 attr
= (pthread_attr_t
*) &new_attr
;
934 return __pthread_create_2_1 (newthread
, attr
, start_routine
, arg
);
936 compat_symbol (libpthread
, __pthread_create_2_0
, pthread_create
,
940 /* Information for libthread_db. */
942 #include "../nptl_db/db_info.c"
944 /* If pthread_create is present, libgcc_eh.a and libsupc++.a expects some other POSIX thread
945 functions to be present as well. */
946 PTHREAD_STATIC_FN_REQUIRE (__pthread_mutex_lock
)
947 PTHREAD_STATIC_FN_REQUIRE (__pthread_mutex_trylock
)
948 PTHREAD_STATIC_FN_REQUIRE (__pthread_mutex_unlock
)
950 PTHREAD_STATIC_FN_REQUIRE (__pthread_once
)
951 PTHREAD_STATIC_FN_REQUIRE (__pthread_cancel
)
953 PTHREAD_STATIC_FN_REQUIRE (__pthread_key_create
)
954 PTHREAD_STATIC_FN_REQUIRE (__pthread_key_delete
)
955 PTHREAD_STATIC_FN_REQUIRE (__pthread_setspecific
)
956 PTHREAD_STATIC_FN_REQUIRE (__pthread_getspecific
)