string: Remove old TLS usage on strsignal

The per-thread state is refactored two use two strategies:

  1. The default one uses a TLS structure, which will be placed in the
     static TLS space (using __thread keyword).

  2. Linux allocates via struct pthread and access it through THREAD_*
     macros.

The default strategy has the disadvantage of increasing libc.so static
TLS consumption and thus decreasing the possible surplus used in
some scenarios (which might be mitigated by BZ#25051 fix).

It is used only on Hurd, where accessing the thread storage in the in
single thread case is not straightforward (afaiu, Hurd developers could
correct me here).

The fallback static allocation used for allocation failure is also
removed: defining its size is problematic without synchronizing with
translated messages (to avoid partial translation) and the resulting
usage is not thread-safe.

Checked on x86-64-linux-gnu, i686-linux-gnu, powerpc64le-linux-gnu,
and s390x-linux-gnu.

Tested-by: Carlos O'Donell <carlos@redhat.com>
Reviewed-by: Carlos O'Donell <carlos@redhat.com>
This commit is contained in:
Adhemerval Zanella 2020-05-14 17:02:38 -03:00
parent f26d456b98
commit 9deec7c8ba
10 changed files with 156 additions and 92 deletions

View File

@ -21,6 +21,7 @@
#include <resolv/resolv-internal.h>
#include <rpc/rpc.h>
#include <string.h>
#include <tls-internal.h>
/* Thread shutdown function. Note that this function must be called
for threads during shutdown for correctness reasons. Unlike
@ -32,6 +33,7 @@ __libc_thread_freeres (void)
call_function_static_weak (__rpc_thread_destroy);
call_function_static_weak (__res_thread_freeres);
call_function_static_weak (__strerror_thread_freeres);
__glibc_tls_internal_free ();
/* This should come last because it shuts down malloc for this
thread and the other shutdown functions might well call free. */

View File

@ -237,6 +237,8 @@ get_cached_stack (size_t *sizep, void **memp)
/* No pending event. */
result->nextevent = NULL;
result->tls_state = (struct tls_internal_t) { 0 };
/* Clear the DTV. */
dtv_t *dtv = GET_DTV (TLS_TPADJ (result));
for (size_t cnt = 0; cnt < dtv[-1].counter; ++cnt)

View File

@ -34,6 +34,7 @@
#include <unwind.h>
#include <bits/types/res_state.h>
#include <kernel-features.h>
#include <tls-internal-struct.h>
#ifndef TCB_ALIGNMENT
# define TCB_ALIGNMENT sizeof (double)
@ -398,6 +399,9 @@ struct pthread
/* Indicates whether is a C11 thread created by thrd_creat. */
bool c11;
/* Used on strsignal. */
struct tls_internal_t tls_state;
/* This member must be last. */
char end_padding[];

View File

@ -20,106 +20,36 @@
#include <stdlib.h>
#include <string.h>
#include <libintl.h>
#include <libc-lock.h>
static __libc_key_t key;
/* If nonzero the key allocation failed and we should better use a
static buffer than fail. */
#define BUFFERSIZ 100
static char local_buf[BUFFERSIZ];
static char *static_buf;
/* Destructor for the thread-specific data. */
static void init (void);
static void free_key_mem (void *mem);
static char *getbuffer (void);
#include <tls-internal.h>
#include <array_length.h>
/* Return a string describing the meaning of the signal number SIGNUM. */
char *
strsignal (int signum)
{
__libc_once_define (static, once);
const char *desc;
const char *desc = NULL;
/* If we have not yet initialized the buffer do it now. */
__libc_once (once, init);
if (signum >= 0 && signum <= NSIG && signum < array_length (__sys_siglist))
desc = __sys_siglist[signum];
if (
#ifdef SIGRTMIN
(signum >= SIGRTMIN && signum <= SIGRTMAX) ||
#endif
signum < 0 || signum >= NSIG
|| (desc = __sys_siglist[signum]) == NULL)
{
char *buffer = getbuffer ();
int len;
if (desc != NULL)
return (char *) _(desc);
struct tls_internal_t *tls_internal = __glibc_tls_internal ();
free (tls_internal->strsignal_buf);
int r;
#ifdef SIGRTMIN
if (signum >= SIGRTMIN && signum <= SIGRTMAX)
len = __snprintf (buffer, BUFFERSIZ - 1, _("Real-time signal %d"),
r = __asprintf (&tls_internal->strsignal_buf, _("Real-time signal %d"),
signum - SIGRTMIN);
else
#endif
len = __snprintf (buffer, BUFFERSIZ - 1, _("Unknown signal %d"),
r = __asprintf (&tls_internal->strsignal_buf, _("Unknown signal %d"),
signum);
if (len >= BUFFERSIZ)
buffer = NULL;
else
buffer[len] = '\0';
return buffer;
}
return (char *) _(desc);
}
/* Initialize buffer. */
static void
init (void)
{
if (__libc_key_create (&key, free_key_mem))
/* Creating the key failed. This means something really went
wrong. In any case use a static buffer which is better than
nothing. */
static_buf = local_buf;
}
/* Free the thread specific data, this is done if a thread terminates. */
static void
free_key_mem (void *mem)
{
free (mem);
__libc_setspecific (key, NULL);
}
/* Return the buffer to be used. */
static char *
getbuffer (void)
{
char *result;
if (static_buf != NULL)
result = static_buf;
else
{
/* We don't use the static buffer and so we have a key. Use it
to get the thread-specific buffer. */
result = __libc_getspecific (key);
if (result == NULL)
{
/* No buffer allocated so far. */
result = malloc (BUFFERSIZ);
if (result == NULL)
/* No more memory available. We use the static buffer. */
result = local_buf;
else
__libc_setspecific (key, result);
}
}
return result;
if (r == -1)
tls_internal->strsignal_buf = NULL;
return tls_internal->strsignal_buf;
}

View File

@ -16,6 +16,7 @@
# <https://www.gnu.org/licenses/>.
ifeq ($(subdir),string)
sysdep_routines += tls-internal
CFLAGS-wordcopy.c += -Wno-uninitialized
endif

View File

@ -0,0 +1,27 @@
/* Per-thread state. Generic version.
Copyright (C) 2020 Free Software Foundation, Inc.
This file is part of the GNU C Library.
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
<https://www.gnu.org/licenses/>. */
#ifndef _TLS_INTERNAL_STRUCT_H
#define _TLS_INTERNAL_STRUCT_H 1
struct tls_internal_t
{
char *strsignal_buf;
};
#endif

View File

@ -0,0 +1,21 @@
/* Per-thread state. Generic version.
Copyright (C) 2020 Free Software Foundation, Inc.
This file is part of the GNU C Library.
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
<https://www.gnu.org/licenses/>. */
#include <tls-internal.h>
__thread struct tls_internal_t __tls_internal;

View File

@ -0,0 +1,39 @@
/* Per-thread state. Generic version.
Copyright (C) 2020 Free Software Foundation, Inc.
This file is part of the GNU C Library.
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
<https://www.gnu.org/licenses/>. */
#ifndef _TLS_INTERNAL_H
#define _TLS_INTERNAL_H 1
#include <stdlib.h>
#include <tls-internal-struct.h>
extern __thread struct tls_internal_t __tls_internal attribute_hidden;
static inline struct tls_internal_t *
__glibc_tls_internal (void)
{
return &__tls_internal;
}
static inline void
__glibc_tls_internal_free (void)
{
free (__tls_internal.strsignal_buf);
}
#endif

View File

@ -0,0 +1 @@
/* Empty. */

View File

@ -0,0 +1,37 @@
/* Per-thread state. Linux version.
Copyright (C) 2020 Free Software Foundation, Inc.
This file is part of the GNU C Library.
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
<https://www.gnu.org/licenses/>. */
#ifndef _TLS_INTERNAL_H
#define _TLS_INTERNAL_H 1
#include <stdlib.h>
#include <nptl/pthreadP.h>
static inline struct tls_internal_t *
__glibc_tls_internal (void)
{
return &THREAD_SELF->tls_state;
}
static inline void
__glibc_tls_internal_free (void)
{
free (THREAD_SELF->tls_state.strsignal_buf);
}
#endif