mirror of
https://sourceware.org/git/glibc.git
synced 2024-11-22 21:10:07 +00:00
ff08fc59e3
Drop _dl_hwcap_mask when building with tunables. This completes the transition of hwcap_mask reading from _dl_hwcap_mask to tunables. * elf/dl-hwcaps.h: New file. * elf/dl-hwcaps.c: Include it. (_dl_important_hwcaps)[HAVE_TUNABLES]: Read and update glibc.tune.hwcap_mask. * elf/dl-cache.c: Include dl-hwcaps.h. (_dl_load_cache_lookup)[HAVE_TUNABLES]: Read glibc.tune.hwcap_mask. * sysdeps/sparc/sparc32/dl-machine.h: Likewise. * elf/dl-support.c (_dl_hwcap2)[HAVE_TUNABLES]: Drop _dl_hwcap_mask. * elf/rtld.c (rtld_global_ro)[HAVE_TUNABLES]: Drop _dl_hwcap_mask. (process_envvars)[HAVE_TUNABLES]: Likewise. * sysdeps/generic/ldsodefs.h (rtld_global_ro)[HAVE_TUNABLES]: Likewise. * sysdeps/x86/cpu-features.c (init_cpu_features): Don't initialize dl_hwcap_mask when tunables are enabled.
326 lines
10 KiB
C
326 lines
10 KiB
C
/* Support for reading /etc/ld.so.cache files written by Linux ldconfig.
|
|
Copyright (C) 1996-2017 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
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
#include <assert.h>
|
|
#include <unistd.h>
|
|
#include <ldsodefs.h>
|
|
#include <sys/mman.h>
|
|
#include <dl-cache.h>
|
|
#include <dl-procinfo.h>
|
|
#include <stdint.h>
|
|
#include <_itoa.h>
|
|
#include <dl-hwcaps.h>
|
|
|
|
#ifndef _DL_PLATFORMS_COUNT
|
|
# define _DL_PLATFORMS_COUNT 0
|
|
#endif
|
|
|
|
/* This is the starting address and the size of the mmap()ed file. */
|
|
static struct cache_file *cache;
|
|
static struct cache_file_new *cache_new;
|
|
static size_t cachesize;
|
|
|
|
/* 1 if cache_data + PTR points into the cache. */
|
|
#define _dl_cache_verify_ptr(ptr) (ptr < cache_data_size)
|
|
|
|
#define SEARCH_CACHE(cache) \
|
|
/* We use binary search since the table is sorted in the cache file. \
|
|
The first matching entry in the table is returned. \
|
|
It is important to use the same algorithm as used while generating \
|
|
the cache file. */ \
|
|
do \
|
|
{ \
|
|
left = 0; \
|
|
right = cache->nlibs - 1; \
|
|
\
|
|
while (left <= right) \
|
|
{ \
|
|
__typeof__ (cache->libs[0].key) key; \
|
|
\
|
|
middle = (left + right) / 2; \
|
|
\
|
|
key = cache->libs[middle].key; \
|
|
\
|
|
/* Make sure string table indices are not bogus before using \
|
|
them. */ \
|
|
if (! _dl_cache_verify_ptr (key)) \
|
|
{ \
|
|
cmpres = 1; \
|
|
break; \
|
|
} \
|
|
\
|
|
/* Actually compare the entry with the key. */ \
|
|
cmpres = _dl_cache_libcmp (name, cache_data + key); \
|
|
if (__glibc_unlikely (cmpres == 0)) \
|
|
{ \
|
|
/* Found it. LEFT now marks the last entry for which we \
|
|
know the name is correct. */ \
|
|
left = middle; \
|
|
\
|
|
/* There might be entries with this name before the one we \
|
|
found. So we have to find the beginning. */ \
|
|
while (middle > 0) \
|
|
{ \
|
|
__typeof__ (cache->libs[0].key) key; \
|
|
\
|
|
key = cache->libs[middle - 1].key; \
|
|
/* Make sure string table indices are not bogus before \
|
|
using them. */ \
|
|
if (! _dl_cache_verify_ptr (key) \
|
|
/* Actually compare the entry. */ \
|
|
|| _dl_cache_libcmp (name, cache_data + key) != 0) \
|
|
break; \
|
|
--middle; \
|
|
} \
|
|
\
|
|
do \
|
|
{ \
|
|
int flags; \
|
|
__typeof__ (cache->libs[0]) *lib = &cache->libs[middle]; \
|
|
\
|
|
/* Only perform the name test if necessary. */ \
|
|
if (middle > left \
|
|
/* We haven't seen this string so far. Test whether the \
|
|
index is ok and whether the name matches. Otherwise \
|
|
we are done. */ \
|
|
&& (! _dl_cache_verify_ptr (lib->key) \
|
|
|| (_dl_cache_libcmp (name, cache_data + lib->key) \
|
|
!= 0))) \
|
|
break; \
|
|
\
|
|
flags = lib->flags; \
|
|
if (_dl_cache_check_flags (flags) \
|
|
&& _dl_cache_verify_ptr (lib->value)) \
|
|
{ \
|
|
if (best == NULL || flags == GLRO(dl_correct_cache_id)) \
|
|
{ \
|
|
HWCAP_CHECK; \
|
|
best = cache_data + lib->value; \
|
|
\
|
|
if (flags == GLRO(dl_correct_cache_id)) \
|
|
/* We've found an exact match for the shared \
|
|
object and no general `ELF' release. Stop \
|
|
searching. */ \
|
|
break; \
|
|
} \
|
|
} \
|
|
} \
|
|
while (++middle <= right); \
|
|
break; \
|
|
} \
|
|
\
|
|
if (cmpres < 0) \
|
|
left = middle + 1; \
|
|
else \
|
|
right = middle - 1; \
|
|
} \
|
|
} \
|
|
while (0)
|
|
|
|
|
|
int
|
|
internal_function
|
|
_dl_cache_libcmp (const char *p1, const char *p2)
|
|
{
|
|
while (*p1 != '\0')
|
|
{
|
|
if (*p1 >= '0' && *p1 <= '9')
|
|
{
|
|
if (*p2 >= '0' && *p2 <= '9')
|
|
{
|
|
/* Must compare this numerically. */
|
|
int val1;
|
|
int val2;
|
|
|
|
val1 = *p1++ - '0';
|
|
val2 = *p2++ - '0';
|
|
while (*p1 >= '0' && *p1 <= '9')
|
|
val1 = val1 * 10 + *p1++ - '0';
|
|
while (*p2 >= '0' && *p2 <= '9')
|
|
val2 = val2 * 10 + *p2++ - '0';
|
|
if (val1 != val2)
|
|
return val1 - val2;
|
|
}
|
|
else
|
|
return 1;
|
|
}
|
|
else if (*p2 >= '0' && *p2 <= '9')
|
|
return -1;
|
|
else if (*p1 != *p2)
|
|
return *p1 - *p2;
|
|
else
|
|
{
|
|
++p1;
|
|
++p2;
|
|
}
|
|
}
|
|
return *p1 - *p2;
|
|
}
|
|
|
|
|
|
/* Look up NAME in ld.so.cache and return the file name stored there, or null
|
|
if none is found. The cache is loaded if it was not already. If loading
|
|
the cache previously failed there will be no more attempts to load it.
|
|
The caller is responsible for freeing the returned string. The ld.so.cache
|
|
may be unmapped at any time by a completing recursive dlopen and
|
|
this function must take care that it does not return references to
|
|
any data in the mapping. */
|
|
char *
|
|
internal_function
|
|
_dl_load_cache_lookup (const char *name)
|
|
{
|
|
int left, right, middle;
|
|
int cmpres;
|
|
const char *cache_data;
|
|
uint32_t cache_data_size;
|
|
const char *best;
|
|
|
|
/* Print a message if the loading of libs is traced. */
|
|
if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_LIBS))
|
|
_dl_debug_printf (" search cache=%s\n", LD_SO_CACHE);
|
|
|
|
if (cache == NULL)
|
|
{
|
|
/* Read the contents of the file. */
|
|
void *file = _dl_sysdep_read_whole_file (LD_SO_CACHE, &cachesize,
|
|
PROT_READ);
|
|
|
|
/* We can handle three different cache file formats here:
|
|
- the old libc5/glibc2.0/2.1 format
|
|
- the old format with the new format in it
|
|
- only the new format
|
|
The following checks if the cache contains any of these formats. */
|
|
if (file != MAP_FAILED && cachesize > sizeof *cache
|
|
&& memcmp (file, CACHEMAGIC, sizeof CACHEMAGIC - 1) == 0)
|
|
{
|
|
size_t offset;
|
|
/* Looks ok. */
|
|
cache = file;
|
|
|
|
/* Check for new version. */
|
|
offset = ALIGN_CACHE (sizeof (struct cache_file)
|
|
+ cache->nlibs * sizeof (struct file_entry));
|
|
|
|
cache_new = (struct cache_file_new *) ((void *) cache + offset);
|
|
if (cachesize < (offset + sizeof (struct cache_file_new))
|
|
|| memcmp (cache_new->magic, CACHEMAGIC_VERSION_NEW,
|
|
sizeof CACHEMAGIC_VERSION_NEW - 1) != 0)
|
|
cache_new = (void *) -1;
|
|
}
|
|
else if (file != MAP_FAILED && cachesize > sizeof *cache_new
|
|
&& memcmp (file, CACHEMAGIC_VERSION_NEW,
|
|
sizeof CACHEMAGIC_VERSION_NEW - 1) == 0)
|
|
{
|
|
cache_new = file;
|
|
cache = file;
|
|
}
|
|
else
|
|
{
|
|
if (file != MAP_FAILED)
|
|
__munmap (file, cachesize);
|
|
cache = (void *) -1;
|
|
}
|
|
|
|
assert (cache != NULL);
|
|
}
|
|
|
|
if (cache == (void *) -1)
|
|
/* Previously looked for the cache file and didn't find it. */
|
|
return NULL;
|
|
|
|
best = NULL;
|
|
|
|
if (cache_new != (void *) -1)
|
|
{
|
|
uint64_t platform;
|
|
|
|
/* This is where the strings start. */
|
|
cache_data = (const char *) cache_new;
|
|
|
|
/* Now we can compute how large the string table is. */
|
|
cache_data_size = (const char *) cache + cachesize - cache_data;
|
|
|
|
platform = _dl_string_platform (GLRO(dl_platform));
|
|
if (platform != (uint64_t) -1)
|
|
platform = 1ULL << platform;
|
|
|
|
uint64_t hwcap_mask = GET_HWCAP_MASK();
|
|
|
|
#define _DL_HWCAP_TLS_MASK (1LL << 63)
|
|
uint64_t hwcap_exclude = ~((GLRO(dl_hwcap) & hwcap_mask)
|
|
| _DL_HWCAP_PLATFORM | _DL_HWCAP_TLS_MASK);
|
|
|
|
/* Only accept hwcap if it's for the right platform. */
|
|
#define HWCAP_CHECK \
|
|
if (lib->hwcap & hwcap_exclude) \
|
|
continue; \
|
|
if (GLRO(dl_osversion) && lib->osversion > GLRO(dl_osversion)) \
|
|
continue; \
|
|
if (_DL_PLATFORMS_COUNT \
|
|
&& (lib->hwcap & _DL_HWCAP_PLATFORM) != 0 \
|
|
&& (lib->hwcap & _DL_HWCAP_PLATFORM) != platform) \
|
|
continue
|
|
SEARCH_CACHE (cache_new);
|
|
}
|
|
else
|
|
{
|
|
/* This is where the strings start. */
|
|
cache_data = (const char *) &cache->libs[cache->nlibs];
|
|
|
|
/* Now we can compute how large the string table is. */
|
|
cache_data_size = (const char *) cache + cachesize - cache_data;
|
|
|
|
#undef HWCAP_CHECK
|
|
#define HWCAP_CHECK do {} while (0)
|
|
SEARCH_CACHE (cache);
|
|
}
|
|
|
|
/* Print our result if wanted. */
|
|
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_LIBS, 0)
|
|
&& best != NULL)
|
|
_dl_debug_printf (" trying file=%s\n", best);
|
|
|
|
if (best == NULL)
|
|
return NULL;
|
|
|
|
/* The double copy is *required* since malloc may be interposed
|
|
and call dlopen itself whose completion would unmap the data
|
|
we are accessing. Therefore we must make the copy of the
|
|
mapping data without using malloc. */
|
|
char *temp;
|
|
temp = alloca (strlen (best) + 1);
|
|
strcpy (temp, best);
|
|
return __strdup (temp);
|
|
}
|
|
|
|
#ifndef MAP_COPY
|
|
/* If the system does not support MAP_COPY we cannot leave the file open
|
|
all the time since this would create problems when the file is replaced.
|
|
Therefore we provide this function to close the file and open it again
|
|
once needed. */
|
|
void
|
|
_dl_unload_cache (void)
|
|
{
|
|
if (cache != NULL && cache != (struct cache_file *) -1)
|
|
{
|
|
__munmap (cache, cachesize);
|
|
cache = NULL;
|
|
}
|
|
}
|
|
#endif
|