/* Relocate a shared object and resolve its references to other loaded objects.
- Copyright (C) 1995-2014 Free Software Foundation, Inc.
+ Copyright (C) 1995-2019 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
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
-#include <atomic.h>
#include <errno.h>
#include <libintl.h>
-#include <signal.h>
#include <stdlib.h>
#include <unistd.h>
#include <ldsodefs.h>
#include <sys/param.h>
#include <sys/types.h>
#include <_itoa.h>
+#include <libc-pointer-arith.h>
#include "dynamic-link.h"
/* Statistics function. */
directly, as static TLS should be rare and code handling it should
not be inlined as much as possible. */
int
-internal_function
_dl_try_allocate_static_tls (struct link_map *map)
{
/* If we've already used the variable with dynamic access, or if the
size_t offset = GL(dl_tls_static_used) + (freebytes - n * map->l_tls_align
- map->l_tls_firstbyte_offset);
+
+ map->l_tls_offset = GL(dl_tls_static_used) = offset;
#elif TLS_DTV_AT_TP
/* dl_tls_static_used includes the TCB at the beginning. */
- size_t offset = (((GL(dl_tls_static_used)
- - map->l_tls_firstbyte_offset
- + map->l_tls_align - 1) & -map->l_tls_align)
+ size_t offset = (ALIGN_UP(GL(dl_tls_static_used)
+ - map->l_tls_firstbyte_offset,
+ map->l_tls_align)
+ map->l_tls_firstbyte_offset);
size_t used = offset + map->l_tls_blocksize;
if (used > GL(dl_tls_static_size))
goto fail;
-#else
-# error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
-#endif
- /* We've computed the new value we want, now try to install it. */
- ptrdiff_t val;
- if ((val = map->l_tls_offset) == NO_TLS_OFFSET)
- {
- /* l_tls_offset starts out at NO_TLS_OFFSET, and all attempts to
- change it go from NO_TLS_OFFSET to some other value. We use
- compare_and_exchange to ensure only one attempt succeeds. We
- don't actually need any memory ordering here, but _acq is the
- weakest available. */
- (void ) atomic_compare_and_exchange_bool_acq (&map->l_tls_offset,
- offset,
- NO_TLS_OFFSET);
- val = map->l_tls_offset;
- assert (val != NO_TLS_OFFSET);
- }
- if (val != offset)
- {
- /* We'd like to set a static offset for this section, but another
- thread has already used a dynamic TLS block for it. Since we can
- only use static offsets if everyone does (and it's not practical
- to move that thread's dynamic block), we have to fail. */
- goto fail;
- }
- /* We installed the value; now update the globals. */
-#if TLS_TCB_AT_TP
- GL(dl_tls_static_used) = offset;
-#elif TLS_DTV_AT_TP
+ map->l_tls_offset = offset;
map->l_tls_firstbyte_offset = GL(dl_tls_static_used);
GL(dl_tls_static_used) = used;
#else
}
void
-internal_function __attribute_noinline__
+__attribute_noinline__
_dl_allocate_static_tls (struct link_map *map)
{
- /* We wrap this in a signal mask because it has to iterate all threads
- (including this one) and update this map's TLS entry. A signal handler
- accessing TLS would try to do the same update and break. */
- sigset_t old;
- _dl_mask_all_signals (&old);
- int err = -1;
- if (map->l_tls_offset != FORCED_DYNAMIC_TLS_OFFSET)
- err = _dl_try_allocate_static_tls (map);
-
- _dl_unmask_signals (&old);
- if (err != 0)
+ if (map->l_tls_offset == FORCED_DYNAMIC_TLS_OFFSET
+ || _dl_try_allocate_static_tls (map))
{
_dl_signal_error (0, map->l_name, NULL, N_("\
cannot allocate memory in static TLS block"));
# error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
#endif
- /* Fill in the DTV slot so that a later LD/GD access will find it. */
- dtv_t *dtv = THREAD_DTV ();
- assert (map->l_tls_modid <= dtv[-1].counter);
- dtv[map->l_tls_modid].pointer.val = dest;
- dtv[map->l_tls_modid].pointer.is_static = true;
-
/* Initialize the memory. */
memset (__mempcpy (dest, map->l_tls_initimage, map->l_tls_initimage_size),
'\0', map->l_tls_blocksize - map->l_tls_initimage_size);
&& __builtin_expect (l->l_info[DT_BIND_NOW] != NULL, 0))
lazy = 0;
- if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_RELOC, 0))
+ if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_RELOC))
_dl_debug_printf ("\nrelocation processing: %s%s\n",
DSO_FILENAME (l->l_name), lazy ? " (lazy)" : "");
/* DT_TEXTREL is now in level 2 and might phase out at some time.
But we rewrite the DT_FLAGS entry to a DT_TEXTREL entry to make
testing easier and therefore it will be available at all time. */
- if (__builtin_expect (l->l_info[DT_TEXTREL] != NULL, 0))
+ if (__glibc_unlikely (l->l_info[DT_TEXTREL] != NULL))
{
/* Bletch. We must make read-only segments writable
long enough to relocate them. */
struct textrels *newp;
newp = (struct textrels *) alloca (sizeof (*newp));
- newp->len = (((ph->p_vaddr + ph->p_memsz + GLRO(dl_pagesize) - 1)
- & ~(GLRO(dl_pagesize) - 1))
- - (ph->p_vaddr & ~(GLRO(dl_pagesize) - 1)));
- newp->start = ((ph->p_vaddr & ~(GLRO(dl_pagesize) - 1))
- + (caddr_t) l->l_addr);
+ newp->len = ALIGN_UP (ph->p_vaddr + ph->p_memsz, GLRO(dl_pagesize))
+ - ALIGN_DOWN (ph->p_vaddr, GLRO(dl_pagesize));
+ newp->start = PTR_ALIGN_DOWN (ph->p_vaddr, GLRO(dl_pagesize))
+ + (caddr_t) l->l_addr;
- if (__mprotect (newp->start, newp->len, PROT_READ|PROT_WRITE) < 0)
- {
- errstring = N_("cannot make segment writable for relocation");
- call_error:
- _dl_signal_error (errno, l->l_name, NULL, errstring);
- }
-
-#if (PF_R | PF_W | PF_X) == 7 && (PROT_READ | PROT_WRITE | PROT_EXEC) == 7
- newp->prot = (PF_TO_PROT
- >> ((ph->p_flags & (PF_R | PF_W | PF_X)) * 4)) & 0xf;
-#else
newp->prot = 0;
if (ph->p_flags & PF_R)
newp->prot |= PROT_READ;
newp->prot |= PROT_WRITE;
if (ph->p_flags & PF_X)
newp->prot |= PROT_EXEC;
-#endif
+
+ if (__mprotect (newp->start, newp->len, newp->prot|PROT_WRITE) < 0)
+ {
+ errstring = N_("cannot make segment writable for relocation");
+ call_error:
+ _dl_signal_error (errno, l->l_name, NULL, errstring);
+ }
+
newp->next = textrels;
textrels = newp;
}
/* This macro is used as a callback from the ELF_DYNAMIC_RELOCATE code. */
#define RESOLVE_MAP(ref, version, r_type) \
- (ELFW(ST_BIND) ((*ref)->st_info) != STB_LOCAL \
+ ((ELFW(ST_BIND) ((*ref)->st_info) != STB_LOCAL \
+ && __glibc_likely (!dl_symbol_visibility_binds_local_p (*ref))) \
? ((__builtin_expect ((*ref) == l->l_lookup_cache.sym, 0) \
&& elf_machine_type_class (r_type) == l->l_lookup_cache.type_class) \
? (bump_num_cache_relocations (), \
ELF_DYNAMIC_RELOCATE (l, lazy, consider_profiling, skip_ifunc);
#ifndef PROF
- if (__builtin_expect (consider_profiling, 0))
+ if (__glibc_unlikely (consider_profiling)
+ && l->l_info[DT_PLTRELSZ] != NULL)
{
/* Allocate the array which will contain the already found
relocations. If the shared object lacks a PLT (for example
if it only contains lead function) the l_info[DT_PLTRELSZ]
will be NULL. */
- if (l->l_info[DT_PLTRELSZ] == NULL)
- {
- errstring = N_("%s: no PLTREL found in object %s\n");
- fatal:
- _dl_fatal_printf (errstring,
- RTLD_PROGNAME,
- l->l_name);
- }
+ size_t sizeofrel = l->l_info[DT_PLTREL]->d_un.d_val == DT_RELA
+ ? sizeof (ElfW(Rela))
+ : sizeof (ElfW(Rel));
+ size_t relcount = l->l_info[DT_PLTRELSZ]->d_un.d_val / sizeofrel;
+ l->l_reloc_result = calloc (sizeof (l->l_reloc_result[0]), relcount);
- l->l_reloc_result = calloc (sizeof (l->l_reloc_result[0]),
- l->l_info[DT_PLTRELSZ]->d_un.d_val);
if (l->l_reloc_result == NULL)
{
errstring = N_("\
%s: out of memory to store relocation results for %s\n");
- goto fatal;
+ _dl_fatal_printf (errstring, RTLD_PROGNAME, l->l_name);
}
}
#endif
}
-void internal_function
+void
_dl_protect_relro (struct link_map *l)
{
- ElfW(Addr) start = ((l->l_addr + l->l_relro_addr)
- & ~(GLRO(dl_pagesize) - 1));
- ElfW(Addr) end = ((l->l_addr + l->l_relro_addr + l->l_relro_size)
- & ~(GLRO(dl_pagesize) - 1));
-
+ ElfW(Addr) start = ALIGN_DOWN((l->l_addr
+ + l->l_relro_addr),
+ GLRO(dl_pagesize));
+ ElfW(Addr) end = ALIGN_DOWN((l->l_addr
+ + l->l_relro_addr
+ + l->l_relro_size),
+ GLRO(dl_pagesize));
if (start != end
&& __mprotect ((void *) start, end - start, PROT_READ) < 0)
{
}
void
-internal_function __attribute_noinline__
+__attribute_noinline__
_dl_reloc_bad_type (struct link_map *map, unsigned int type, int plt)
{
#define DIGIT(b) _itoa_lower_digits[(b) & 0xf];