1/* Low-level thread creation for NPTL. Linux version.
2 Copyright (C) 2002-2019 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
5
6 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public
8 License as published by the Free Software Foundation; either
9 version 2.1 of the License, or (at your option) any later version.
10
11 The GNU C Library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
15
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; if not, see
18 <http://www.gnu.org/licenses/>. */
19
20#include <sched.h>
21#include <setjmp.h>
22#include <signal.h>
23#include <stdlib.h>
24#include <atomic.h>
25#include <ldsodefs.h>
26#include <tls.h>
27#include <stdint.h>
28
29#include <arch-fork.h>
30
31#ifdef __NR_clone2
32# define ARCH_CLONE __clone2
33#else
34# define ARCH_CLONE __clone
35#endif
36
37/* See the comments in pthread_create.c for the requirements for these
38 two macros and the create_thread function. */
39
40#define START_THREAD_DEFN \
41 static int __attribute__ ((noreturn)) start_thread (void *arg)
42#define START_THREAD_SELF arg
43
44/* pthread_create.c defines this using START_THREAD_DEFN
45 We need a forward declaration here so we can take its address. */
46static int start_thread (void *arg) __attribute__ ((noreturn));
47
48static int
49create_thread (struct pthread *pd, const struct pthread_attr *attr,
50 bool *stopped_start, STACK_VARIABLES_PARMS, bool *thread_ran)
51{
52 /* Determine whether the newly created threads has to be started
53 stopped since we have to set the scheduling parameters or set the
54 affinity. */
55 if (attr != NULL
56 && (__glibc_unlikely (attr->cpuset != NULL)
57 || __glibc_unlikely ((attr->flags & ATTR_FLAG_NOTINHERITSCHED) != 0)))
58 *stopped_start = true;
59
60 pd->stopped_start = *stopped_start;
61 if (__glibc_unlikely (*stopped_start))
62 /* See CONCURRENCY NOTES in nptl/pthread_creat.c. */
63 lll_lock (pd->lock, LLL_PRIVATE);
64
65 /* We rely heavily on various flags the CLONE function understands:
66
67 CLONE_VM, CLONE_FS, CLONE_FILES
68 These flags select semantics with shared address space and
69 file descriptors according to what POSIX requires.
70
71 CLONE_SIGHAND, CLONE_THREAD
72 This flag selects the POSIX signal semantics and various
73 other kinds of sharing (itimers, POSIX timers, etc.).
74
75 CLONE_SETTLS
76 The sixth parameter to CLONE determines the TLS area for the
77 new thread.
78
79 CLONE_PARENT_SETTID
80 The kernels writes the thread ID of the newly created thread
81 into the location pointed to by the fifth parameters to CLONE.
82
83 Note that it would be semantically equivalent to use
84 CLONE_CHILD_SETTID but it is be more expensive in the kernel.
85
86 CLONE_CHILD_CLEARTID
87 The kernels clears the thread ID of a thread that has called
88 sys_exit() in the location pointed to by the seventh parameter
89 to CLONE.
90
91 The termination signal is chosen to be zero which means no signal
92 is sent. */
93 const int clone_flags = (CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SYSVSEM
94 | CLONE_SIGHAND | CLONE_THREAD
95 | CLONE_SETTLS | CLONE_PARENT_SETTID
96 | CLONE_CHILD_CLEARTID
97 | 0);
98
99 TLS_DEFINE_INIT_TP (tp, pd);
100
101 if (__glibc_unlikely (ARCH_CLONE (&start_thread, STACK_VARIABLES_ARGS,
102 clone_flags, pd, &pd->tid, tp, &pd->tid)
103 == -1))
104 return errno;
105
106 /* It's started now, so if we fail below, we'll have to cancel it
107 and let it clean itself up. */
108 *thread_ran = true;
109
110 /* Now we have the possibility to set scheduling parameters etc. */
111 if (attr != NULL)
112 {
113 INTERNAL_SYSCALL_DECL (err);
114 int res;
115
116 /* Set the affinity mask if necessary. */
117 if (attr->cpuset != NULL)
118 {
119 assert (*stopped_start);
120
121 res = INTERNAL_SYSCALL (sched_setaffinity, err, 3, pd->tid,
122 attr->cpusetsize, attr->cpuset);
123
124 if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (res, err)))
125 err_out:
126 {
127 /* The operation failed. We have to kill the thread.
128 We let the normal cancellation mechanism do the work. */
129
130 pid_t pid = __getpid ();
131 INTERNAL_SYSCALL_DECL (err2);
132 (void) INTERNAL_SYSCALL_CALL (tgkill, err2, pid, pd->tid,
133 SIGCANCEL);
134
135 return INTERNAL_SYSCALL_ERRNO (res, err);
136 }
137 }
138
139 /* Set the scheduling parameters. */
140 if ((attr->flags & ATTR_FLAG_NOTINHERITSCHED) != 0)
141 {
142 assert (*stopped_start);
143
144 res = INTERNAL_SYSCALL (sched_setscheduler, err, 3, pd->tid,
145 pd->schedpolicy, &pd->schedparam);
146
147 if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (res, err)))
148 goto err_out;
149 }
150 }
151
152 return 0;
153}
154