elf/dl-cache.c

   1 /* Support for reading /etc/ld.so.cache files written by Linux ldconfig.
   2    Copyright (C) 1996-2017 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <http://www.gnu.org/licenses/>.  */
  18
  19 #include <assert.h>
  20 #include <unistd.h>
  21 #include <ldsodefs.h>
  22 #include <sys/mman.h>
  23 #include <dl-cache.h>
  24 #include <dl-procinfo.h>
  25 #include <stdint.h>
  26 #include <_itoa.h>
  27 #include <dl-hwcaps.h>
  28
  29 #ifndef _DL_PLATFORMS_COUNT
  30 # define _DL_PLATFORMS_COUNT 0
  31 #endif
  32
  33 /* This is the starting address and the size of the mmap()ed file.  */
  34 static struct cache_file *cache;
  35 static struct cache_file_new *cache_new;
  36 static size_t cachesize;
  37
  38 /* 1 if cache_data + PTR points into the cache.  */
  39 #define _dl_cache_verify_ptr(ptr) (ptr < cache_data_size)
  40
  41 #define SEARCH_CACHE(cache) \
  42 /* We use binary search since the table is sorted in the cache file.          \
  43    The first matching entry in the table is returned.                         \
  44    It is important to use the same algorithm as used while generating         \
  45    the cache file.  */                                                        \
  46 do                                                                            \
  47   {                                                                           \
  48     left = 0;                                                                 \
  49     right = cache->nlibs - 1;                                                 \
  50                                                                               \
  51     while (left <= right)                                                     \
  52       {                                                                       \
  53         __typeof__ (cache->libs[0].key) key;                                  \
  54                                                                               \
  55         middle = (left + right) / 2;                                          \
  56                                                                               \
  57         key = cache->libs[middle].key;                                        \
  58                                                                               \
  59         /* Make sure string table indices are not bogus before using          \
  60            them.  */                                                          \
  61         if (! _dl_cache_verify_ptr (key))                                     \
  62           {                                                                   \
  63             cmpres = 1;                                                       \
  64             break;                                                            \
  65           }                                                                   \
  66                                                                               \
  67         /* Actually compare the entry with the key.  */                       \
  68         cmpres = _dl_cache_libcmp (name, cache_data + key);                   \
  69         if (__glibc_unlikely (cmpres == 0))                                   \
  70           {                                                                   \
  71             /* Found it.  LEFT now marks the last entry for which we          \
  72                know the name is correct.  */                                  \
  73             left = middle;                                                    \
  74                                                                               \
  75             /* There might be entries with this name before the one we        \
  76                found.  So we have to find the beginning.  */                  \
  77             while (middle > 0)                                                \
  78               {                                                               \
  79                 __typeof__ (cache->libs[0].key) key;                          \
  80                                                                               \
  81                 key = cache->libs[middle - 1].key;                            \
  82                 /* Make sure string table indices are not bogus before        \
  83                    using them.  */                                            \
  84                 if (! _dl_cache_verify_ptr (key)                              \
  85                     /* Actually compare the entry.  */                        \
  86                     || _dl_cache_libcmp (name, cache_data + key) != 0)        \
  87                   break;                                                      \
  88                 --middle;                                                     \
  89               }                                                               \
  90                                                                               \
  91             do                                                                \
  92               {                                                               \
  93                 int flags;                                                    \
  94                 __typeof__ (cache->libs[0]) *lib = &cache->libs[middle];      \
  95                                                                               \
  96                 /* Only perform the name test if necessary.  */               \
  97                 if (middle > left                                             \
  98                     /* We haven't seen this string so far.  Test whether the  \
  99                        index is ok and whether the name matches.  Otherwise   \
 100                        we are done.  */                                       \
 101                     && (! _dl_cache_verify_ptr (lib->key)                     \
 102                         || (_dl_cache_libcmp (name, cache_data + lib->key)    \
 103                             != 0)))                                           \
 104                   break;                                                      \
 105                                                                               \
 106                 flags = lib->flags;                                           \
 107                 if (_dl_cache_check_flags (flags)                             \
 108                     && _dl_cache_verify_ptr (lib->value))                     \
 109                   {                                                           \
 110                     if (best == NULL || flags == GLRO(dl_correct_cache_id))   \
 111                       {                                                       \
 112                         HWCAP_CHECK;                                          \
 113                         best = cache_data + lib->value;                       \
 114                                                                               \
 115                         if (flags == GLRO(dl_correct_cache_id))               \
 116                           /* We've found an exact match for the shared        \
 117                              object and no general `ELF' release.  Stop       \
 118                              searching.  */                                   \
 119                           break;                                              \
 120                       }                                                       \
 121                   }                                                           \
 122               }                                                               \
 123             while (++middle <= right);                                        \
 124             break;                                                            \
 125         }                                                                     \
 126                                                                               \
 127         if (cmpres < 0)                                                       \
 128           left = middle + 1;                                                  \
 129         else                                                                  \
 130           right = middle - 1;                                                 \
 131       }                                                                       \
 132   }                                                                           \
 133 while (0)
 134
 135
 136 int
 137 internal_function
 138 _dl_cache_libcmp (const char *p1, const char *p2)
 139 {
 140   while (*p1 != '\0')
 141     {
 142       if (*p1 >= '0' && *p1 <= '9')
 143         {
 144           if (*p2 >= '0' && *p2 <= '9')
 145             {
 146               /* Must compare this numerically.  */
 147               int val1;
 148               int val2;
 149
 150               val1 = *p1++ - '0';
 151               val2 = *p2++ - '0';
 152               while (*p1 >= '0' && *p1 <= '9')
 153                 val1 = val1 * 10 + *p1++ - '0';
 154               while (*p2 >= '0' && *p2 <= '9')
 155                 val2 = val2 * 10 + *p2++ - '0';
 156               if (val1 != val2)
 157                 return val1 - val2;
 158             }
 159           else
 160             return 1;
 161         }
 162       else if (*p2 >= '0' && *p2 <= '9')
 163         return -1;
 164       else if (*p1 != *p2)
 165         return *p1 - *p2;
 166       else
 167         {
 168           ++p1;
 169           ++p2;
 170         }
 171     }
 172   return *p1 - *p2;
 173 }
 174
 175
 176 /* Look up NAME in ld.so.cache and return the file name stored there, or null
 177    if none is found.  The cache is loaded if it was not already.  If loading
 178    the cache previously failed there will be no more attempts to load it.
 179    The caller is responsible for freeing the returned string.  The ld.so.cache
 180    may be unmapped at any time by a completing recursive dlopen and
 181    this function must take care that it does not return references to
 182    any data in the mapping.  */
 183 char *
 184 internal_function
 185 _dl_load_cache_lookup (const char *name)
 186 {
 187   int left, right, middle;
 188   int cmpres;
 189   const char *cache_data;
 190   uint32_t cache_data_size;
 191   const char *best;
 192
 193   /* Print a message if the loading of libs is traced.  */
 194   if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_LIBS))
 195     _dl_debug_printf (" search cache=%s\n", LD_SO_CACHE);
 196
 197   if (cache == NULL)
 198     {
 199       /* Read the contents of the file.  */
 200       void *file = _dl_sysdep_read_whole_file (LD_SO_CACHE, &cachesize,
 201                                                PROT_READ);
 202
 203       /* We can handle three different cache file formats here:
 204          - the old libc5/glibc2.0/2.1 format
 205          - the old format with the new format in it
 206          - only the new format
 207          The following checks if the cache contains any of these formats.  */
 208       if (file != MAP_FAILED && cachesize > sizeof *cache
 209           && memcmp (file, CACHEMAGIC, sizeof CACHEMAGIC - 1) == 0)
 210         {
 211           size_t offset;
 212           /* Looks ok.  */
 213           cache = file;
 214
 215           /* Check for new version.  */
 216           offset = ALIGN_CACHE (sizeof (struct cache_file)
 217                                 + cache->nlibs * sizeof (struct file_entry));
 218
 219           cache_new = (struct cache_file_new *) ((void *) cache + offset);
 220           if (cachesize < (offset + sizeof (struct cache_file_new))
 221               || memcmp (cache_new->magic, CACHEMAGIC_VERSION_NEW,
 222                          sizeof CACHEMAGIC_VERSION_NEW - 1) != 0)
 223             cache_new = (void *) -1;
 224         }
 225       else if (file != MAP_FAILED && cachesize > sizeof *cache_new
 226                && memcmp (file, CACHEMAGIC_VERSION_NEW,
 227                           sizeof CACHEMAGIC_VERSION_NEW - 1) == 0)
 228         {
 229           cache_new = file;
 230           cache = file;
 231         }
 232       else
 233         {
 234           if (file != MAP_FAILED)
 235             __munmap (file, cachesize);
 236           cache = (void *) -1;
 237         }
 238
 239       assert (cache != NULL);
 240     }
 241
 242   if (cache == (void *) -1)
 243     /* Previously looked for the cache file and didn't find it.  */
 244     return NULL;
 245
 246   best = NULL;
 247
 248   if (cache_new != (void *) -1)
 249     {
 250       uint64_t platform;
 251
 252       /* This is where the strings start.  */
 253       cache_data = (const char *) cache_new;
 254
 255       /* Now we can compute how large the string table is.  */
 256       cache_data_size = (const char *) cache + cachesize - cache_data;
 257
 258       platform = _dl_string_platform (GLRO(dl_platform));
 259       if (platform != (uint64_t) -1)
 260         platform = 1ULL << platform;
 261
 262       uint64_t hwcap_mask = GET_HWCAP_MASK();
 263
 264 #define _DL_HWCAP_TLS_MASK (1LL << 63)
 265       uint64_t hwcap_exclude = ~((GLRO(dl_hwcap) & hwcap_mask)
 266                                  | _DL_HWCAP_PLATFORM | _DL_HWCAP_TLS_MASK);
 267
 268       /* Only accept hwcap if it's for the right platform.  */
 269 #define HWCAP_CHECK \
 270       if (lib->hwcap & hwcap_exclude)                                         \
 271         continue;                                                             \
 272       if (GLRO(dl_osversion) && lib->osversion > GLRO(dl_osversion))          \
 273         continue;                                                             \
 274       if (_DL_PLATFORMS_COUNT                                                 \
 275           && (lib->hwcap & _DL_HWCAP_PLATFORM) != 0                           \
 276           && (lib->hwcap & _DL_HWCAP_PLATFORM) != platform)                   \
 277         continue
 278       SEARCH_CACHE (cache_new);
 279     }
 280   else
 281     {
 282       /* This is where the strings start.  */
 283       cache_data = (const char *) &cache->libs[cache->nlibs];
 284
 285       /* Now we can compute how large the string table is.  */
 286       cache_data_size = (const char *) cache + cachesize - cache_data;
 287
 288 #undef HWCAP_CHECK
 289 #define HWCAP_CHECK do {} while (0)
 290       SEARCH_CACHE (cache);
 291     }
 292
 293   /* Print our result if wanted.  */
 294   if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_LIBS, 0)
 295       && best != NULL)
 296     _dl_debug_printf ("  trying file=%s\n", best);
 297
 298   if (best == NULL)
 299     return NULL;
 300
 301   /* The double copy is *required* since malloc may be interposed
 302      and call dlopen itself whose completion would unmap the data
 303      we are accessing. Therefore we must make the copy of the
 304      mapping data without using malloc.  */
 305   char *temp;
 306   temp = alloca (strlen (best) + 1);
 307   strcpy (temp, best);
 308   return __strdup (temp);
 309 }
 310
 311 #ifndef MAP_COPY
 312 /* If the system does not support MAP_COPY we cannot leave the file open
 313    all the time since this would create problems when the file is replaced.
 314    Therefore we provide this function to close the file and open it again
 315    once needed.  */
 316 void
 317 _dl_unload_cache (void)
 318 {
 319   if (cache != NULL && cache != (struct cache_file *) -1)
 320     {
 321       __munmap (cache, cachesize);
 322       cache = NULL;
 323     }
 324 }
 325 #endif