[PATCH v3 1/1] rtld: add tunable for audit-specific surplus TLS

Adhemerval Zanella Netto adhemerval.zanella@linaro.org
Tue Nov 3 20:42:15 GMT 2026



On 29/10/26 13:44, DJ Delorie wrote:
> 
> Add glibc.rtld.audit_static_tls which specifies additional
> surplus TLS just for audit modules, as when audit modules are
> used the loader can't compute TLS space before the auditors
> run.  This surplus exists until the loader can recompute the
> TLS needs, and is reduced for future threads.

The reserved space is not used only by audit modules, since init_tls
runs before the main program's dependencies are loaded.  So *every*
 object loaded at startup that needs static TLS gets it from the
surplus, including the program's own dependencies and the base
namespace libc.so. I think it is worth to mention this on commit
message.

This patch also needs a NEWS entry for the new tunable and tests.

> ---
> Changes in v3:
>   - rebased
>   - fixed typo in dl-tls.c
> Changes in v2:
>   - rebased
>   - fix tst-rtld-list-tunables
> 
>  elf/dl-tls.c                   | 43 ++++++++++++++++++++++++++++++++--
>  elf/dl-tunables.list           |  5 ++++
>  elf/rtld.c                     |  2 ++
>  elf/tst-rtld-list-tunables.exp |  1 +
>  manual/tunables.texi           | 22 +++++++++++++++++
>  sysdeps/generic/ldsodefs.h     |  5 ++++
>  6 files changed, 76 insertions(+), 2 deletions(-)
> 
> diff --git a/elf/dl-tls.c b/elf/dl-tls.c
> index 31b26fe8d3..f7308d8ce5 100644
> --- a/elf/dl-tls.c
> +++ b/elf/dl-tls.c
> @@ -130,6 +130,10 @@ tls_static_surplus (int nns, int opt_tls)
>     tunable, and sets an additional minimum alignment on the TLS
>     data.  */
>  static size_t optional_static_tls_alignment = 0;
> +static size_t dl_audit_tls = 0;
> +static size_t dl_original_optional = 0;
> +static size_t dl_original_surplus = 0;

The 'dl_original_surplus' is not really required, nothing access it after
_dl_tls_static_surplus_init.

> +static size_t dl_original_align = 1;
>  
>  /* Calculate the size of the static TLS surplus, when the given
>     number of audit modules are loaded.  Must be called after the
> @@ -145,6 +149,8 @@ _dl_tls_static_surplus_init (size_t naudit)
>    /* Ignore invalid requests.  */
>    if (! powerof2 (optional_static_tls_alignment))
>      optional_static_tls_alignment = 0;
> +  if (naudit)

No implicit checks: 'if (naudit > 0)'.

> +    dl_audit_tls = TUNABLE_GET (audit_static_tls, size_t, NULL);
>    if (nns > DL_NNS)
>      nns = DL_NNS;
>    if (DL_NNS - nns < naudit)
> @@ -155,6 +161,33 @@ _dl_tls_static_surplus_init (size_t naudit)
>    GL(dl_tls_static_optional) = opt_tls;
>    assert (LEGACY_TLS >= 0);
>    GLRO(dl_tls_static_surplus) = tls_static_surplus (nns, opt_tls) + LEGACY_TLS;
> +
> +  if (dl_audit_tls > 0)
> +    {
> +      if (dl_audit_tls >= SIZE_MAX / 2)
> +	_dl_fatal_printf ("glibc.rtld.audit_static_tls exceeds SIZE_MAX/2\n");

The usual way to do this is a maxval in dl-tunables.list, which makes the loader
ignore out-of-range values. I think it would be better to just use very large
max value (0x40000000 / 1 GiB) or maybe improve the tunables definition to
accept symbolic value (like SSIZE_MAX_DIV_2):

cat << EOF > auditmod.c
#include <link.h>
#include <stdio.h>

extern void _dl_get_tls_static_info (size_t *, size_t *);

__thread char aud_buf[56 * 1024] __attribute__ ((tls_model ("initial-exec")));

unsigned int
la_version (unsigned int version)
{
  size_t size, align;
  _dl_get_tls_static_info (&size, &align);
  fprintf (stderr, "auditor: static TLS size %zu (initial thread block)\n",
           size);
  aud_buf[0] = 1;
  return version;
}
EOF
cat <<EOF > libie.c
__thread char ie_buf[56 * 1024] __attribute__ ((tls_model ("initial-exec")));

char *
ie_addr (void)
{
  return ie_buf;
}
EOF
cat << EOF > main.c
#include <dlfcn.h>
#include <stdio.h>

extern void _dl_get_tls_static_info (size_t *, size_t *);

int
main (int argc, char **argv)
{
  size_t size, align;
  _dl_get_tls_static_info (&size, &align);
  printf ("main: static TLS size %zu\n", size);
  fflush (stdout);

  void *h = dlopen (argv[1], RTLD_NOW);
  if (h == NULL)
    {
      printf ("main: dlopen failed: %s\n", dlerror ());
      return 1;
    }
  puts ("main: dlopen succeeded");
  return 0;
}
EOF

$ gcc -O2 -o main main.c
$ gcc -O2 -fPIC -shared -o libie.so libie.c
$ gcc -O2 -fPIC -shared -o auditmod.so auditmod.c

$ GLIBC_TUNABLES=glibc.rtld.optional_static_tls=0x10000 \
elf/ld.so --library-path . --audit auditmod.so main /tmp/review/libie.so
auditor: static TLS size 69440 (initial thread block)
main: static TLS size 69440
main: dlopen failed: libie.so: cannot allocate memory in static TLS block: ie_buf: requested 000000000000e940, available 0000000000002e00
$ GLIBC_TUNABLES=glibc.rtld.optional_static_tls=0x10000:glibc.rtld.audit_static_tls=16 \
elf/ld.so --library-path . --audit auditmod.so main libie.so
auditor: static TLS size 69440 (initial thread block)
main: static TLS size 127040
Segmentation fault

The size should only ever shrink. I think we want something like:

  static size_t dl_audit_tls;
  static size_t dl_original_optional;

  static size_t
  tls_static_size (size_t used, size_t surplus, size_t align)
  {
  #if TLS_TCB_AT_TP
    return roundup (used + surplus, align) + TLS_TCB_SIZE;
  #elif TLS_DTV_AT_TP
    return roundup (used + surplus, TCB_ALIGNMENT);
  #else
  # error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
  #endif
  }

  void
  _dl_tls_static_surplus_init (size_t naudit)
  {
    [...]
    dl_original_optional = opt_tls;
    [...] 
  }

  void
  _dl_tls_prune_audit_storage (void)
  {
    if (dl_audit_tls == 0)
      return;

    size_t size = tls_static_size (GL(dl_tls_static_used),
                                   GLRO(dl_tls_static_surplus),
                                   GLRO(dl_tls_static_align));
    if (size < GLRO(dl_tls_static_size))
      {
        GLRO(dl_tls_static_size) = size;
        GL(dl_tls_static_optional) = dl_original_optional;
      }
  }

And adjust it on _dl_determine_tlsoffset:

  GLRO (dl_tls_static_size) = tls_static_size (offset,
					       GLRO(dl_tls_static_surplus)
					       + dl_audit_tls,
					       max_align);


With this, the above example should safely fail to load the library.

> +      dl_original_optional = GL(dl_tls_static_optional);
> +      dl_original_surplus = GLRO(dl_tls_static_surplus);
> +    }
> +}
> +
> +/* Undo as much of the audit-specific extra TLS space accounted for
> +   above, as possible.  After this function, the unused amount of TLS
> +   must be at least the dl_tls_static_surplus amount.  */
> +void
> +_dl_tls_prune_audit_storage (void)
> +{
> +  if (dl_audit_tls > 0)
> +    {
> +      GL(dl_tls_static_optional) = dl_original_optional;
> +      GLRO(dl_tls_static_surplus) = dl_original_surplus;
> +      GLRO(dl_tls_static_size) = roundup (GL(dl_tls_static_used)
> +					  + dl_original_surplus,
> +					  dl_original_align);

I think this can set GLRO(dl_tls_static_size) larger than the initial thread's
static TLS block, and the block is already allocated at this point (and cannot
grow).

The old size based on 'offset + surplus + dl_audit_tls' and the new on
'use + surplus'. So whatever the objects loaded at startup use more than 
dl_audit_tls (used - offset > dl_audit_tls) the size grow.

> +#ifdef TLS_TCB_AT_TP

As Gabriel noted, this is always true (every port defines both TLS_TCB_AT_TP and
TLS_DTV_AT_TP).

> +      GLRO(dl_tls_static_size) += TLS_TCB_SIZE;
> +#endif
> +    }
>  }
>  
>  /* Out-of-memory handler.  */
> @@ -380,9 +413,12 @@ _dl_determine_tlsoffset (void)
>    _dl_extra_tls_set_offset (-offset);
>  
>    GL(dl_tls_static_used) = offset;
> -  GLRO (dl_tls_static_size) = (roundup (offset + GLRO(dl_tls_static_surplus),
> +  GLRO (dl_tls_static_size) = (roundup (offset
> +					+ GLRO(dl_tls_static_surplus)
> +					+ dl_audit_tls,
>  					max_align)
>  			       + TLS_TCB_SIZE);
> +  dl_original_align = max_align;
>  #elif TLS_DTV_AT_TP
>    /* The TLS blocks start right after the TCB.  */
>    size_t offset = TLS_TCB_SIZE;
> @@ -467,8 +503,11 @@ _dl_determine_tlsoffset (void)
>    offset += extra_tls_size;
>  
>    GL(dl_tls_static_used) = offset;
> -  GLRO (dl_tls_static_size) = roundup (offset + GLRO(dl_tls_static_surplus),
> +  GLRO (dl_tls_static_size) = roundup (offset
> +				       + GLRO(dl_tls_static_surplus)
> +				       + dl_audit_tls,
>  				       TCB_ALIGNMENT);
> +  dl_original_align = TCB_ALIGNMENT;
>  #else
>  # error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
>  #endif
> diff --git a/elf/dl-tunables.list b/elf/dl-tunables.list
> index 4c78444542..d8daf30ab0 100644
> --- a/elf/dl-tunables.list
> +++ b/elf/dl-tunables.list
> @@ -106,6 +106,11 @@ glibc {
>        minval: 0
>        default: 0
>      }
> +    audit_static_tls {
> +      type: SIZE_T
> +      minval: 0
> +      default: 0
> +    }
>      enable_secure {
>        type: INT_32
>        minval: 0
> diff --git a/elf/rtld.c b/elf/rtld.c
> index 9233c50256..5799b1d007 100644
> --- a/elf/rtld.c
> +++ b/elf/rtld.c
> @@ -2353,6 +2353,8 @@ dl_main (const ElfW(Phdr) *phdr,
>        _dl_debug_post_relocate (main_map);
>      }
>  
> +  _dl_tls_prune_audit_storage ();
> +
>    /* All ld.so initialization is complete.  Apply RELRO.  */
>    _dl_protect_relro (&_dl_rtld_map);
>  
> diff --git a/elf/tst-rtld-list-tunables.exp b/elf/tst-rtld-list-tunables.exp
> index 17520d6b31..d208804723 100644
> --- a/elf/tst-rtld-list-tunables.exp
> +++ b/elf/tst-rtld-list-tunables.exp
> @@ -10,6 +10,7 @@ glibc.malloc.tcache_count: 0x0 (min: 0x0, max: 0x[f]+)
>  glibc.malloc.tcache_max: 0x0 (min: 0x0, max: 0x[f]+)
>  glibc.malloc.top_pad: 0x20000 (min: 0x0, max: 0x[f]+)
>  glibc.malloc.trim_threshold: 0x0 (min: 0x0, max: 0x[f]+)
> +glibc.rtld.audit_static_tls: 0x0 (min: 0x0, max: 0x[f]+)
>  glibc.rtld.dynamic_sort: 2 (min: 1, max: 2)
>  glibc.rtld.enable_secure: 0 (min: 0, max: 1)
>  glibc.rtld.execstack: 1 (min: 0, max: 2)
> diff --git a/manual/tunables.texi b/manual/tunables.texi
> index 2cb516b1dc..12565c6ae8 100644
> --- a/manual/tunables.texi
> +++ b/manual/tunables.texi
> @@ -429,6 +429,28 @@ for (for example) audit modules that have a higher-than-default
>  alignment requirement.
>  @end deftp
>  
> +@deftp Tunable glibc.rtld.audit_static_tls
> +Sets an additional amount of memory to be allocated in the initial
> +thread's TLS when one or more auditing modules are to be loaded.

I think it would be worth adding that the value is in bytes and that it is
for static TLS only. The initial-exec TLS, TLS blocks accessed through an
initial-exec access, and the space used by the TLSDESC and powerpc
optimizations.  Dynamic TLS in an audit module does not use this space.



> +Since auditing modules must run before the loader is done loading
> +dynamic objects, the loader cannot know how much TLS space is needed
> +before it must create the first TLS area.  If no auditing modules are
> +loaded, the initial TLS size can be computed after the dynamic objects
> +are loaded.  When this tunable is used, the initial TLS size can be
> +very large, and the size computation is adjusted after loading is
> +complete, so that any additional threads created will have a more
> +suitable TLS size (including any optional space as specified by
> +@code{glibc.rtld.optional_static_tls}).  The default is to not
> +allocate any additional TLS for audit modules.
> +
> +As an example, if a program required 1MB of TLS space and specified an
> +optional 1MB surplus, normally every thread would have 2MB of TLS
> +space.  If an auditing module requires 3MB of TLS space, and 5MB of
> +audit TLS was specified by this tunable, the main thread would have
> +7MB of TLS space (2MB plus the specified 5MB) and every other thread
> +would have 5MB (2MB plus the actual 3MB).
> +@end deftp
> +
>  @deftp Tunable glibc.rtld.dynamic_sort
>  Sets the algorithm to use for DSO sorting, valid values are @samp{1} and
>  @samp{2}.  For value of @samp{1}, an older O(n^3) algorithm is used, which is
> diff --git a/sysdeps/generic/ldsodefs.h b/sysdeps/generic/ldsodefs.h
> index 305ca6e0df..54535452b3 100644
> --- a/sysdeps/generic/ldsodefs.h
> +++ b/sysdeps/generic/ldsodefs.h
> @@ -1184,6 +1184,11 @@ extern void _dl_determine_tlsoffset (void) attribute_hidden;
>     number of audit modules are loaded.  */
>  void _dl_tls_static_surplus_init (size_t naudit) attribute_hidden;
>  
> +/* After startup is complete but before user entry, the size of the
> +   audit modules is more knowable so we can reduce the TLS size
> +   accordingly.  */
> +void _dl_tls_prune_audit_storage (void) attribute_hidden;
> +
>  /* This function is called very early from dl_main to set up TLS and
>     other thread-related data structures.  */
>  void __tls_pre_init_tp (void) attribute_hidden;



More information about the Libc-alpha mailing list