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