elf/dl-cache.c

   1 /* Support for reading /etc/ld.so.cache files written by Linux ldconfig.
   2    Copyright (C) 1996-2021 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    <https://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 #include <dl-isa-level.h>
  29
  30 #ifndef _DL_PLATFORMS_COUNT
  31 # define _DL_PLATFORMS_COUNT 0
  32 #endif
  33
  34 /* This is the starting address and the size of the mmap()ed file.  */
  35 static struct cache_file *cache;
  36 static struct cache_file_new *cache_new;
  37 static size_t cachesize;
  38
  39 #ifdef SHARED
  40 /* This is used to cache the priorities of glibc-hwcaps
  41    subdirectories.  The elements of _dl_cache_priorities correspond to
  42    the strings in the cache_extension_tag_glibc_hwcaps section.  */
  43 static uint32_t *glibc_hwcaps_priorities;
  44 static uint32_t glibc_hwcaps_priorities_length;
  45 static uint32_t glibc_hwcaps_priorities_allocated;
  46
  47 /* True if the full malloc was used to allocated the array.  */
  48 static bool glibc_hwcaps_priorities_malloced;
  49
  50 /* Deallocate the glibc_hwcaps_priorities array.  */
  51 static void
  52 glibc_hwcaps_priorities_free (void)
  53 {
  54   /* When the minimal malloc is in use, free does not do anything,
  55      so it does not make sense to call it.  */
  56   if (glibc_hwcaps_priorities_malloced)
  57     free (glibc_hwcaps_priorities);
  58   glibc_hwcaps_priorities = NULL;
  59   glibc_hwcaps_priorities_allocated = 0;
  60 }
  61
  62 /* Ordered comparison of a hwcaps string from the cache on the left
  63    (identified by its string table index) and a _dl_hwcaps_priorities
  64    element on the right.  */
  65 static int
  66 glibc_hwcaps_compare (uint32_t left_index, struct dl_hwcaps_priority *right)
  67 {
  68   const char *left_name = (const char *) cache + left_index;
  69   uint32_t left_name_length = strlen (left_name);
  70   uint32_t to_compare;
  71   if (left_name_length < right->name_length)
  72     to_compare = left_name_length;
  73   else
  74     to_compare = right->name_length;
  75   int cmp = memcmp (left_name, right->name, to_compare);
  76   if (cmp != 0)
  77     return cmp;
  78   if (left_name_length < right->name_length)
  79     return -1;
  80   else if (left_name_length > right->name_length)
  81     return 1;
  82   else
  83     return 0;
  84 }
  85
  86 /* Initialize the glibc_hwcaps_priorities array and its length,
  87    glibc_hwcaps_priorities_length.  */
  88 static void
  89 glibc_hwcaps_priorities_init (void)
  90 {
  91   struct cache_extension_all_loaded ext;
  92   if (!cache_extension_load (cache_new, cache, cachesize, &ext))
  93     return;
  94
  95   uint32_t length = (ext.sections[cache_extension_tag_glibc_hwcaps].size
  96                      / sizeof (uint32_t));
  97   if (length > glibc_hwcaps_priorities_allocated)
  98     {
  99       glibc_hwcaps_priorities_free ();
 100
 101       uint32_t *new_allocation = malloc (length * sizeof (uint32_t));
 102       if (new_allocation == NULL)
 103         /* This effectively disables hwcaps on memory allocation
 104            errors.  */
 105         return;
 106
 107       glibc_hwcaps_priorities = new_allocation;
 108       glibc_hwcaps_priorities_allocated = length;
 109       glibc_hwcaps_priorities_malloced = __rtld_malloc_is_complete ();
 110     }
 111
 112   /* Compute the priorities for the subdirectories by merging the
 113      array in the cache with the dl_hwcaps_priorities array.  */
 114   const uint32_t *left = ext.sections[cache_extension_tag_glibc_hwcaps].base;
 115   const uint32_t *left_end = left + length;
 116   struct dl_hwcaps_priority *right = _dl_hwcaps_priorities;
 117   struct dl_hwcaps_priority *right_end = right + _dl_hwcaps_priorities_length;
 118   uint32_t *result = glibc_hwcaps_priorities;
 119
 120   while (left < left_end && right < right_end)
 121     {
 122       if (*left < cachesize)
 123         {
 124           int cmp = glibc_hwcaps_compare (*left, right);
 125           if (cmp == 0)
 126             {
 127               *result = right->priority;
 128               ++result;
 129               ++left;
 130               ++right;
 131             }
 132           else if (cmp < 0)
 133             {
 134               *result = 0;
 135               ++result;
 136               ++left;
 137             }
 138           else
 139             ++right;
 140         }
 141       else
 142         {
 143           *result = 0;
 144           ++result;
 145         }
 146     }
 147   while (left < left_end)
 148     {
 149       *result = 0;
 150       ++result;
 151       ++left;
 152     }
 153
 154   glibc_hwcaps_priorities_length = length;
 155 }
 156
 157 /* Return the priority of the cache_extension_tag_glibc_hwcaps section
 158    entry at INDEX.  Zero means do not use.  Otherwise, lower values
 159    indicate greater preference.  */
 160 static uint32_t
 161 glibc_hwcaps_priority (uint32_t index)
 162 {
 163   /* This does not need to repeated initialization attempts because
 164      this function is only called if there is glibc-hwcaps data in the
 165      cache, so the first call initializes the glibc_hwcaps_priorities
 166      array.  */
 167   if (glibc_hwcaps_priorities_length == 0)
 168     glibc_hwcaps_priorities_init ();
 169
 170   if (index < glibc_hwcaps_priorities_length)
 171     return glibc_hwcaps_priorities[index];
 172   else
 173     return 0;
 174 }
 175 #endif /* SHARED */
 176
 177 /* True if PTR is a valid string table index.  */
 178 static inline bool
 179 _dl_cache_verify_ptr (uint32_t ptr, size_t string_table_size)
 180 {
 181   return ptr < string_table_size;
 182 }
 183
 184 /* Compute the address of the element INDEX of the array at LIBS.
 185    Conceptually, this is &LIBS[INDEX], but use ENTRY_SIZE for the size
 186    of *LIBS.  */
 187 static inline const struct file_entry *
 188 _dl_cache_file_entry (const struct file_entry *libs, size_t entry_size,
 189                       size_t index)
 190 {
 191   return (const void *) libs + index * entry_size;
 192 }
 193
 194 /* We use binary search since the table is sorted in the cache file.
 195    The first matching entry in the table is returned.  It is important
 196    to use the same algorithm as used while generating the cache file.
 197    STRING_TABLE_SIZE indicates the maximum offset in STRING_TABLE at
 198    which data is mapped; it is not exact.  */
 199 static const char *
 200 search_cache (const char *string_table, uint32_t string_table_size,
 201               struct file_entry *libs, uint32_t nlibs, uint32_t entry_size,
 202               const char *name)
 203 {
 204   /* Used by the HWCAP check in the struct file_entry_new case.  */
 205   uint64_t platform = _dl_string_platform (GLRO (dl_platform));
 206   if (platform != (uint64_t) -1)
 207     platform = 1ULL << platform;
 208   uint64_t hwcap_mask = GET_HWCAP_MASK ();
 209 #define _DL_HWCAP_TLS_MASK (1LL << 63)
 210   uint64_t hwcap_exclude = ~((GLRO (dl_hwcap) & hwcap_mask)
 211                              | _DL_HWCAP_PLATFORM | _DL_HWCAP_TLS_MASK);
 212
 213   int left = 0;
 214   int right = nlibs - 1;
 215   const char *best = NULL;
 216 #ifdef SHARED
 217   uint32_t best_priority = 0;
 218 #endif
 219
 220   while (left <= right)
 221     {
 222       int middle = (left + right) / 2;
 223       uint32_t key = _dl_cache_file_entry (libs, entry_size, middle)->key;
 224
 225       /* Make sure string table indices are not bogus before using
 226          them.  */
 227       if (!_dl_cache_verify_ptr (key, string_table_size))
 228         return NULL;
 229
 230       /* Actually compare the entry with the key.  */
 231       int cmpres = _dl_cache_libcmp (name, string_table + key);
 232       if (__glibc_unlikely (cmpres == 0))
 233         {
 234           /* Found it.  LEFT now marks the last entry for which we
 235              know the name is correct.  */
 236           left = middle;
 237
 238           /* There might be entries with this name before the one we
 239              found.  So we have to find the beginning.  */
 240           while (middle > 0)
 241             {
 242               key = _dl_cache_file_entry (libs, entry_size, middle - 1)->key;
 243               /* Make sure string table indices are not bogus before
 244                  using them.  */
 245               if (!_dl_cache_verify_ptr (key, string_table_size)
 246                   /* Actually compare the entry.  */
 247                   || _dl_cache_libcmp (name, string_table + key) != 0)
 248                 break;
 249               --middle;
 250             }
 251
 252           do
 253             {
 254               int flags;
 255               const struct file_entry *lib
 256                 = _dl_cache_file_entry (libs, entry_size, middle);
 257
 258               /* Only perform the name test if necessary.  */
 259               if (middle > left
 260                   /* We haven't seen this string so far.  Test whether the
 261                      index is ok and whether the name matches.  Otherwise
 262                      we are done.  */
 263                   && (! _dl_cache_verify_ptr (lib->key, string_table_size)
 264                       || (_dl_cache_libcmp (name, string_table + lib->key)
 265                           != 0)))
 266                 break;
 267
 268               flags = lib->flags;
 269               if (_dl_cache_check_flags (flags)
 270                   && _dl_cache_verify_ptr (lib->value, string_table_size))
 271                 {
 272                   /* Named/extension hwcaps get slightly different
 273                      treatment: We keep searching for a better
 274                      match.  */
 275                   bool named_hwcap = false;
 276
 277                   if (entry_size >= sizeof (struct file_entry_new))
 278                     {
 279                       /* The entry is large enough to include
 280                          HWCAP data.  Check it.  */
 281                       struct file_entry_new *libnew
 282                         = (struct file_entry_new *) lib;
 283
 284 #ifdef SHARED
 285                       named_hwcap = dl_cache_hwcap_extension (libnew);
 286                       if (named_hwcap
 287                           && !dl_cache_hwcap_isa_level_compatible (libnew))
 288                         continue;
 289 #endif
 290
 291                       /* The entries with named/extension hwcaps have
 292                          been exhausted (they are listed before all
 293                          other entries).  Return the best match
 294                          encountered so far if there is one.  */
 295                       if (!named_hwcap && best != NULL)
 296                         break;
 297
 298                       if ((libnew->hwcap & hwcap_exclude) && !named_hwcap)
 299                         continue;
 300                       if (GLRO (dl_osversion)
 301                           && libnew->osversion > GLRO (dl_osversion))
 302                         continue;
 303                       if (_DL_PLATFORMS_COUNT
 304                           && (libnew->hwcap & _DL_HWCAP_PLATFORM) != 0
 305                           && ((libnew->hwcap & _DL_HWCAP_PLATFORM)
 306                               != platform))
 307                         continue;
 308
 309 #ifdef SHARED
 310                       /* For named hwcaps, determine the priority and
 311                          see if beats what has been found so far.  */
 312                       if (named_hwcap)
 313                         {
 314                           uint32_t entry_priority
 315                             = glibc_hwcaps_priority (libnew->hwcap);
 316                           if (entry_priority == 0)
 317                             /* Not usable at all.  Skip.  */
 318                             continue;
 319                           else if (best == NULL
 320                                    || entry_priority < best_priority)
 321                             /* This entry is of higher priority
 322                                than the previous one, or it is the
 323                                first entry.  */
 324                             best_priority = entry_priority;
 325                           else
 326                             /* An entry has already been found,
 327                                but it is a better match.  */
 328                             continue;
 329                         }
 330 #endif /* SHARED */
 331                     }
 332
 333                   best = string_table + lib->value;
 334
 335                   if (!named_hwcap && flags == _DL_CACHE_DEFAULT_ID)
 336                     /* With named hwcaps, we need to keep searching to
 337                        see if we find a better match.  A better match
 338                        is also possible if the flags of the current
 339                        entry do not match the expected cache flags.
 340                        But if the flags match, no better entry will be
 341                        found.  */
 342                     break;
 343                 }
 344             }
 345           while (++middle <= right);
 346           break;
 347         }
 348
 349       if (cmpres < 0)
 350         left = middle + 1;
 351       else
 352         right = middle - 1;
 353     }
 354
 355   return best;
 356 }
 357
 358 int
 359 _dl_cache_libcmp (const char *p1, const char *p2)
 360 {
 361   while (*p1 != '\0')
 362     {
 363       if (*p1 >= '0' && *p1 <= '9')
 364         {
 365           if (*p2 >= '0' && *p2 <= '9')
 366             {
 367               /* Must compare this numerically.  */
 368               int val1;
 369               int val2;
 370
 371               val1 = *p1++ - '0';
 372               val2 = *p2++ - '0';
 373               while (*p1 >= '0' && *p1 <= '9')
 374                 val1 = val1 * 10 + *p1++ - '0';
 375               while (*p2 >= '0' && *p2 <= '9')
 376                 val2 = val2 * 10 + *p2++ - '0';
 377               if (val1 != val2)
 378                 return val1 - val2;
 379             }
 380           else
 381             return 1;
 382         }
 383       else if (*p2 >= '0' && *p2 <= '9')
 384         return -1;
 385       else if (*p1 != *p2)
 386         return *p1 - *p2;
 387       else
 388         {
 389           ++p1;
 390           ++p2;
 391         }
 392     }
 393   return *p1 - *p2;
 394 }
 395
 396
 397 /* Look up NAME in ld.so.cache and return the file name stored there, or null
 398    if none is found.  The cache is loaded if it was not already.  If loading
 399    the cache previously failed there will be no more attempts to load it.
 400    The caller is responsible for freeing the returned string.  The ld.so.cache
 401    may be unmapped at any time by a completing recursive dlopen and
 402    this function must take care that it does not return references to
 403    any data in the mapping.  */
 404 char *
 405 _dl_load_cache_lookup (const char *name)
 406 {
 407   /* Print a message if the loading of libs is traced.  */
 408   if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_LIBS))
 409     _dl_debug_printf (" search cache=%s\n", LD_SO_CACHE);
 410
 411   if (cache == NULL)
 412     {
 413       /* Read the contents of the file.  */
 414       void *file = _dl_sysdep_read_whole_file (LD_SO_CACHE, &cachesize,
 415                                                PROT_READ);
 416
 417       /* We can handle three different cache file formats here:
 418          - only the new format
 419          - the old libc5/glibc2.0/2.1 format
 420          - the old format with the new format in it
 421          The following checks if the cache contains any of these formats.  */
 422       if (file != MAP_FAILED && cachesize > sizeof *cache_new
 423           && memcmp (file, CACHEMAGIC_VERSION_NEW,
 424                      sizeof CACHEMAGIC_VERSION_NEW - 1) == 0
 425           /* Check for corruption, avoiding overflow.  */
 426           && ((cachesize - sizeof *cache_new) / sizeof (struct file_entry_new)
 427               >= ((struct cache_file_new *) file)->nlibs))
 428         {
 429           if (! cache_file_new_matches_endian (file))
 430             {
 431               __munmap (file, cachesize);
 432               file = (void *) -1;
 433             }
 434           cache_new = file;
 435           cache = file;
 436         }
 437       else if (file != MAP_FAILED && cachesize > sizeof *cache
 438                && memcmp (file, CACHEMAGIC, sizeof CACHEMAGIC - 1) == 0
 439                /* Check for corruption, avoiding overflow.  */
 440                && ((cachesize - sizeof *cache) / sizeof (struct file_entry)
 441                    >= ((struct cache_file *) file)->nlibs))
 442         {
 443           size_t offset;
 444           /* Looks ok.  */
 445           cache = file;
 446
 447           /* Check for new version.  */
 448           offset = ALIGN_CACHE (sizeof (struct cache_file)
 449                                 + cache->nlibs * sizeof (struct file_entry));
 450
 451           cache_new = (struct cache_file_new *) ((void *) cache + offset);
 452           if (cachesize < (offset + sizeof (struct cache_file_new))
 453               || memcmp (cache_new->magic, CACHEMAGIC_VERSION_NEW,
 454                          sizeof CACHEMAGIC_VERSION_NEW - 1) != 0)
 455               cache_new = (void *) -1;
 456           else
 457             {
 458               if (! cache_file_new_matches_endian (cache_new))
 459                 {
 460                   /* The old-format part of the cache is bogus as well
 461                      if the endianness does not match.  (But it is
 462                      unclear how the new header can be located if the
 463                      endianess does not match.)  */
 464                   cache = (void *) -1;
 465                   cache_new = (void *) -1;
 466                   __munmap (file, cachesize);
 467                 }
 468             }
 469         }
 470       else
 471         {
 472           if (file != MAP_FAILED)
 473             __munmap (file, cachesize);
 474           cache = (void *) -1;
 475         }
 476
 477       assert (cache != NULL);
 478     }
 479
 480   if (cache == (void *) -1)
 481     /* Previously looked for the cache file and didn't find it.  */
 482     return NULL;
 483
 484   const char *best;
 485   if (cache_new != (void *) -1)
 486     {
 487       const char *string_table = (const char *) cache_new;
 488       best = search_cache (string_table, cachesize,
 489                            &cache_new->libs[0].entry, cache_new->nlibs,
 490                            sizeof (cache_new->libs[0]), name);
 491     }
 492   else
 493     {
 494       const char *string_table = (const char *) &cache->libs[cache->nlibs];
 495       uint32_t string_table_size
 496         = (const char *) cache + cachesize - string_table;
 497       best = search_cache (string_table, string_table_size,
 498                            &cache->libs[0], cache->nlibs,
 499                            sizeof (cache->libs[0]), name);
 500     }
 501
 502   /* Print our result if wanted.  */
 503   if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_LIBS, 0)
 504       && best != NULL)
 505     _dl_debug_printf ("  trying file=%s\n", best);
 506
 507   if (best == NULL)
 508     return NULL;
 509
 510   /* The double copy is *required* since malloc may be interposed
 511      and call dlopen itself whose completion would unmap the data
 512      we are accessing. Therefore we must make the copy of the
 513      mapping data without using malloc.  */
 514   char *temp;
 515   temp = alloca (strlen (best) + 1);
 516   strcpy (temp, best);
 517   return __strdup (temp);
 518 }
 519
 520 #ifndef MAP_COPY
 521 /* If the system does not support MAP_COPY we cannot leave the file open
 522    all the time since this would create problems when the file is replaced.
 523    Therefore we provide this function to close the file and open it again
 524    once needed.  */
 525 void
 526 _dl_unload_cache (void)
 527 {
 528   if (cache != NULL && cache != (struct cache_file *) -1)
 529     {
 530       __munmap (cache, cachesize);
 531       cache = NULL;
 532     }
 533 #ifdef SHARED
 534   /* This marks the glibc_hwcaps_priorities array as out-of-date.  */
 535   glibc_hwcaps_priorities_length = 0;
 536 #endif
 537 }
 538 #endif