elf/cache.c

   1 /* Copyright (C) 1999-2003,2005,2006 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Andreas Jaeger <aj@suse.de>, 1999.
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published
   7    by the Free Software Foundation; version 2 of the License, or
   8    (at your option) any later version.
   9
  10    This program 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
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software Foundation,
  17    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  18
  19 #include <errno.h>
  20 #include <error.h>
  21 #include <dirent.h>
  22 #include <inttypes.h>
  23 #include <libintl.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <unistd.h>
  28 #include <sys/fcntl.h>
  29 #include <sys/mman.h>
  30 #include <sys/stat.h>
  31 #include <sys/types.h>
  32
  33 #include <ldconfig.h>
  34 #include <dl-cache.h>
  35
  36 struct cache_entry
  37 {
  38   char *lib;                    /* Library name.  */
  39   char *path;                   /* Path to find library.  */
  40   int flags;                    /* Flags to indicate kind of library.  */
  41   unsigned int osversion;       /* Required OS version.  */
  42   uint64_t hwcap;               /* Important hardware capabilities.  */
  43   int bits_hwcap;               /* Number of bits set in hwcap.  */
  44   struct cache_entry *next;     /* Next entry in list.  */
  45 };
  46
  47 /* List of all cache entries.  */
  48 static struct cache_entry *entries;
  49
  50 static const char *flag_descr[] =
  51 { "libc4", "ELF", "libc5", "libc6"};
  52
  53 /* Print a single entry.  */
  54 static void
  55 print_entry (const char *lib, int flag, unsigned int osversion,
  56              uint64_t hwcap, const char *key)
  57 {
  58   printf ("\t%s (", lib);
  59   switch (flag & FLAG_TYPE_MASK)
  60     {
  61     case FLAG_LIBC4:
  62     case FLAG_ELF:
  63     case FLAG_ELF_LIBC5:
  64     case FLAG_ELF_LIBC6:
  65       fputs (flag_descr[flag & FLAG_TYPE_MASK], stdout);
  66       break;
  67     default:
  68       fputs (_("unknown"), stdout);
  69       break;
  70     }
  71   switch (flag & FLAG_REQUIRED_MASK)
  72     {
  73     case FLAG_SPARC_LIB64:
  74       fputs (",64bit", stdout);
  75       break;
  76     case FLAG_IA64_LIB64:
  77       fputs (",IA-64", stdout);
  78       break;
  79     case FLAG_X8664_LIB64:
  80       fputs (",x86-64", stdout);
  81       break;
  82     case FLAG_S390_LIB64:
  83       fputs(",64bit", stdout);
  84       break;
  85     case FLAG_POWERPC_LIB64:
  86       fputs(",64bit", stdout);
  87       break;
  88     case FLAG_MIPS64_LIBN32:
  89       fputs(",N32", stdout);
  90       break;
  91     case FLAG_MIPS64_LIBN64:
  92       fputs(",64bit", stdout);
  93     case 0:
  94       break;
  95     default:
  96       printf (",%d", flag & FLAG_REQUIRED_MASK);
  97       break;
  98     }
  99   if (hwcap != 0)
 100     printf (", hwcap: %#.16" PRIx64, hwcap);
 101   if (osversion != 0)
 102     {
 103       static const char *const abi_tag_os[] =
 104       {
 105         [0] = "Linux",
 106         [1] = "Hurd",
 107         [2] = "Solaris",
 108         [3] = "FreeBSD",
 109         [4] = "kNetBSD",
 110         [5] = "Syllable",
 111         [6] = N_("Unknown OS")
 112       };
 113 #define MAXTAG (sizeof abi_tag_os / sizeof abi_tag_os[0] - 1)
 114       unsigned int os = osversion >> 24;
 115
 116       printf (_(", OS ABI: %s %d.%d.%d"),
 117               _(abi_tag_os[os > MAXTAG ? MAXTAG : os]),
 118               (osversion >> 16) & 0xff,
 119               (osversion >> 8) & 0xff,
 120               osversion & 0xff);
 121     }
 122   printf (") => %s\n", key);
 123 }
 124
 125
 126 /* Print the whole cache file, if a file contains the new cache format
 127    hidden in the old one, print the contents of the new format.  */
 128 void
 129 print_cache (const char *cache_name)
 130 {
 131   size_t cache_size;
 132   struct stat64 st;
 133   int fd;
 134   unsigned int i;
 135   struct cache_file *cache;
 136   struct cache_file_new *cache_new = NULL;
 137   const char *cache_data;
 138   int format = 0;
 139
 140   fd = open (cache_name, O_RDONLY);
 141   if (fd < 0)
 142     error (EXIT_FAILURE, errno, _("Can't open cache file %s\n"), cache_name);
 143
 144   if (fstat64 (fd, &st) < 0
 145       /* No need to map the file if it is empty.  */
 146       || st.st_size == 0)
 147     {
 148       close (fd);
 149       return;
 150     }
 151
 152   cache = mmap (0, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
 153   if (cache == MAP_FAILED)
 154     error (EXIT_FAILURE, errno, _("mmap of cache file failed.\n"));
 155   cache_size = st.st_size;
 156
 157   if (cache_size < sizeof (struct cache_file))
 158     error (EXIT_FAILURE, 0, _("File is not a cache file.\n"));
 159
 160   if (memcmp (cache->magic, CACHEMAGIC, sizeof CACHEMAGIC - 1))
 161     {
 162       /* This can only be the new format without the old one.  */
 163       cache_new = (struct cache_file_new *) cache;
 164
 165       if (memcmp (cache_new->magic, CACHEMAGIC_NEW, sizeof CACHEMAGIC_NEW - 1)
 166           || memcmp (cache_new->version, CACHE_VERSION,
 167                       sizeof CACHE_VERSION - 1))
 168         error (EXIT_FAILURE, 0, _("File is not a cache file.\n"));
 169       format = 1;
 170       /* This is where the strings start.  */
 171       cache_data = (const char *) cache_new;
 172     }
 173   else
 174     {
 175       size_t offset = ALIGN_CACHE (sizeof (struct cache_file)
 176                                    + (cache->nlibs
 177                                       * sizeof (struct file_entry)));
 178       /* This is where the strings start.  */
 179       cache_data = (const char *) &cache->libs[cache->nlibs];
 180
 181       /* Check for a new cache embedded in the old format.  */
 182       if (cache_size >
 183           (offset + sizeof (struct cache_file_new)))
 184         {
 185
 186           cache_new = (struct cache_file_new *) ((void *)cache + offset);
 187
 188           if (memcmp (cache_new->magic, CACHEMAGIC_NEW,
 189                       sizeof CACHEMAGIC_NEW - 1) == 0
 190               && memcmp (cache_new->version, CACHE_VERSION,
 191                          sizeof CACHE_VERSION - 1) == 0)
 192             {
 193               cache_data = (const char *) cache_new;
 194               format = 1;
 195             }
 196         }
 197     }
 198
 199   if (format == 0)
 200     {
 201       printf (_("%d libs found in cache `%s'\n"), cache->nlibs, cache_name);
 202
 203       /* Print everything.  */
 204       for (i = 0; i < cache->nlibs; i++)
 205         print_entry (cache_data + cache->libs[i].key,
 206                      cache->libs[i].flags, 0, 0,
 207                      cache_data + cache->libs[i].value);
 208     }
 209   else if (format == 1)
 210     {
 211       printf (_("%d libs found in cache `%s'\n"),
 212               cache_new->nlibs, cache_name);
 213
 214       /* Print everything.  */
 215       for (i = 0; i < cache_new->nlibs; i++)
 216         print_entry (cache_data + cache_new->libs[i].key,
 217                      cache_new->libs[i].flags,
 218                      cache_new->libs[i].osversion,
 219                      cache_new->libs[i].hwcap,
 220                      cache_data + cache_new->libs[i].value);
 221     }
 222   /* Cleanup.  */
 223   munmap (cache, cache_size);
 224   close (fd);
 225 }
 226
 227 /* Initialize cache data structures.  */
 228 void
 229 init_cache (void)
 230 {
 231   entries = NULL;
 232 }
 233
 234
 235
 236 static
 237 int compare (const struct cache_entry *e1, const struct cache_entry *e2)
 238 {
 239   int res;
 240
 241   /* We need to swap entries here to get the correct sort order.  */
 242   res = _dl_cache_libcmp (e2->lib, e1->lib);
 243   if (res == 0)
 244     {
 245       if (e1->flags < e2->flags)
 246         return 1;
 247       else if (e1->flags > e2->flags)
 248         return -1;
 249       /* Sort by most specific hwcap.  */
 250       else if (e2->bits_hwcap > e1->bits_hwcap)
 251         return 1;
 252       else if (e2->bits_hwcap < e1->bits_hwcap)
 253         return -1;
 254       else if (e2->hwcap > e1->hwcap)
 255         return 1;
 256       else if (e2->hwcap < e1->hwcap)
 257         return -1;
 258       if (e2->osversion > e1->osversion)
 259         return 1;
 260       if (e2->osversion < e1->osversion)
 261         return -1;
 262     }
 263   return res;
 264 }
 265
 266 /* Save the contents of the cache.  */
 267 void
 268 save_cache (const char *cache_name)
 269 {
 270   struct cache_entry *entry;
 271   int fd, idx_old, idx_new;
 272   size_t total_strlen, len;
 273   char *strings, *str, *temp_name;
 274   struct cache_file *file_entries = NULL;
 275   struct cache_file_new *file_entries_new = NULL;
 276   size_t file_entries_size = 0;
 277   size_t file_entries_new_size = 0;
 278   unsigned int str_offset;
 279   /* Number of cache entries.  */
 280   int cache_entry_count = 0;
 281   /* Number of normal cache entries.  */
 282   int cache_entry_old_count = 0;
 283   /* Pad for alignment of cache_file_new.  */
 284   size_t pad;
 285
 286   /* The cache entries are sorted already, save them in this order. */
 287
 288   /* Count the length of all strings.  */
 289   /* The old format doesn't contain hwcap entries and doesn't contain
 290      libraries in subdirectories with hwcaps entries.  Count therefore
 291      also all entries with hwcap == 0.  */
 292   total_strlen = 0;
 293   for (entry = entries; entry != NULL; entry = entry->next)
 294     {
 295       /* Account the final NULs.  */
 296       total_strlen += strlen (entry->lib) + strlen (entry->path) + 2;
 297       ++cache_entry_count;
 298       if (entry->hwcap == 0)
 299         ++cache_entry_old_count;
 300     }
 301
 302   /* Create the on disk cache structure.  */
 303   /* First an array for all strings.  */
 304   strings = (char *)xmalloc (total_strlen);
 305
 306   if (opt_format != 2)
 307     {
 308       /* struct cache_file_new is 64-bit aligned on some arches while
 309          only 32-bit aligned on other arches.  Duplicate last old
 310          cache entry so that new cache in ld.so.cache can be used by
 311          both.  */
 312       if (opt_format != 0)
 313         cache_entry_old_count = (cache_entry_old_count + 1) & ~1;
 314
 315       /* And the list of all entries in the old format.  */
 316       file_entries_size = sizeof (struct cache_file)
 317         + cache_entry_old_count * sizeof (struct file_entry);
 318       file_entries = (struct cache_file *) xmalloc (file_entries_size);
 319
 320       /* Fill in the header.  */
 321       memset (file_entries, 0, sizeof (struct cache_file));
 322       memcpy (file_entries->magic, CACHEMAGIC, sizeof CACHEMAGIC - 1);
 323
 324       file_entries->nlibs = cache_entry_old_count;
 325     }
 326
 327   if (opt_format != 0)
 328     {
 329       /* And the list of all entries in the new format.  */
 330       file_entries_new_size = sizeof (struct cache_file_new)
 331         + cache_entry_count * sizeof (struct file_entry_new);
 332       file_entries_new =
 333         (struct cache_file_new *) xmalloc (file_entries_new_size);
 334
 335       /* Fill in the header.  */
 336       memset (file_entries_new, 0, sizeof (struct cache_file_new));
 337       memcpy (file_entries_new->magic, CACHEMAGIC_NEW,
 338               sizeof CACHEMAGIC_NEW - 1);
 339       memcpy (file_entries_new->version, CACHE_VERSION,
 340               sizeof CACHE_VERSION - 1);
 341
 342       file_entries_new->nlibs = cache_entry_count;
 343       file_entries_new->len_strings = total_strlen;
 344     }
 345
 346   pad = ALIGN_CACHE (file_entries_size) - file_entries_size;
 347
 348   /* If we have both formats, we hide the new format in the strings
 349      table, we have to adjust all string indices for this so that
 350      old libc5/glibc 2 dynamic linkers just ignore them.  */
 351   if (opt_format != 0)
 352     str_offset = file_entries_new_size;
 353   else
 354     str_offset = 0;
 355
 356   str = strings;
 357   for (idx_old = 0, idx_new = 0, entry = entries; entry != NULL;
 358        entry = entry->next, ++idx_new)
 359     {
 360       /* First the library.  */
 361       if (opt_format != 2 && entry->hwcap == 0)
 362         {
 363           file_entries->libs[idx_old].flags = entry->flags;
 364           /* XXX: Actually we can optimize here and remove duplicates.  */
 365           file_entries->libs[idx_old].key = str_offset + pad;
 366         }
 367       if (opt_format != 0)
 368         {
 369           /* We could subtract file_entries_new_size from str_offset -
 370              not doing so makes the code easier, the string table
 371              always begins at the beginning of the the new cache
 372              struct.  */
 373           file_entries_new->libs[idx_new].flags = entry->flags;
 374           file_entries_new->libs[idx_new].osversion = entry->osversion;
 375           file_entries_new->libs[idx_new].hwcap = entry->hwcap;
 376           file_entries_new->libs[idx_new].key = str_offset;
 377         }
 378       len = strlen (entry->lib);
 379       str = stpcpy (str, entry->lib);
 380       /* Account the final NUL.  */
 381       ++str;
 382       str_offset += len + 1;
 383       /* Then the path.  */
 384       if (opt_format != 2 && entry->hwcap == 0)
 385         file_entries->libs[idx_old].value = str_offset + pad;
 386       if (opt_format != 0)
 387         file_entries_new->libs[idx_new].value = str_offset;
 388       len = strlen (entry->path);
 389       str = stpcpy (str, entry->path);
 390       /* Account the final NUL.  */
 391       ++str;
 392       str_offset += len + 1;
 393       /* Ignore entries with hwcap for old format.  */
 394       if (entry->hwcap == 0)
 395         ++idx_old;
 396     }
 397
 398   /* Duplicate last old cache entry if needed.  */
 399   if (opt_format != 2
 400       && idx_old < cache_entry_old_count)
 401     file_entries->libs[idx_old] = file_entries->libs[idx_old - 1];
 402
 403   /* Write out the cache.  */
 404
 405   /* Write cache first to a temporary file and rename it later.  */
 406   temp_name = xmalloc (strlen (cache_name) + 2);
 407   sprintf (temp_name, "%s~", cache_name);
 408   /* First remove an old copy if it exists.  */
 409   if (unlink (temp_name) && errno != ENOENT)
 410     error (EXIT_FAILURE, errno, _("Can't remove old temporary cache file %s"),
 411            temp_name);
 412
 413   /* Create file.  */
 414   fd = open (temp_name, O_CREAT|O_WRONLY|O_TRUNC|O_NOFOLLOW,
 415              S_IROTH|S_IRGRP|S_IRUSR|S_IWUSR);
 416   if (fd < 0)
 417     error (EXIT_FAILURE, errno, _("Can't create temporary cache file %s"),
 418            temp_name);
 419
 420   /* Write contents.  */
 421   if (opt_format != 2)
 422     {
 423       if (write (fd, file_entries, file_entries_size)
 424           != (ssize_t) file_entries_size)
 425         error (EXIT_FAILURE, errno, _("Writing of cache data failed"));
 426     }
 427   if (opt_format != 0)
 428     {
 429       /* Align cache.  */
 430       if (opt_format != 2)
 431         {
 432           char zero[pad];
 433           memset (zero, '\0', pad);
 434           if (write (fd, zero, pad) != (ssize_t) pad)
 435             error (EXIT_FAILURE, errno, _("Writing of cache data failed"));
 436         }
 437       if (write (fd, file_entries_new, file_entries_new_size)
 438           != (ssize_t) file_entries_new_size)
 439         error (EXIT_FAILURE, errno, _("Writing of cache data failed"));
 440     }
 441
 442   if (write (fd, strings, total_strlen) != (ssize_t) total_strlen)
 443     error (EXIT_FAILURE, errno, _("Writing of cache data failed"));
 444
 445   close (fd);
 446
 447   /* Make sure user can always read cache file */
 448   if (chmod (temp_name, S_IROTH|S_IRGRP|S_IRUSR|S_IWUSR))
 449     error (EXIT_FAILURE, errno,
 450            _("Changing access rights of %s to %#o failed"), temp_name,
 451            S_IROTH|S_IRGRP|S_IRUSR|S_IWUSR);
 452
 453   /* Move temporary to its final location.  */
 454   if (rename (temp_name, cache_name))
 455     error (EXIT_FAILURE, errno, _("Renaming of %s to %s failed"), temp_name,
 456            cache_name);
 457
 458   /* Free all allocated memory.  */
 459   free (file_entries_new);
 460   free (file_entries);
 461   free (strings);
 462
 463   while (entries)
 464     {
 465       entry = entries;
 466       free (entry->path);
 467       free (entry->lib);
 468       entries = entries->next;
 469       free (entry);
 470     }
 471 }
 472
 473
 474 /* Add one library to the cache.  */
 475 void
 476 add_to_cache (const char *path, const char *lib, int flags,
 477               unsigned int osversion, uint64_t hwcap)
 478 {
 479   struct cache_entry *new_entry, *ptr, *prev;
 480   char *full_path;
 481   size_t len, i;
 482
 483   new_entry = (struct cache_entry *) xmalloc (sizeof (struct cache_entry));
 484
 485   len = strlen (lib) + strlen (path) + 2;
 486
 487   full_path = (char *) xmalloc (len);
 488   snprintf (full_path, len, "%s/%s", path, lib);
 489
 490   new_entry->lib = xstrdup (lib);
 491   new_entry->path = full_path;
 492   new_entry->flags = flags;
 493   new_entry->osversion = osversion;
 494   new_entry->hwcap = hwcap;
 495   new_entry->bits_hwcap = 0;
 496
 497   /* Count the number of bits set in the masked value.  */
 498   for (i = 0; (~((1ULL << i) - 1) & hwcap) != 0 && i < 8 * sizeof (hwcap); ++i)
 499     if ((hwcap & (1ULL << i)) != 0)
 500       ++new_entry->bits_hwcap;
 501
 502
 503   /* Keep the list sorted - search for right place to insert.  */
 504   ptr = entries;
 505   prev = entries;
 506   while (ptr != NULL)
 507     {
 508       if (compare (ptr, new_entry) > 0)
 509         break;
 510       prev = ptr;
 511       ptr = ptr->next;
 512     }
 513   /* Is this the first entry?  */
 514   if (ptr == entries)
 515     {
 516       new_entry->next = entries;
 517       entries = new_entry;
 518     }
 519   else
 520     {
 521       new_entry->next = prev->next;
 522       prev->next = new_entry;
 523     }
 524 }