]>
Commit | Line | Data |
---|---|---|
6f8326ca | 1 | /* Copyright (C) 2002-2007, 2008, 2009, 2011 Free Software Foundation, Inc. |
76a50749 UD |
2 | This file is part of the GNU C Library. |
3 | Contributed by Ulrich Drepper <drepper@redhat.com>, 2002. | |
4 | ||
5 | The GNU C Library is free software; you can redistribute it and/or | |
6 | modify it under the terms of the GNU Lesser General Public | |
7 | License as published by the Free Software Foundation; either | |
8 | version 2.1 of the License, or (at your option) any later version. | |
9 | ||
10 | The GNU C Library is distributed in the hope that it will be useful, | |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
13 | Lesser General Public License for more details. | |
14 | ||
15 | You should have received a copy of the GNU Lesser General Public | |
59ba27a6 PE |
16 | License along with the GNU C Library; if not, see |
17 | <http://www.gnu.org/licenses/>. */ | |
76a50749 UD |
18 | |
19 | #include <assert.h> | |
cbd8aeb8 | 20 | #include <errno.h> |
76a50749 UD |
21 | #include <limits.h> |
22 | #include <signal.h> | |
23 | #include <stdlib.h> | |
24 | #include <unistd.h> | |
25 | #include <sys/param.h> | |
26 | #include <sys/resource.h> | |
27 | #include <pthreadP.h> | |
28 | #include <atomic.h> | |
29 | #include <ldsodefs.h> | |
30 | #include <tls.h> | |
7a775e6b | 31 | #include <list.h> |
76a50749 UD |
32 | #include <fork.h> |
33 | #include <version.h> | |
bf293afe | 34 | #include <shlib-compat.h> |
2c0b891a | 35 | #include <smp.h> |
2edb61e3 | 36 | #include <lowlevellock.h> |
f8de5057 | 37 | #include <kernel-features.h> |
76a50749 UD |
38 | |
39 | ||
76a50749 UD |
40 | /* Size and alignment of static TLS block. */ |
41 | size_t __static_tls_size; | |
923e02ea | 42 | size_t __static_tls_align_m1; |
76a50749 | 43 | |
0f6699ea UD |
44 | #ifndef __ASSUME_SET_ROBUST_LIST |
45 | /* Negative if we do not have the system call and we can use it. */ | |
46 | int __set_robust_list_avail; | |
47 | # define set_robust_list_not_avail() \ | |
48 | __set_robust_list_avail = -1 | |
49 | #else | |
50 | # define set_robust_list_not_avail() do { } while (0) | |
51 | #endif | |
52 | ||
cbd8aeb8 UD |
53 | #ifndef __ASSUME_FUTEX_CLOCK_REALTIME |
54 | /* Nonzero if we do not have FUTEX_CLOCK_REALTIME. */ | |
55 | int __have_futex_clock_realtime; | |
56 | # define __set_futex_clock_realtime() \ | |
57 | __have_futex_clock_realtime = 1 | |
58 | #else | |
59 | #define __set_futex_clock_realtime() do { } while (0) | |
60 | #endif | |
61 | ||
76a50749 | 62 | /* Version of the library, used in libthread_db to detect mismatches. */ |
e3b22ad3 | 63 | static const char nptl_version[] __attribute_used__ = VERSION; |
76a50749 UD |
64 | |
65 | ||
11bf311e | 66 | #ifndef SHARED |
76a50749 UD |
67 | extern void __libc_setup_tls (size_t tcbsize, size_t tcbalign); |
68 | #endif | |
69 | ||
6f8326ca UD |
70 | #ifdef SHARED |
71 | static | |
72 | #else | |
73 | extern | |
74 | #endif | |
75 | void __nptl_set_robust (struct pthread *); | |
76 | ||
30991b8b | 77 | #ifdef SHARED |
cca50323 UD |
78 | static void nptl_freeres (void); |
79 | ||
76a50749 | 80 | |
630d93a7 | 81 | static const struct pthread_functions pthread_functions = |
8454830b UD |
82 | { |
83 | .ptr_pthread_attr_destroy = __pthread_attr_destroy, | |
73e9ae88 | 84 | # if SHLIB_COMPAT(libpthread, GLIBC_2_0, GLIBC_2_1) |
49e9f864 | 85 | .ptr___pthread_attr_init_2_0 = __pthread_attr_init_2_0, |
73e9ae88 | 86 | # endif |
49e9f864 | 87 | .ptr___pthread_attr_init_2_1 = __pthread_attr_init_2_1, |
8454830b UD |
88 | .ptr_pthread_attr_getdetachstate = __pthread_attr_getdetachstate, |
89 | .ptr_pthread_attr_setdetachstate = __pthread_attr_setdetachstate, | |
90 | .ptr_pthread_attr_getinheritsched = __pthread_attr_getinheritsched, | |
91 | .ptr_pthread_attr_setinheritsched = __pthread_attr_setinheritsched, | |
92 | .ptr_pthread_attr_getschedparam = __pthread_attr_getschedparam, | |
93 | .ptr_pthread_attr_setschedparam = __pthread_attr_setschedparam, | |
94 | .ptr_pthread_attr_getschedpolicy = __pthread_attr_getschedpolicy, | |
95 | .ptr_pthread_attr_setschedpolicy = __pthread_attr_setschedpolicy, | |
96 | .ptr_pthread_attr_getscope = __pthread_attr_getscope, | |
97 | .ptr_pthread_attr_setscope = __pthread_attr_setscope, | |
98 | .ptr_pthread_condattr_destroy = __pthread_condattr_destroy, | |
99 | .ptr_pthread_condattr_init = __pthread_condattr_init, | |
bf293afe UD |
100 | .ptr___pthread_cond_broadcast = __pthread_cond_broadcast, |
101 | .ptr___pthread_cond_destroy = __pthread_cond_destroy, | |
102 | .ptr___pthread_cond_init = __pthread_cond_init, | |
103 | .ptr___pthread_cond_signal = __pthread_cond_signal, | |
104 | .ptr___pthread_cond_wait = __pthread_cond_wait, | |
c503d3dc | 105 | .ptr___pthread_cond_timedwait = __pthread_cond_timedwait, |
73e9ae88 | 106 | # if SHLIB_COMPAT(libpthread, GLIBC_2_0, GLIBC_2_3_2) |
bf293afe UD |
107 | .ptr___pthread_cond_broadcast_2_0 = __pthread_cond_broadcast_2_0, |
108 | .ptr___pthread_cond_destroy_2_0 = __pthread_cond_destroy_2_0, | |
109 | .ptr___pthread_cond_init_2_0 = __pthread_cond_init_2_0, | |
110 | .ptr___pthread_cond_signal_2_0 = __pthread_cond_signal_2_0, | |
111 | .ptr___pthread_cond_wait_2_0 = __pthread_cond_wait_2_0, | |
c503d3dc | 112 | .ptr___pthread_cond_timedwait_2_0 = __pthread_cond_timedwait_2_0, |
73e9ae88 | 113 | # endif |
8454830b | 114 | .ptr_pthread_equal = __pthread_equal, |
49e9f864 | 115 | .ptr___pthread_exit = __pthread_exit, |
8454830b UD |
116 | .ptr_pthread_getschedparam = __pthread_getschedparam, |
117 | .ptr_pthread_setschedparam = __pthread_setschedparam, | |
118 | .ptr_pthread_mutex_destroy = INTUSE(__pthread_mutex_destroy), | |
119 | .ptr_pthread_mutex_init = INTUSE(__pthread_mutex_init), | |
120 | .ptr_pthread_mutex_lock = INTUSE(__pthread_mutex_lock), | |
121 | .ptr_pthread_mutex_unlock = INTUSE(__pthread_mutex_unlock), | |
122 | .ptr_pthread_self = __pthread_self, | |
123 | .ptr_pthread_setcancelstate = __pthread_setcancelstate, | |
73e9ae88 UD |
124 | .ptr_pthread_setcanceltype = __pthread_setcanceltype, |
125 | .ptr___pthread_cleanup_upto = __pthread_cleanup_upto, | |
126 | .ptr___pthread_once = __pthread_once_internal, | |
127 | .ptr___pthread_rwlock_rdlock = __pthread_rwlock_rdlock_internal, | |
128 | .ptr___pthread_rwlock_wrlock = __pthread_rwlock_wrlock_internal, | |
129 | .ptr___pthread_rwlock_unlock = __pthread_rwlock_unlock_internal, | |
130 | .ptr___pthread_key_create = __pthread_key_create_internal, | |
131 | .ptr___pthread_getspecific = __pthread_getspecific_internal, | |
132 | .ptr___pthread_setspecific = __pthread_setspecific_internal, | |
133 | .ptr__pthread_cleanup_push_defer = __pthread_cleanup_push_defer, | |
47202270 | 134 | .ptr__pthread_cleanup_pop_restore = __pthread_cleanup_pop_restore, |
6efd4814 | 135 | .ptr_nthreads = &__nptl_nthreads, |
3fa21fd8 | 136 | .ptr___pthread_unwind = &__pthread_unwind, |
2edb61e3 | 137 | .ptr__nptl_deallocate_tsd = __nptl_deallocate_tsd, |
ba408f84 UD |
138 | .ptr__nptl_setxid = __nptl_setxid, |
139 | /* For now only the stack cache needs to be freed. */ | |
6f8326ca UD |
140 | .ptr_freeres = nptl_freeres, |
141 | .ptr_set_robust = __nptl_set_robust | |
8454830b UD |
142 | }; |
143 | # define ptr_pthread_functions &pthread_functions | |
144 | #else | |
145 | # define ptr_pthread_functions NULL | |
146 | #endif | |
147 | ||
148 | ||
30991b8b | 149 | #ifdef SHARED |
cca50323 UD |
150 | /* This function is called indirectly from the freeres code in libc. */ |
151 | static void | |
152 | __libc_freeres_fn_section | |
153 | nptl_freeres (void) | |
154 | { | |
cca50323 | 155 | __unwind_freeres (); |
cca50323 UD |
156 | __free_stacks (0); |
157 | } | |
6f8326ca UD |
158 | |
159 | ||
160 | static | |
30991b8b | 161 | #endif |
6f8326ca UD |
162 | void |
163 | __nptl_set_robust (struct pthread *self) | |
164 | { | |
165 | INTERNAL_SYSCALL_DECL (err); | |
166 | INTERNAL_SYSCALL (set_robust_list, err, 2, &self->robust_head, | |
167 | sizeof (struct robust_list_head)); | |
168 | } | |
cca50323 UD |
169 | |
170 | ||
76a50749 UD |
171 | /* For asynchronous cancellation we use a signal. This is the handler. */ |
172 | static void | |
a1ed6b4c | 173 | sigcancel_handler (int sig, siginfo_t *si, void *ctx) |
76a50749 | 174 | { |
7960f2a7 UD |
175 | #ifdef __ASSUME_CORRECT_SI_PID |
176 | /* Determine the process ID. It might be negative if the thread is | |
177 | in the middle of a fork() call. */ | |
178 | pid_t pid = THREAD_GETMEM (THREAD_SELF, pid); | |
179 | if (__builtin_expect (pid < 0, 0)) | |
180 | pid = -pid; | |
181 | #endif | |
182 | ||
a1ed6b4c | 183 | /* Safety check. It would be possible to call this function for |
2edb61e3 | 184 | other signals and send a signal from another process. This is not |
a1ed6b4c UD |
185 | correct and might even be a security problem. Try to catch as |
186 | many incorrect invocations as possible. */ | |
187 | if (sig != SIGCANCEL | |
db54f488 UD |
188 | #ifdef __ASSUME_CORRECT_SI_PID |
189 | /* Kernels before 2.5.75 stored the thread ID and not the process | |
190 | ID in si_pid so we skip this test. */ | |
7960f2a7 | 191 | || si->si_pid != pid |
db54f488 | 192 | #endif |
a1ed6b4c | 193 | || si->si_code != SI_TKILL) |
a1ed6b4c UD |
194 | return; |
195 | ||
76a50749 UD |
196 | struct pthread *self = THREAD_SELF; |
197 | ||
b22d701b | 198 | int oldval = THREAD_GETMEM (self, cancelhandling); |
76a50749 UD |
199 | while (1) |
200 | { | |
201 | /* We are canceled now. When canceled by another thread this flag | |
202 | is already set but if the signal is directly send (internally or | |
203 | from another process) is has to be done here. */ | |
e320ef46 | 204 | int newval = oldval | CANCELING_BITMASK | CANCELED_BITMASK; |
76a50749 UD |
205 | |
206 | if (oldval == newval || (oldval & EXITING_BITMASK) != 0) | |
207 | /* Already canceled or exiting. */ | |
208 | break; | |
209 | ||
b22d701b UD |
210 | int curval = THREAD_ATOMIC_CMPXCHG_VAL (self, cancelhandling, newval, |
211 | oldval); | |
212 | if (curval == oldval) | |
76a50749 UD |
213 | { |
214 | /* Set the return value. */ | |
215 | THREAD_SETMEM (self, result, PTHREAD_CANCELED); | |
216 | ||
217 | /* Make sure asynchronous cancellation is still enabled. */ | |
218 | if ((newval & CANCELTYPE_BITMASK) != 0) | |
d9eb687b UD |
219 | /* Run the registered destructors and terminate the thread. */ |
220 | __do_cancel (); | |
76a50749 UD |
221 | |
222 | break; | |
223 | } | |
b22d701b UD |
224 | |
225 | oldval = curval; | |
76a50749 UD |
226 | } |
227 | } | |
228 | ||
229 | ||
2edb61e3 UD |
230 | struct xid_command *__xidcmd attribute_hidden; |
231 | ||
232 | /* For asynchronous cancellation we use a signal. This is the handler. */ | |
233 | static void | |
234 | sighandler_setxid (int sig, siginfo_t *si, void *ctx) | |
235 | { | |
7960f2a7 UD |
236 | #ifdef __ASSUME_CORRECT_SI_PID |
237 | /* Determine the process ID. It might be negative if the thread is | |
238 | in the middle of a fork() call. */ | |
239 | pid_t pid = THREAD_GETMEM (THREAD_SELF, pid); | |
240 | if (__builtin_expect (pid < 0, 0)) | |
241 | pid = -pid; | |
242 | #endif | |
243 | ||
2edb61e3 UD |
244 | /* Safety check. It would be possible to call this function for |
245 | other signals and send a signal from another process. This is not | |
246 | correct and might even be a security problem. Try to catch as | |
247 | many incorrect invocations as possible. */ | |
248 | if (sig != SIGSETXID | |
249 | #ifdef __ASSUME_CORRECT_SI_PID | |
250 | /* Kernels before 2.5.75 stored the thread ID and not the process | |
251 | ID in si_pid so we skip this test. */ | |
7960f2a7 | 252 | || si->si_pid != pid |
2edb61e3 UD |
253 | #endif |
254 | || si->si_code != SI_TKILL) | |
255 | return; | |
256 | ||
257 | INTERNAL_SYSCALL_DECL (err); | |
258 | INTERNAL_SYSCALL_NCS (__xidcmd->syscall_no, err, 3, __xidcmd->id[0], | |
259 | __xidcmd->id[1], __xidcmd->id[2]); | |
260 | ||
dff9a7a1 UD |
261 | /* Reset the SETXID flag. */ |
262 | struct pthread *self = THREAD_SELF; | |
25db0f6c DJ |
263 | int flags, newval; |
264 | do | |
265 | { | |
266 | flags = THREAD_GETMEM (self, cancelhandling); | |
267 | newval = THREAD_ATOMIC_CMPXCHG_VAL (self, cancelhandling, | |
268 | flags & ~SETXID_BITMASK, flags); | |
269 | } | |
270 | while (flags != newval); | |
dff9a7a1 UD |
271 | |
272 | /* And release the futex. */ | |
273 | self->setxid_futex = 1; | |
085a4412 | 274 | lll_futex_wake (&self->setxid_futex, 1, LLL_PRIVATE); |
25db0f6c DJ |
275 | |
276 | if (atomic_decrement_val (&__xidcmd->cntr) == 0) | |
277 | lll_futex_wake (&__xidcmd->cntr, 1, LLL_PRIVATE); | |
2edb61e3 UD |
278 | } |
279 | ||
280 | ||
b1531183 UD |
281 | /* When using __thread for this, we do it in libc so as not |
282 | to give libpthread its own TLS segment just for this. */ | |
283 | extern void **__libc_dl_error_tsd (void) __attribute__ ((const)); | |
284 | ||
76a50749 | 285 | |
0ecf9c10 | 286 | /* This can be set by the debugger before initialization is complete. */ |
e965d514 | 287 | static bool __nptl_initial_report_events __attribute_used__; |
0ecf9c10 | 288 | |
76a50749 | 289 | void |
2ae920ed | 290 | __pthread_initialize_minimal_internal (void) |
76a50749 | 291 | { |
76a50749 UD |
292 | #ifndef SHARED |
293 | /* Unlike in the dynamically linked case the dynamic linker has not | |
294 | taken care of initializing the TLS data structures. */ | |
295 | __libc_setup_tls (TLS_TCB_SIZE, TLS_TCB_ALIGN); | |
85631c8e UD |
296 | |
297 | /* We must prevent gcc from being clever and move any of the | |
298 | following code ahead of the __libc_setup_tls call. This function | |
299 | will initialize the thread register which is subsequently | |
300 | used. */ | |
301 | __asm __volatile (""); | |
76a50749 UD |
302 | #endif |
303 | ||
304 | /* Minimal initialization of the thread descriptor. */ | |
75cddafe | 305 | struct pthread *pd = THREAD_SELF; |
6aca81bb | 306 | INTERNAL_SYSCALL_DECL (err); |
db54f488 | 307 | pd->pid = pd->tid = INTERNAL_SYSCALL (set_tid_address, err, 1, &pd->tid); |
76a50749 UD |
308 | THREAD_SETMEM (pd, specific[0], &pd->specific_1stblock[0]); |
309 | THREAD_SETMEM (pd, user_stack, true); | |
310 | if (LLL_LOCK_INITIALIZER != 0) | |
311 | THREAD_SETMEM (pd, lock, LLL_LOCK_INITIALIZER); | |
312 | #if HP_TIMING_AVAIL | |
313 | THREAD_SETMEM (pd, cpuclock_offset, GL(dl_cpuclock_offset)); | |
314 | #endif | |
315 | ||
0f6699ea UD |
316 | /* Initialize the robust mutex data. */ |
317 | #ifdef __PTHREAD_MUTEX_HAVE_PREV | |
318 | pd->robust_prev = &pd->robust_head; | |
319 | #endif | |
320 | pd->robust_head.list = &pd->robust_head; | |
321 | #ifdef __NR_set_robust_list | |
322 | pd->robust_head.futex_offset = (offsetof (pthread_mutex_t, __data.__lock) | |
323 | - offsetof (pthread_mutex_t, | |
324 | __data.__list.__next)); | |
325 | int res = INTERNAL_SYSCALL (set_robust_list, err, 2, &pd->robust_head, | |
326 | sizeof (struct robust_list_head)); | |
327 | if (INTERNAL_SYSCALL_ERROR_P (res, err)) | |
328 | #endif | |
329 | set_robust_list_not_avail (); | |
330 | ||
e59660bc | 331 | #ifndef __ASSUME_PRIVATE_FUTEX |
5a8075b1 UD |
332 | /* Private futexes are always used (at least internally) so that |
333 | doing the test once this early is beneficial. */ | |
334 | { | |
e807818b | 335 | int word = 0; |
e59660bc | 336 | word = INTERNAL_SYSCALL (futex, err, 3, &word, |
5a8075b1 | 337 | FUTEX_WAKE | FUTEX_PRIVATE_FLAG, 1); |
e59660bc UD |
338 | if (!INTERNAL_SYSCALL_ERROR_P (word, err)) |
339 | THREAD_SETMEM (pd, header.private_futex, FUTEX_PRIVATE_FLAG); | |
5a8075b1 | 340 | } |
5a8075b1 | 341 | |
3c612057 UD |
342 | /* Private futexes have been introduced earlier than the |
343 | FUTEX_CLOCK_REALTIME flag. We don't have to run the test if we | |
344 | know the former are not supported. This also means we know the | |
345 | kernel will return ENOSYS for unknown operations. */ | |
346 | if (THREAD_GETMEM (pd, header.private_futex) != 0) | |
347 | #endif | |
cbd8aeb8 | 348 | #ifndef __ASSUME_FUTEX_CLOCK_REALTIME |
3c612057 UD |
349 | { |
350 | int word = 0; | |
351 | /* NB: the syscall actually takes six parameters. The last is the | |
352 | bit mask. But since we will not actually wait at all the value | |
353 | is irrelevant. Given that passing six parameters is difficult | |
354 | on some architectures we just pass whatever random value the | |
355 | calling convention calls for to the kernel. It causes no harm. */ | |
356 | word = INTERNAL_SYSCALL (futex, err, 5, &word, | |
357 | FUTEX_WAIT_BITSET | FUTEX_CLOCK_REALTIME | |
358 | | FUTEX_PRIVATE_FLAG, 1, NULL, 0); | |
359 | assert (INTERNAL_SYSCALL_ERROR_P (word, err)); | |
360 | if (INTERNAL_SYSCALL_ERRNO (word, err) != ENOSYS) | |
361 | __set_futex_clock_realtime (); | |
362 | } | |
cbd8aeb8 UD |
363 | #endif |
364 | ||
675620f7 UD |
365 | /* Set initial thread's stack block from 0 up to __libc_stack_end. |
366 | It will be bigger than it actually is, but for unwind.c/pt-longjmp.c | |
367 | purposes this is good enough. */ | |
368 | THREAD_SETMEM (pd, stackblock_size, (size_t) __libc_stack_end); | |
369 | ||
fde89ad0 | 370 | /* Initialize the list of all running threads with the main thread. */ |
a4548cea | 371 | INIT_LIST_HEAD (&__stack_user); |
d4f64e1a | 372 | list_add (&pd->list, &__stack_user); |
76a50749 | 373 | |
0ecf9c10 RM |
374 | /* Before initializing __stack_user, the debugger could not find us and |
375 | had to set __nptl_initial_report_events. Propagate its setting. */ | |
376 | THREAD_SETMEM (pd, report_events, __nptl_initial_report_events); | |
76a50749 UD |
377 | |
378 | /* Install the cancellation signal handler. If for some reason we | |
379 | cannot install the handler we do not abort. Maybe we should, but | |
380 | it is only asynchronous cancellation which is affected. */ | |
75cddafe | 381 | struct sigaction sa; |
a1ed6b4c UD |
382 | sa.sa_sigaction = sigcancel_handler; |
383 | sa.sa_flags = SA_SIGINFO; | |
a71c152c | 384 | __sigemptyset (&sa.sa_mask); |
76a50749 UD |
385 | |
386 | (void) __libc_sigaction (SIGCANCEL, &sa, NULL); | |
387 | ||
2edb61e3 UD |
388 | /* Install the handle to change the threads' uid/gid. */ |
389 | sa.sa_sigaction = sighandler_setxid; | |
390 | sa.sa_flags = SA_SIGINFO | SA_RESTART; | |
391 | ||
392 | (void) __libc_sigaction (SIGSETXID, &sa, NULL); | |
393 | ||
708bfb9a | 394 | /* The parent process might have left the signals blocked. Just in |
f006d3a0 UD |
395 | case, unblock it. We reuse the signal mask in the sigaction |
396 | structure. It is already cleared. */ | |
397 | __sigaddset (&sa.sa_mask, SIGCANCEL); | |
708bfb9a | 398 | __sigaddset (&sa.sa_mask, SIGSETXID); |
f006d3a0 UD |
399 | (void) INTERNAL_SYSCALL (rt_sigprocmask, err, 4, SIG_UNBLOCK, &sa.sa_mask, |
400 | NULL, _NSIG / 8); | |
401 | ||
b399707e RM |
402 | /* Get the size of the static and alignment requirements for the TLS |
403 | block. */ | |
404 | size_t static_tls_align; | |
405 | _dl_get_tls_static_info (&__static_tls_size, &static_tls_align); | |
406 | ||
407 | /* Make sure the size takes all the alignments into account. */ | |
408 | if (STACK_ALIGN > static_tls_align) | |
409 | static_tls_align = STACK_ALIGN; | |
410 | __static_tls_align_m1 = static_tls_align - 1; | |
411 | ||
412 | __static_tls_size = roundup (__static_tls_size, static_tls_align); | |
76a50749 UD |
413 | |
414 | /* Determine the default allowed stack size. This is the size used | |
415 | in case the user does not specify one. */ | |
75cddafe | 416 | struct rlimit limit; |
76a50749 UD |
417 | if (getrlimit (RLIMIT_STACK, &limit) != 0 |
418 | || limit.rlim_cur == RLIM_INFINITY) | |
419 | /* The system limit is not usable. Use an architecture-specific | |
420 | default. */ | |
fe60d146 | 421 | limit.rlim_cur = ARCH_STACK_DEFAULT_SIZE; |
d9cabb2f RM |
422 | else if (limit.rlim_cur < PTHREAD_STACK_MIN) |
423 | /* The system limit is unusably small. | |
424 | Use the minimal size acceptable. */ | |
fe60d146 RM |
425 | limit.rlim_cur = PTHREAD_STACK_MIN; |
426 | ||
427 | /* Make sure it meets the minimum size that allocate_stack | |
428 | (allocatestack.c) will demand, which depends on the page size. */ | |
2c1094bd | 429 | const uintptr_t pagesz = GLRO(dl_pagesize); |
b399707e | 430 | const size_t minstack = pagesz + __static_tls_size + MINIMAL_REST_STACK; |
fe60d146 RM |
431 | if (limit.rlim_cur < minstack) |
432 | limit.rlim_cur = minstack; | |
433 | ||
434 | /* Round the resource limit up to page size. */ | |
435 | limit.rlim_cur = (limit.rlim_cur + pagesz - 1) & -pagesz; | |
436 | __default_stacksize = limit.rlim_cur; | |
76a50749 | 437 | |
b1531183 UD |
438 | #ifdef SHARED |
439 | /* Transfer the old value from the dynamic linker's internal location. */ | |
440 | *__libc_dl_error_tsd () = *(*GL(dl_error_catch_tsd)) (); | |
441 | GL(dl_error_catch_tsd) = &__libc_dl_error_tsd; | |
334fcf2a UD |
442 | |
443 | /* Make __rtld_lock_{,un}lock_recursive use pthread_mutex_{,un}lock, | |
444 | keep the lock count from the ld.so implementation. */ | |
445 | GL(dl_rtld_lock_recursive) = (void *) INTUSE (__pthread_mutex_lock); | |
446 | GL(dl_rtld_unlock_recursive) = (void *) INTUSE (__pthread_mutex_unlock); | |
447 | unsigned int rtld_lock_count = GL(dl_load_lock).mutex.__data.__count; | |
448 | GL(dl_load_lock).mutex.__data.__count = 0; | |
449 | while (rtld_lock_count-- > 0) | |
450 | INTUSE (__pthread_mutex_lock) (&GL(dl_load_lock).mutex); | |
54ee14b3 UD |
451 | |
452 | GL(dl_make_stack_executable_hook) = &__make_stacks_executable; | |
b1531183 UD |
453 | #endif |
454 | ||
adc12574 UD |
455 | GL(dl_init_static_tls) = &__pthread_init_static_tls; |
456 | ||
7adefea8 UD |
457 | GL(dl_wait_lookup_done) = &__wait_lookup_done; |
458 | ||
76a50749 | 459 | /* Register the fork generation counter with the libc. */ |
5a03acfe UD |
460 | #ifndef TLS_MULTIPLE_THREADS_IN_TCB |
461 | __libc_multiple_threads_ptr = | |
462 | #endif | |
463 | __libc_pthread_init (&__fork_generation, __reclaim_stacks, | |
464 | ptr_pthread_functions); | |
2c0b891a UD |
465 | |
466 | /* Determine whether the machine is SMP or not. */ | |
467 | __is_smp = is_smp_system (); | |
76a50749 | 468 | } |
2ae920ed UD |
469 | strong_alias (__pthread_initialize_minimal_internal, |
470 | __pthread_initialize_minimal) | |
2c1094bd UD |
471 | |
472 | ||
473 | size_t | |
474 | __pthread_get_minstack (const pthread_attr_t *attr) | |
475 | { | |
476 | struct pthread_attr *iattr = (struct pthread_attr *) attr; | |
477 | ||
478 | return (GLRO(dl_pagesize) + __static_tls_size + PTHREAD_STACK_MIN | |
479 | + iattr->guardsize); | |
480 | } |