From patchwork Mon May 10 12:37:51 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Florian Weimer X-Patchwork-Id: 1476387 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=sourceware.org (client-ip=8.43.85.97; helo=sourceware.org; envelope-from=libc-alpha-bounces@sourceware.org; receiver=) Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; secure) header.d=sourceware.org header.i=@sourceware.org header.a=rsa-sha256 header.s=default header.b=aI6h9B8O; dkim-atps=neutral Received: from sourceware.org (server2.sourceware.org [8.43.85.97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 4Ff0v63Xr2z9tlG for ; Mon, 10 May 2021 22:37:38 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id DC87F396C832; Mon, 10 May 2021 12:37:32 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org DC87F396C832 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1620650252; bh=RqAKCOxY/SrltRZYbP4OaqOosDdkq0lWZvrADj9SDSU=; h=To:Subject:In-Reply-To:References:Date:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:List-Subscribe:From:Reply-To: From; b=aI6h9B8Oq6OH+Crze3zmSPN985jpsNuryYaGLuMKFTMjWA/BfW8KRs1hy3D87I2+w XYmYu36bwqTiWlhiCo6HSS08WkKj2xVoDCnA0JDH7jmPDOCNNRovTK0+x9ahfmts+0 gzmnjIz+3TjwUtd5Jyvjl3aB2uf8pITRNoXlYoBM= X-Original-To: libc-alpha@sourceware.org Delivered-To: libc-alpha@sourceware.org Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by sourceware.org (Postfix) with ESMTP id 79A9F396C824 for ; Mon, 10 May 2021 12:37:29 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org 79A9F396C824 Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-424-RnGbtMpXNjKLjuEZkSnA8Q-1; Mon, 10 May 2021 08:37:27 -0400 X-MC-Unique: RnGbtMpXNjKLjuEZkSnA8Q-1 Received: from smtp.corp.redhat.com (int-mx03.intmail.prod.int.phx2.redhat.com [10.5.11.13]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 9225A1854E24 for ; Mon, 10 May 2021 12:37:26 +0000 (UTC) Received: from oldenburg.str.redhat.com (ovpn-112-137.ams2.redhat.com [10.36.112.137]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 8625C60CC5 for ; Mon, 10 May 2021 12:37:25 +0000 (UTC) To: libc-alpha@sourceware.org Subject: [PATCH 5/8] nptl: Move stack cache management, __libpthread_freeres into libc In-Reply-To: References: X-From-Line: 14bef3680d1c8f3df2a75cb978f7c398a3973702 Mon Sep 17 00:00:00 2001 Message-Id: <14bef3680d1c8f3df2a75cb978f7c398a3973702.1620650045.git.fweimer@redhat.com> Date: Mon, 10 May 2021 14:37:51 +0200 User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/27.2 (gnu/linux) MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.13 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com X-Spam-Status: No, score=-12.8 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_SHORT, RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H4, RCVD_IN_MSPIKE_WL, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.2 X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on server2.sourceware.org X-BeenThere: libc-alpha@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Libc-alpha mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Florian Weimer via Libc-alpha From: Florian Weimer Reply-To: Florian Weimer Errors-To: libc-alpha-bounces@sourceware.org Sender: "Libc-alpha" This replaces the FREE_P macro with the __nptl_stack_in_use inline function. stack_list_del is renamed to __nptl_stack_list_del, stack_list_add to __nptl_stack_list_add, __deallocate_stack to __nptl_deallocate_stack, free_stacks to __nptl_free_stacks. It is convenient to move __libpthread_freeres into libc at the same time. This removes the temporary __default_pthread_attr_freeres export and restores full freeres coverage for __default_pthread_attr. Reviewed-by: Adhemerval Zanella --- malloc/set-freeres.c | 15 +++-- nptl/Makefile | 3 +- nptl/Versions | 5 +- nptl/allocatestack.c | 147 ++---------------------------------------- nptl/descr.h | 6 ++ nptl/nptl-stack.c | 130 +++++++++++++++++++++++++++++++++++++ nptl/nptl-stack.h | 50 ++++++++++++++ nptl/nptlfreeres.c | 3 +- nptl/pthreadP.h | 7 +- nptl/pthread_create.c | 4 +- 10 files changed, 212 insertions(+), 158 deletions(-) create mode 100644 nptl/nptl-stack.c create mode 100644 nptl/nptl-stack.h diff --git a/malloc/set-freeres.c b/malloc/set-freeres.c index d404250151..5c19a2725c 100644 --- a/malloc/set-freeres.c +++ b/malloc/set-freeres.c @@ -29,7 +29,15 @@ DEFINE_HOOK (__libc_subfreeres, (void)); symbol_set_define (__libc_freeres_ptrs); -extern __attribute__ ((weak)) void __libpthread_freeres (void); +extern void __libpthread_freeres (void) +#if PTHREAD_IN_LIBC && defined SHARED +/* It is possible to call __libpthread_freeres directly in shared + builds with an integrated libpthread. */ + attribute_hidden +#else + __attribute__ ((weak)) +#endif + ; void __libc_freeres_fn_section __libc_freeres (void) @@ -51,10 +59,7 @@ __libc_freeres (void) /* We run the resource freeing after IO cleanup. */ RUN_HOOK (__libc_subfreeres, ()); - /* Call the libpthread list of cleanup functions - (weak-ref-and-check). */ - if (&__libpthread_freeres != NULL) - __libpthread_freeres (); + call_function_static_weak (__libpthread_freeres); #ifdef SHARED __libc_unwind_link_freeres (); diff --git a/nptl/Makefile b/nptl/Makefile index 2a18eadf71..3b83817163 100644 --- a/nptl/Makefile +++ b/nptl/Makefile @@ -44,9 +44,11 @@ routines = \ libc_multiple_threads \ libc_pthread_init \ lowlevellock \ + nptl-stack \ nptl_deallocate_tsd \ nptl_nthreads \ nptl_setxid \ + nptlfreeres \ old_pthread_atfork \ old_pthread_cond_broadcast \ old_pthread_cond_destroy \ @@ -185,7 +187,6 @@ libpthread-routines = \ funlockfile \ libpthread-compat \ nptl-init \ - nptlfreeres \ pt-interp \ pthread_attr_getaffinity \ pthread_attr_getguardsize \ diff --git a/nptl/Versions b/nptl/Versions index de025e179c..93219d2657 100644 --- a/nptl/Versions +++ b/nptl/Versions @@ -303,7 +303,6 @@ libc { } GLIBC_PRIVATE { __default_pthread_attr; - __default_pthread_attr_freeres; __default_pthread_attr_lock; __futex_abstimed_wait64; __futex_abstimed_wait_cancelable64; @@ -320,9 +319,12 @@ libc { __lll_trylock_elision; __lll_unlock_elision; __mutex_aconf; + __nptl_deallocate_stack; __nptl_deallocate_tsd; __nptl_nthreads; __nptl_setxid_sighandler; + __nptl_stack_list_add; + __nptl_stack_list_del; __pthread_attr_copy; __pthread_attr_destroy; __pthread_attr_init; @@ -459,7 +461,6 @@ libpthread { } GLIBC_PRIVATE { - __libpthread_freeres; __pthread_clock_gettime; __pthread_clock_settime; __pthread_get_minstack; diff --git a/nptl/allocatestack.c b/nptl/allocatestack.c index 8672e89e75..c0a5c4d96d 100644 --- a/nptl/allocatestack.c +++ b/nptl/allocatestack.c @@ -31,7 +31,7 @@ #include #include #include - +#include #ifndef NEED_SEPARATE_REGISTER_STACK @@ -92,56 +92,6 @@ # define MAP_STACK 0 #endif -/* This yields the pointer that TLS support code calls the thread pointer. */ -#if TLS_TCB_AT_TP -# define TLS_TPADJ(pd) (pd) -#elif TLS_DTV_AT_TP -# define TLS_TPADJ(pd) ((struct pthread *)((char *) (pd) + TLS_PRE_TCB_SIZE)) -#endif - -/* Cache handling for not-yet free stacks. */ - -/* Maximum size in kB of cache. */ -static size_t stack_cache_maxsize = 40 * 1024 * 1024; /* 40MiBi by default. */ - -/* Check whether the stack is still used or not. */ -#define FREE_P(descr) ((descr)->tid <= 0) - - -static void -stack_list_del (list_t *elem) -{ - GL (dl_in_flight_stack) = (uintptr_t) elem; - - atomic_write_barrier (); - - list_del (elem); - - atomic_write_barrier (); - - GL (dl_in_flight_stack) = 0; -} - - -static void -stack_list_add (list_t *elem, list_t *list) -{ - GL (dl_in_flight_stack) = (uintptr_t) elem | 1; - - atomic_write_barrier (); - - list_add (elem, list); - - atomic_write_barrier (); - - GL (dl_in_flight_stack) = 0; -} - - -/* We create a double linked list of all cache entries. Double linked - because this allows removing entries from the end. */ - - /* Get a stack frame from the cache. We have to match by size since some blocks might be too small or far too large. */ static struct pthread * @@ -164,7 +114,7 @@ get_cached_stack (size_t *sizep, void **memp) struct pthread *curr; curr = list_entry (entry, struct pthread, list); - if (FREE_P (curr) && curr->stackblock_size >= size) + if (__nptl_stack_in_use (curr) && curr->stackblock_size >= size) { if (curr->stackblock_size == size) { @@ -193,10 +143,10 @@ get_cached_stack (size_t *sizep, void **memp) result->setxid_futex = -1; /* Dequeue the entry. */ - stack_list_del (&result->list); + __nptl_stack_list_del (&result->list); /* And add to the list of stacks in use. */ - stack_list_add (&result->list, &GL (dl_stack_used)); + __nptl_stack_list_add (&result->list, &GL (dl_stack_used)); /* And decrease the cache size. */ GL (dl_stack_cache_actsize) -= result->stackblock_size; @@ -229,68 +179,6 @@ get_cached_stack (size_t *sizep, void **memp) return result; } - -/* Free stacks until cache size is lower than LIMIT. */ -static void -free_stacks (size_t limit) -{ - /* We reduce the size of the cache. Remove the last entries until - the size is below the limit. */ - list_t *entry; - list_t *prev; - - /* Search from the end of the list. */ - list_for_each_prev_safe (entry, prev, &GL (dl_stack_cache)) - { - struct pthread *curr; - - curr = list_entry (entry, struct pthread, list); - if (FREE_P (curr)) - { - /* Unlink the block. */ - stack_list_del (entry); - - /* Account for the freed memory. */ - GL (dl_stack_cache_actsize) -= curr->stackblock_size; - - /* Free the memory associated with the ELF TLS. */ - _dl_deallocate_tls (TLS_TPADJ (curr), false); - - /* Remove this block. This should never fail. If it does - something is really wrong. */ - if (__munmap (curr->stackblock, curr->stackblock_size) != 0) - abort (); - - /* Maybe we have freed enough. */ - if (GL (dl_stack_cache_actsize) <= limit) - break; - } - } -} - -/* Free all the stacks on cleanup. */ -void -__nptl_stacks_freeres (void) -{ - free_stacks (0); -} - -/* Add a stack frame which is not used anymore to the stack. Must be - called with the cache lock held. */ -static inline void -__attribute ((always_inline)) -queue_stack (struct pthread *stack) -{ - /* We unconditionally add the stack to the list. The memory may - still be in use but it will not be reused until the kernel marks - the stack as not used anymore. */ - stack_list_add (&stack->list, &GL (dl_stack_cache)); - - GL (dl_stack_cache_actsize) += stack->stackblock_size; - if (__glibc_unlikely (GL (dl_stack_cache_actsize) > stack_cache_maxsize)) - free_stacks (stack_cache_maxsize); -} - /* Return the guard page position on allocated stack. */ static inline char * __attribute ((always_inline)) @@ -588,7 +476,7 @@ allocate_stack (const struct pthread_attr *attr, struct pthread **pdp, lll_lock (GL (dl_stack_cache_lock), LLL_PRIVATE); /* And add to the list of stacks in use. */ - stack_list_add (&pd->list, &GL (dl_stack_used)); + __nptl_stack_list_add (&pd->list, &GL (dl_stack_used)); lll_unlock (GL (dl_stack_cache_lock), LLL_PRIVATE); @@ -630,7 +518,7 @@ allocate_stack (const struct pthread_attr *attr, struct pthread **pdp, lll_lock (GL (dl_stack_cache_lock), LLL_PRIVATE); /* Remove the thread from the list. */ - stack_list_del (&pd->list); + __nptl_stack_list_del (&pd->list); lll_unlock (GL (dl_stack_cache_lock), LLL_PRIVATE); @@ -731,26 +619,3 @@ allocate_stack (const struct pthread_attr *attr, struct pthread **pdp, return 0; } - - -void -__deallocate_stack (struct pthread *pd) -{ - lll_lock (GL (dl_stack_cache_lock), LLL_PRIVATE); - - /* Remove the thread from the list of threads with user defined - stacks. */ - stack_list_del (&pd->list); - - /* Not much to do. Just free the mmap()ed memory. Note that we do - not reset the 'used' flag in the 'tid' field. This is done by - the kernel. If no thread has been created yet this field is - still zero. */ - if (__glibc_likely (! pd->user_stack)) - (void) queue_stack (pd); - else - /* Free the memory associated with the ELF TLS. */ - _dl_deallocate_tls (TLS_TPADJ (pd), false); - - lll_unlock (GL (dl_stack_cache_lock), LLL_PRIVATE); -} diff --git a/nptl/descr.h b/nptl/descr.h index d423a53bbf..3de9535449 100644 --- a/nptl/descr.h +++ b/nptl/descr.h @@ -416,5 +416,11 @@ struct pthread (sizeof (struct pthread) - offsetof (struct pthread, end_padding)) } __attribute ((aligned (TCB_ALIGNMENT))); +/* This yields the pointer that TLS support code calls the thread pointer. */ +#if TLS_TCB_AT_TP +# define TLS_TPADJ(pd) (pd) +#elif TLS_DTV_AT_TP +# define TLS_TPADJ(pd) ((struct pthread *)((char *) (pd) + TLS_PRE_TCB_SIZE)) +#endif #endif /* descr.h */ diff --git a/nptl/nptl-stack.c b/nptl/nptl-stack.c new file mode 100644 index 0000000000..5ead9db198 --- /dev/null +++ b/nptl/nptl-stack.c @@ -0,0 +1,130 @@ +/* Stack cache management for NPTL. + Copyright (C) 2002-2021 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Ulrich Drepper , 2002. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#include +#include + +/* Maximum size in kB of cache. */ +static size_t stack_cache_maxsize = 40 * 1024 * 1024; /* 40MiBi by default. */ + +void +__nptl_stack_list_del (list_t *elem) +{ + GL (dl_in_flight_stack) = (uintptr_t) elem; + + atomic_write_barrier (); + + list_del (elem); + + atomic_write_barrier (); + + GL (dl_in_flight_stack) = 0; +} +libc_hidden_def (__nptl_stack_list_del) + +void +__nptl_stack_list_add (list_t *elem, list_t *list) +{ + GL (dl_in_flight_stack) = (uintptr_t) elem | 1; + + atomic_write_barrier (); + + list_add (elem, list); + + atomic_write_barrier (); + + GL (dl_in_flight_stack) = 0; +} +libc_hidden_def (__nptl_stack_list_add) + +void +__nptl_free_stacks (size_t limit) +{ + /* We reduce the size of the cache. Remove the last entries until + the size is below the limit. */ + list_t *entry; + list_t *prev; + + /* Search from the end of the list. */ + list_for_each_prev_safe (entry, prev, &GL (dl_stack_cache)) + { + struct pthread *curr; + + curr = list_entry (entry, struct pthread, list); + if (__nptl_stack_in_use (curr)) + { + /* Unlink the block. */ + __nptl_stack_list_del (entry); + + /* Account for the freed memory. */ + GL (dl_stack_cache_actsize) -= curr->stackblock_size; + + /* Free the memory associated with the ELF TLS. */ + _dl_deallocate_tls (TLS_TPADJ (curr), false); + + /* Remove this block. This should never fail. If it does + something is really wrong. */ + if (__munmap (curr->stackblock, curr->stackblock_size) != 0) + abort (); + + /* Maybe we have freed enough. */ + if (GL (dl_stack_cache_actsize) <= limit) + break; + } + } +} + +/* Add a stack frame which is not used anymore to the stack. Must be + called with the cache lock held. */ +static inline void +__attribute ((always_inline)) +queue_stack (struct pthread *stack) +{ + /* We unconditionally add the stack to the list. The memory may + still be in use but it will not be reused until the kernel marks + the stack as not used anymore. */ + __nptl_stack_list_add (&stack->list, &GL (dl_stack_cache)); + + GL (dl_stack_cache_actsize) += stack->stackblock_size; + if (__glibc_unlikely (GL (dl_stack_cache_actsize) > stack_cache_maxsize)) + __nptl_free_stacks (stack_cache_maxsize); +} + +void +__nptl_deallocate_stack (struct pthread *pd) +{ + lll_lock (GL (dl_stack_cache_lock), LLL_PRIVATE); + + /* Remove the thread from the list of threads with user defined + stacks. */ + __nptl_stack_list_del (&pd->list); + + /* Not much to do. Just free the mmap()ed memory. Note that we do + not reset the 'used' flag in the 'tid' field. This is done by + the kernel. If no thread has been created yet this field is + still zero. */ + if (__glibc_likely (! pd->user_stack)) + (void) queue_stack (pd); + else + /* Free the memory associated with the ELF TLS. */ + _dl_deallocate_tls (TLS_TPADJ (pd), false); + + lll_unlock (GL (dl_stack_cache_lock), LLL_PRIVATE); +} +libc_hidden_def (__nptl_deallocate_stack) diff --git a/nptl/nptl-stack.h b/nptl/nptl-stack.h new file mode 100644 index 0000000000..8631b61816 --- /dev/null +++ b/nptl/nptl-stack.h @@ -0,0 +1,50 @@ +/* Stack cache management for NPTL. + Copyright (C) 2002-2021 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Ulrich Drepper , 2002. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _NPTL_STACK_H +#define _NPTL_STACK_H + +#include +#include +#include + +/* Check whether the stack is still used or not. */ +static inline bool +__nptl_stack_in_use (struct pthread *pd) +{ + return pd->tid <= 0; +} + +/* Remove the stack ELEM from its list. */ +void __nptl_stack_list_del (list_t *elem); +libc_hidden_proto (__nptl_stack_list_del) + +/* Add ELEM to a stack list. LIST can be either &GL (dl_stack_used) + or &GL (dl_stack_cache). */ +void __nptl_stack_list_add (list_t *elem, list_t *list); +libc_hidden_proto (__nptl_stack_list_add) + +/* Free allocated stack. */ +extern void __nptl_deallocate_stack (struct pthread *pd); +libc_hidden_proto (__nptl_deallocate_stack) + +/* Free stacks until cache size is lower than LIMIT. */ +void __nptl_free_stacks (size_t limit) attribute_hidden; + +#endif /* _NPTL_STACK_H */ diff --git a/nptl/nptlfreeres.c b/nptl/nptlfreeres.c index 4833f04714..527b5ee103 100644 --- a/nptl/nptlfreeres.c +++ b/nptl/nptlfreeres.c @@ -19,6 +19,7 @@ #include #include #include +#include /* Free libpthread.so resources. Note: Caller ensures we are called only once. */ @@ -26,5 +27,5 @@ void __libpthread_freeres (void) { call_function_static_weak (__default_pthread_attr_freeres); - call_function_static_weak (__nptl_stacks_freeres); + __nptl_free_stacks (0); } diff --git a/nptl/pthreadP.h b/nptl/pthreadP.h index 8466332248..505d0f00ff 100644 --- a/nptl/pthreadP.h +++ b/nptl/pthreadP.h @@ -203,7 +203,7 @@ libc_hidden_proto (__default_pthread_attr) extern int __default_pthread_attr_lock; libc_hidden_proto (__default_pthread_attr_lock) /* Called from __libc_freeres to deallocate the default attribute. */ -extern void __default_pthread_attr_freeres (void); +extern void __default_pthread_attr_freeres (void) attribute_hidden; /* Size and alignment of static TLS block. */ extern size_t __static_tls_size attribute_hidden; @@ -314,9 +314,6 @@ __do_cancel (void) descriptor is still valid. */ extern void __free_tcb (struct pthread *pd) attribute_hidden; -/* Free allocated stack. */ -extern void __deallocate_stack (struct pthread *pd) attribute_hidden; - /* Change the permissions of a thread stack. Called from _dl_make_stacks_executable and pthread_create. */ int @@ -679,8 +676,6 @@ void __nptl_setxid_sighandler (int sig, siginfo_t *si, void *ctx); libc_hidden_proto (__nptl_setxid_sighandler) extern int __nptl_setxid (struct xid_command *cmdp) attribute_hidden; -extern void __nptl_stacks_freeres (void) attribute_hidden; - extern void __wait_lookup_done (void) attribute_hidden; /* Allocates the extension space for ATTR. Returns an error code on diff --git a/nptl/pthread_create.c b/nptl/pthread_create.c index d19456d48b..fcaf440bb5 100644 --- a/nptl/pthread_create.c +++ b/nptl/pthread_create.c @@ -228,7 +228,7 @@ __free_tcb (struct pthread *pd) /* Queue the stack memory block for reuse and exit the process. The kernel will signal via writing to the address returned by QUEUE-STACK when the stack is available. */ - __deallocate_stack (pd); + __nptl_deallocate_stack (pd); } } @@ -711,7 +711,7 @@ __pthread_create_2_1 (pthread_t *newthread, const pthread_attr_t *attr, futex_wake (&pd->setxid_futex, 1, FUTEX_PRIVATE); /* Free the resources. */ - __deallocate_stack (pd); + __nptl_deallocate_stack (pd); } /* We have to translate error codes. */