elf/cache.c

   1 /* Copyright (C) 1999-2015 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, see <http://www.gnu.org/licenses/>.  */
  17
  18 #include <errno.h>
  19 #include <error.h>
  20 #include <dirent.h>
  21 #include <inttypes.h>
  22 #include <libgen.h>
  23 #include <libintl.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <unistd.h>
  28 #include <stdint.h>
  29 #include <sys/fcntl.h>
  30 #include <sys/mman.h>
  31 #include <sys/stat.h>
  32 #include <sys/types.h>
  33
  34 #include <ldconfig.h>
  35 #include <dl-cache.h>
  36
  37 struct cache_entry
  38 {
  39   char *lib;                    /* Library name.  */
  40   char *path;                   /* Path to find library.  */
  41   int flags;                    /* Flags to indicate kind of library.  */
  42   unsigned int osversion;       /* Required OS version.  */
  43   uint64_t hwcap;               /* Important hardware capabilities.  */
  44   int bits_hwcap;               /* Number of bits set in hwcap.  */
  45   struct cache_entry *next;     /* Next entry in list.  */
  46 };
  47
  48 /* List of all cache entries.  */
  49 static struct cache_entry *entries;
  50
  51 static const char *flag_descr[] =
  52 { "libc4", "ELF", "libc5", "libc6"};
  53
  54 /* Print a single entry.  */
  55 static void
  56 print_entry (const char *lib, int flag, unsigned int osversion,
  57              uint64_t hwcap, const char *key)
  58 {
  59   printf ("\t%s (", lib);
  60   switch (flag & FLAG_TYPE_MASK)
  61     {
  62     case FLAG_LIBC4:
  63     case FLAG_ELF:
  64     case FLAG_ELF_LIBC5:
  65     case FLAG_ELF_LIBC6:
  66       fputs (flag_descr[flag & FLAG_TYPE_MASK], stdout);
  67       break;
  68     default:
  69       fputs (_("unknown"), stdout);
  70       break;
  71     }
  72   switch (flag & FLAG_REQUIRED_MASK)
  73     {
  74     case FLAG_SPARC_LIB64:
  75       fputs (",64bit", stdout);
  76       break;
  77     case FLAG_IA64_LIB64:
  78       fputs (",IA-64", stdout);
  79       break;
  80     case FLAG_X8664_LIB64:
  81       fputs (",x86-64", stdout);
  82       break;
  83     case FLAG_S390_LIB64:
  84       fputs (",64bit", stdout);
  85       break;
  86     case FLAG_POWERPC_LIB64:
  87       fputs (",64bit", stdout);
  88       break;
  89     case FLAG_MIPS64_LIBN32:
  90       fputs (",N32", stdout);
  91       break;
  92     case FLAG_MIPS64_LIBN64:
  93       fputs (",64bit", stdout);
  94       break;
  95     case FLAG_X8664_LIBX32:
  96       fputs (",x32", stdout);
  97       break;
  98     case FLAG_ARM_LIBHF:
  99       fputs (",hard-float", stdout);
 100       break;
 101     case FLAG_AARCH64_LIB64:
 102       fputs (",AArch64", stdout);
 103       break;
 104     /* Uses the ARM soft-float ABI.  */
 105     case FLAG_ARM_LIBSF:
 106       fputs (",soft-float", stdout);
 107       break;
 108     case FLAG_MIPS_LIB32_NAN2008:
 109       fputs (",nan2008", stdout);
 110       break;
 111     case FLAG_MIPS64_LIBN32_NAN2008:
 112       fputs (",N32,nan2008", stdout);
 113       break;
 114     case FLAG_MIPS64_LIBN64_NAN2008:
 115       fputs (",64bit,nan2008", stdout);
 116       break;
 117     case 0:
 118       break;
 119     default:
 120       printf (",%d", flag & FLAG_REQUIRED_MASK);
 121       break;
 122     }
 123   if (hwcap != 0)
 124     printf (", hwcap: %#.16" PRIx64, hwcap);
 125   if (osversion != 0)
 126     {
 127       static const char *const abi_tag_os[] =
 128       {
 129         [0] = "Linux",
 130         [1] = "Hurd",
 131         [2] = "Solaris",
 132         [3] = "FreeBSD",
 133         [4] = "kNetBSD",
 134         [5] = "Syllable",
 135         [6] = N_("Unknown OS")
 136       };
 137 #define MAXTAG (sizeof abi_tag_os / sizeof abi_tag_os[0] - 1)
 138       unsigned int os = osversion >> 24;
 139
 140       printf (_(", OS ABI: %s %d.%d.%d"),
 141               _(abi_tag_os[os > MAXTAG ? MAXTAG : os]),
 142               (osversion >> 16) & 0xff,
 143               (osversion >> 8) & 0xff,
 144               osversion & 0xff);
 145     }
 146   printf (") => %s\n", key);
 147 }
 148
 149
 150 /* Print the whole cache file, if a file contains the new cache format
 151    hidden in the old one, print the contents of the new format.  */
 152 void
 153 print_cache (const char *cache_name)
 154 {
 155   int fd = open (cache_name, O_RDONLY);
 156   if (fd < 0)
 157     error (EXIT_FAILURE, errno, _("Can't open cache file %s\n"), cache_name);
 158
 159   struct stat64 st;
 160   if (fstat64 (fd, &st) < 0
 161       /* No need to map the file if it is empty.  */
 162       || st.st_size == 0)
 163     {
 164       close (fd);
 165       return;
 166     }
 167
 168   struct cache_file *cache
 169     = mmap (NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
 170   if (cache == MAP_FAILED)
 171     error (EXIT_FAILURE, errno, _("mmap of cache file failed.\n"));
 172
 173   size_t cache_size = st.st_size;
 174   if (cache_size < sizeof (struct cache_file))
 175     error (EXIT_FAILURE, 0, _("File is not a cache file.\n"));
 176
 177   struct cache_file_new *cache_new = NULL;
 178   const char *cache_data;
 179   int format = 0;
 180
 181   if (memcmp (cache->magic, CACHEMAGIC, sizeof CACHEMAGIC - 1))
 182     {
 183       /* This can only be the new format without the old one.  */
 184       cache_new = (struct cache_file_new *) cache;
 185
 186       if (memcmp (cache_new->magic, CACHEMAGIC_NEW, sizeof CACHEMAGIC_NEW - 1)
 187           || memcmp (cache_new->version, CACHE_VERSION,
 188                       sizeof CACHE_VERSION - 1))
 189         error (EXIT_FAILURE, 0, _("File is not a cache file.\n"));
 190       format = 1;
 191       /* This is where the strings start.  */
 192       cache_data = (const char *) cache_new;
 193     }
 194   else
 195     {
 196       size_t offset = ALIGN_CACHE (sizeof (struct cache_file)
 197                                    + (cache->nlibs
 198                                       * sizeof (struct file_entry)));
 199       /* This is where the strings start.  */
 200       cache_data = (const char *) &cache->libs[cache->nlibs];
 201
 202       /* Check for a new cache embedded in the old format.  */
 203       if (cache_size >
 204           (offset + sizeof (struct cache_file_new)))
 205         {
 206
 207           cache_new = (struct cache_file_new *) ((void *)cache + offset);
 208
 209           if (memcmp (cache_new->magic, CACHEMAGIC_NEW,
 210                       sizeof CACHEMAGIC_NEW - 1) == 0
 211               && memcmp (cache_new->version, CACHE_VERSION,
 212                          sizeof CACHE_VERSION - 1) == 0)
 213             {
 214               cache_data = (const char *) cache_new;
 215               format = 1;
 216             }
 217         }
 218     }
 219
 220   if (format == 0)
 221     {
 222       printf (_("%d libs found in cache `%s'\n"), cache->nlibs, cache_name);
 223
 224       /* Print everything.  */
 225       for (unsigned int i = 0; i < cache->nlibs; i++)
 226         print_entry (cache_data + cache->libs[i].key,
 227                      cache->libs[i].flags, 0, 0,
 228                      cache_data + cache->libs[i].value);
 229     }
 230   else if (format == 1)
 231     {
 232       printf (_("%d libs found in cache `%s'\n"),
 233               cache_new->nlibs, cache_name);
 234
 235       /* Print everything.  */
 236       for (unsigned int i = 0; i < cache_new->nlibs; i++)
 237         print_entry (cache_data + cache_new->libs[i].key,
 238                      cache_new->libs[i].flags,
 239                      cache_new->libs[i].osversion,
 240                      cache_new->libs[i].hwcap,
 241                      cache_data + cache_new->libs[i].value);
 242     }
 243   /* Cleanup.  */
 244   munmap (cache, cache_size);
 245   close (fd);
 246 }
 247
 248 /* Initialize cache data structures.  */
 249 void
 250 init_cache (void)
 251 {
 252   entries = NULL;
 253 }
 254
 255 static int
 256 compare (const struct cache_entry *e1, const struct cache_entry *e2)
 257 {
 258   /* We need to swap entries here to get the correct sort order.  */
 259   int res = _dl_cache_libcmp (e2->lib, e1->lib);
 260   if (res == 0)
 261     {
 262       if (e1->flags < e2->flags)
 263         return 1;
 264       else if (e1->flags > e2->flags)
 265         return -1;
 266       /* Sort by most specific hwcap.  */
 267       else if (e2->bits_hwcap > e1->bits_hwcap)
 268         return 1;
 269       else if (e2->bits_hwcap < e1->bits_hwcap)
 270         return -1;
 271       else if (e2->hwcap > e1->hwcap)
 272         return 1;
 273       else if (e2->hwcap < e1->hwcap)
 274         return -1;
 275       if (e2->osversion > e1->osversion)
 276         return 1;
 277       if (e2->osversion < e1->osversion)
 278         return -1;
 279     }
 280   return res;
 281 }
 282
 283 /* Save the contents of the cache.  */
 284 void
 285 save_cache (const char *cache_name)
 286 {
 287   /* The cache entries are sorted already, save them in this order. */
 288
 289   /* Count the length of all strings.  */
 290   /* The old format doesn't contain hwcap entries and doesn't contain
 291      libraries in subdirectories with hwcaps entries.  Count therefore
 292      also all entries with hwcap == 0.  */
 293   size_t total_strlen = 0;
 294   struct cache_entry *entry;
 295   /* Number of cache entries.  */
 296   int cache_entry_count = 0;
 297   /* Number of normal cache entries.  */
 298   int cache_entry_old_count = 0;
 299
 300   for (entry = entries; entry != NULL; entry = entry->next)
 301     {
 302       /* Account the final NULs.  */
 303       total_strlen += strlen (entry->lib) + strlen (entry->path) + 2;
 304       ++cache_entry_count;
 305       if (entry->hwcap == 0)
 306         ++cache_entry_old_count;
 307     }
 308
 309   /* Create the on disk cache structure.  */
 310   struct cache_file *file_entries = NULL;
 311   size_t file_entries_size = 0;
 312
 313   if (opt_format != 2)
 314     {
 315       /* struct cache_file_new is 64-bit aligned on some arches while
 316          only 32-bit aligned on other arches.  Duplicate last old
 317          cache entry so that new cache in ld.so.cache can be used by
 318          both.  */
 319       if (opt_format != 0)
 320         cache_entry_old_count = (cache_entry_old_count + 1) & ~1;
 321
 322       /* And the list of all entries in the old format.  */
 323       file_entries_size = sizeof (struct cache_file)
 324         + cache_entry_old_count * sizeof (struct file_entry);
 325       file_entries = xmalloc (file_entries_size);
 326
 327       /* Fill in the header.  */
 328       memset (file_entries, '\0', sizeof (struct cache_file));
 329       memcpy (file_entries->magic, CACHEMAGIC, sizeof CACHEMAGIC - 1);
 330
 331       file_entries->nlibs = cache_entry_old_count;
 332     }
 333
 334   struct cache_file_new *file_entries_new = NULL;
 335   size_t file_entries_new_size = 0;
 336
 337   if (opt_format != 0)
 338     {
 339       /* And the list of all entries in the new format.  */
 340       file_entries_new_size = sizeof (struct cache_file_new)
 341         + cache_entry_count * sizeof (struct file_entry_new);
 342       file_entries_new = xmalloc (file_entries_new_size);
 343
 344       /* Fill in the header.  */
 345       memset (file_entries_new, '\0', sizeof (struct cache_file_new));
 346       memcpy (file_entries_new->magic, CACHEMAGIC_NEW,
 347               sizeof CACHEMAGIC_NEW - 1);
 348       memcpy (file_entries_new->version, CACHE_VERSION,
 349               sizeof CACHE_VERSION - 1);
 350
 351       file_entries_new->nlibs = cache_entry_count;
 352       file_entries_new->len_strings = total_strlen;
 353     }
 354
 355   /* Pad for alignment of cache_file_new.  */
 356   size_t pad = ALIGN_CACHE (file_entries_size) - file_entries_size;
 357
 358   /* If we have both formats, we hide the new format in the strings
 359      table, we have to adjust all string indices for this so that
 360      old libc5/glibc 2 dynamic linkers just ignore them.  */
 361   unsigned int str_offset;
 362   if (opt_format != 0)
 363     str_offset = file_entries_new_size;
 364   else
 365     str_offset = 0;
 366
 367   /* An array for all strings.  */
 368   char *strings = xmalloc (total_strlen);
 369   char *str = strings;
 370   int idx_old;
 371   int idx_new;
 372
 373   for (idx_old = 0, idx_new = 0, entry = entries; entry != NULL;
 374        entry = entry->next, ++idx_new)
 375     {
 376       /* First the library.  */
 377       if (opt_format != 2 && entry->hwcap == 0)
 378         {
 379           file_entries->libs[idx_old].flags = entry->flags;
 380           /* XXX: Actually we can optimize here and remove duplicates.  */
 381           file_entries->libs[idx_old].key = str_offset + pad;
 382         }
 383       if (opt_format != 0)
 384         {
 385           /* We could subtract file_entries_new_size from str_offset -
 386              not doing so makes the code easier, the string table
 387              always begins at the beginning of the new cache
 388              struct.  */
 389           file_entries_new->libs[idx_new].flags = entry->flags;
 390           file_entries_new->libs[idx_new].osversion = entry->osversion;
 391           file_entries_new->libs[idx_new].hwcap = entry->hwcap;
 392           file_entries_new->libs[idx_new].key = str_offset;
 393         }
 394
 395       size_t len = strlen (entry->lib) + 1;
 396       str = mempcpy (str, entry->lib, len);
 397       str_offset += len;
 398       /* Then the path.  */
 399       if (opt_format != 2 && entry->hwcap == 0)
 400         file_entries->libs[idx_old].value = str_offset + pad;
 401       if (opt_format != 0)
 402         file_entries_new->libs[idx_new].value = str_offset;
 403       len = strlen (entry->path) + 1;
 404       str = mempcpy (str, entry->path, len);
 405       str_offset += len;
 406       /* Ignore entries with hwcap for old format.  */
 407       if (entry->hwcap == 0)
 408         ++idx_old;
 409     }
 410
 411   /* Duplicate last old cache entry if needed.  */
 412   if (opt_format != 2
 413       && idx_old < cache_entry_old_count)
 414     file_entries->libs[idx_old] = file_entries->libs[idx_old - 1];
 415
 416   /* Write out the cache.  */
 417
 418   /* Write cache first to a temporary file and rename it later.  */
 419   char *temp_name = xmalloc (strlen (cache_name) + 2);
 420   sprintf (temp_name, "%s~", cache_name);
 421
 422   /* Create file.  */
 423   int fd = open (temp_name, O_CREAT|O_WRONLY|O_TRUNC|O_NOFOLLOW,
 424                  S_IRUSR|S_IWUSR);
 425   if (fd < 0)
 426     error (EXIT_FAILURE, errno, _("Can't create temporary cache file %s"),
 427            temp_name);
 428
 429   /* Write contents.  */
 430   if (opt_format != 2)
 431     {
 432       if (write (fd, file_entries, file_entries_size)
 433           != (ssize_t) file_entries_size)
 434         error (EXIT_FAILURE, errno, _("Writing of cache data failed"));
 435     }
 436   if (opt_format != 0)
 437     {
 438       /* Align cache.  */
 439       if (opt_format != 2)
 440         {
 441           char zero[pad];
 442           memset (zero, '\0', pad);
 443           if (write (fd, zero, pad) != (ssize_t) pad)
 444             error (EXIT_FAILURE, errno, _("Writing of cache data failed"));
 445         }
 446       if (write (fd, file_entries_new, file_entries_new_size)
 447           != (ssize_t) file_entries_new_size)
 448         error (EXIT_FAILURE, errno, _("Writing of cache data failed"));
 449     }
 450
 451   if (write (fd, strings, total_strlen) != (ssize_t) total_strlen
 452       || close (fd))
 453     error (EXIT_FAILURE, errno, _("Writing of cache data failed"));
 454
 455   /* Make sure user can always read cache file */
 456   if (chmod (temp_name, S_IROTH|S_IRGRP|S_IRUSR|S_IWUSR))
 457     error (EXIT_FAILURE, errno,
 458            _("Changing access rights of %s to %#o failed"), temp_name,
 459            S_IROTH|S_IRGRP|S_IRUSR|S_IWUSR);
 460
 461   /* Move temporary to its final location.  */
 462   if (rename (temp_name, cache_name))
 463     error (EXIT_FAILURE, errno, _("Renaming of %s to %s failed"), temp_name,
 464            cache_name);
 465
 466   /* Free all allocated memory.  */
 467   free (file_entries_new);
 468   free (file_entries);
 469   free (strings);
 470
 471   while (entries)
 472     {
 473       entry = entries;
 474       entries = entries->next;
 475       free (entry);
 476     }
 477 }
 478
 479
 480 /* Add one library to the cache.  */
 481 void
 482 add_to_cache (const char *path, const char *lib, int flags,
 483               unsigned int osversion, uint64_t hwcap)
 484 {
 485   size_t liblen = strlen (lib) + 1;
 486   size_t len = liblen + strlen (path) + 1;
 487   struct cache_entry *new_entry
 488     = xmalloc (sizeof (struct cache_entry) + liblen + len);
 489
 490   new_entry->lib = memcpy ((char *) (new_entry + 1), lib, liblen);
 491   new_entry->path = new_entry->lib + liblen;
 492   snprintf (new_entry->path, len, "%s/%s", path, lib);
 493   new_entry->flags = flags;
 494   new_entry->osversion = osversion;
 495   new_entry->hwcap = hwcap;
 496   new_entry->bits_hwcap = 0;
 497
 498   /* Count the number of bits set in the masked value.  */
 499   for (size_t i = 0;
 500        (~((1ULL << i) - 1) & hwcap) != 0 && i < 8 * sizeof (hwcap); ++i)
 501     if ((hwcap & (1ULL << i)) != 0)
 502       ++new_entry->bits_hwcap;
 503
 504
 505   /* Keep the list sorted - search for right place to insert.  */
 506   struct cache_entry *ptr = entries;
 507   struct cache_entry *prev = entries;
 508   while (ptr != NULL)
 509     {
 510       if (compare (ptr, new_entry) > 0)
 511         break;
 512       prev = ptr;
 513       ptr = ptr->next;
 514     }
 515   /* Is this the first entry?  */
 516   if (ptr == entries)
 517     {
 518       new_entry->next = entries;
 519       entries = new_entry;
 520     }
 521   else
 522     {
 523       new_entry->next = prev->next;
 524       prev->next = new_entry;
 525     }
 526 }
 527
 528
 529 /* Auxiliary cache.  */
 530
 531 struct aux_cache_entry_id
 532 {
 533   uint64_t ino;
 534   uint64_t ctime;
 535   uint64_t size;
 536   uint64_t dev;
 537 };
 538
 539 struct aux_cache_entry
 540 {
 541   struct aux_cache_entry_id id;
 542   int flags;
 543   unsigned int osversion;
 544   int used;
 545   char *soname;
 546   struct aux_cache_entry *next;
 547 };
 548
 549 #define AUX_CACHEMAGIC          "glibc-ld.so.auxcache-1.0"
 550
 551 struct aux_cache_file_entry
 552 {
 553   struct aux_cache_entry_id id; /* Unique id of entry.  */
 554   int32_t flags;                /* This is 1 for an ELF library.  */
 555   uint32_t soname;              /* String table indice.  */
 556   uint32_t osversion;           /* Required OS version.  */
 557   int32_t pad;
 558 };
 559
 560 /* ldconfig maintains an auxiliary cache file that allows
 561    only reading those libraries that have changed since the last iteration.
 562    For this for each library some information is cached in the auxiliary
 563    cache.  */
 564 struct aux_cache_file
 565 {
 566   char magic[sizeof AUX_CACHEMAGIC - 1];
 567   uint32_t nlibs;               /* Number of entries.  */
 568   uint32_t len_strings;         /* Size of string table. */
 569   struct aux_cache_file_entry libs[0]; /* Entries describing libraries.  */
 570   /* After this the string table of size len_strings is found.  */
 571 };
 572
 573 static const unsigned int primes[] =
 574 {
 575   1021, 2039, 4093, 8191, 16381, 32749, 65521, 131071, 262139,
 576   524287, 1048573, 2097143, 4194301, 8388593, 16777213, 33554393,
 577   67108859, 134217689, 268435399, 536870909, 1073741789, 2147483647
 578 };
 579
 580 static size_t aux_hash_size;
 581 static struct aux_cache_entry **aux_hash;
 582
 583 /* Simplistic hash function for aux_cache_entry_id.  */
 584 static unsigned int
 585 aux_cache_entry_id_hash (struct aux_cache_entry_id *id)
 586 {
 587   uint64_t ret = ((id->ino * 11 + id->ctime) * 11 + id->size) * 11 + id->dev;
 588   return ret ^ (ret >> 32);
 589 }
 590
 591 static size_t nextprime (size_t x)
 592 {
 593   for (unsigned int i = 0; i < sizeof (primes) / sizeof (primes[0]); ++i)
 594     if (primes[i] >= x)
 595       return primes[i];
 596   return x;
 597 }
 598
 599 void
 600 init_aux_cache (void)
 601 {
 602   aux_hash_size = primes[3];
 603   aux_hash = xcalloc (aux_hash_size, sizeof (struct aux_cache_entry *));
 604 }
 605
 606 int
 607 search_aux_cache (struct stat64 *stat_buf, int *flags,
 608                   unsigned int *osversion, char **soname)
 609 {
 610   struct aux_cache_entry_id id;
 611   id.ino = (uint64_t) stat_buf->st_ino;
 612   id.ctime = (uint64_t) stat_buf->st_ctime;
 613   id.size = (uint64_t) stat_buf->st_size;
 614   id.dev = (uint64_t) stat_buf->st_dev;
 615
 616   unsigned int hash = aux_cache_entry_id_hash (&id);
 617   struct aux_cache_entry *entry;
 618   for (entry = aux_hash[hash % aux_hash_size]; entry; entry = entry->next)
 619     if (id.ino == entry->id.ino
 620         && id.ctime == entry->id.ctime
 621         && id.size == entry->id.size
 622         && id.dev == entry->id.dev)
 623       {
 624         *flags = entry->flags;
 625         *osversion = entry->osversion;
 626         if (entry->soname != NULL)
 627           *soname = xstrdup (entry->soname);
 628         else
 629           *soname = NULL;
 630         entry->used = 1;
 631         return 1;
 632       }
 633
 634   return 0;
 635 }
 636
 637 static void
 638 insert_to_aux_cache (struct aux_cache_entry_id *id, int flags,
 639                      unsigned int osversion, const char *soname, int used)
 640 {
 641   size_t hash = aux_cache_entry_id_hash (id) % aux_hash_size;
 642   struct aux_cache_entry *entry;
 643   for (entry = aux_hash[hash]; entry; entry = entry->next)
 644     if (id->ino == entry->id.ino
 645         && id->ctime == entry->id.ctime
 646         && id->size == entry->id.size
 647         && id->dev == entry->id.dev)
 648       abort ();
 649
 650   size_t len = soname ? strlen (soname) + 1 : 0;
 651   entry = xmalloc (sizeof (struct aux_cache_entry) + len);
 652   entry->id = *id;
 653   entry->flags = flags;
 654   entry->osversion = osversion;
 655   entry->used = used;
 656   if (soname != NULL)
 657     entry->soname = memcpy ((char *) (entry + 1), soname, len);
 658   else
 659     entry->soname = NULL;
 660   entry->next = aux_hash[hash];
 661   aux_hash[hash] = entry;
 662 }
 663
 664 void
 665 add_to_aux_cache (struct stat64 *stat_buf, int flags,
 666                   unsigned int osversion, const char *soname)
 667 {
 668   struct aux_cache_entry_id id;
 669   id.ino = (uint64_t) stat_buf->st_ino;
 670   id.ctime = (uint64_t) stat_buf->st_ctime;
 671   id.size = (uint64_t) stat_buf->st_size;
 672   id.dev = (uint64_t) stat_buf->st_dev;
 673   insert_to_aux_cache (&id, flags, osversion, soname, 1);
 674 }
 675
 676 /* Load auxiliary cache to search for unchanged entries.   */
 677 void
 678 load_aux_cache (const char *aux_cache_name)
 679 {
 680   int fd = open (aux_cache_name, O_RDONLY);
 681   if (fd < 0)
 682     {
 683       init_aux_cache ();
 684       return;
 685     }
 686
 687   struct stat64 st;
 688   if (fstat64 (fd, &st) < 0 || st.st_size < sizeof (struct aux_cache_file))
 689     {
 690       close (fd);
 691       init_aux_cache ();
 692       return;
 693     }
 694
 695   size_t aux_cache_size = st.st_size;
 696   struct aux_cache_file *aux_cache
 697     = mmap (NULL, aux_cache_size, PROT_READ, MAP_PRIVATE, fd, 0);
 698   if (aux_cache == MAP_FAILED
 699       || aux_cache_size < sizeof (struct aux_cache_file)
 700       || memcmp (aux_cache->magic, AUX_CACHEMAGIC, sizeof AUX_CACHEMAGIC - 1)
 701       || aux_cache->nlibs >= aux_cache_size)
 702     {
 703       close (fd);
 704       init_aux_cache ();
 705       return;
 706     }
 707
 708   aux_hash_size = nextprime (aux_cache->nlibs);
 709   aux_hash = xcalloc (aux_hash_size, sizeof (struct aux_cache_entry *));
 710
 711   const char *aux_cache_data
 712     = (const char *) &aux_cache->libs[aux_cache->nlibs];
 713   for (unsigned int i = 0; i < aux_cache->nlibs; ++i)
 714     insert_to_aux_cache (&aux_cache->libs[i].id,
 715                          aux_cache->libs[i].flags,
 716                          aux_cache->libs[i].osversion,
 717                          aux_cache->libs[i].soname == 0
 718                          ? NULL : aux_cache_data + aux_cache->libs[i].soname,
 719                          0);
 720
 721   munmap (aux_cache, aux_cache_size);
 722   close (fd);
 723 }
 724
 725 /* Save the contents of the auxiliary cache.  */
 726 void
 727 save_aux_cache (const char *aux_cache_name)
 728 {
 729   /* Count the length of all sonames.  We start with empty string.  */
 730   size_t total_strlen = 1;
 731   /* Number of cache entries.  */
 732   int cache_entry_count = 0;
 733
 734   for (size_t i = 0; i < aux_hash_size; ++i)
 735     for (struct aux_cache_entry *entry = aux_hash[i];
 736          entry != NULL; entry = entry->next)
 737       if (entry->used)
 738         {
 739           ++cache_entry_count;
 740           if (entry->soname != NULL)
 741             total_strlen += strlen (entry->soname) + 1;
 742         }
 743
 744   /* Auxiliary cache.  */
 745   size_t file_entries_size
 746     = sizeof (struct aux_cache_file)
 747       + cache_entry_count * sizeof (struct aux_cache_file_entry);
 748   struct aux_cache_file *file_entries
 749     = xmalloc (file_entries_size + total_strlen);
 750
 751   /* Fill in the header of the auxiliary cache.  */
 752   memset (file_entries, '\0', sizeof (struct aux_cache_file));
 753   memcpy (file_entries->magic, AUX_CACHEMAGIC, sizeof AUX_CACHEMAGIC - 1);
 754
 755   file_entries->nlibs = cache_entry_count;
 756   file_entries->len_strings = total_strlen;
 757
 758   /* Initial String offset for auxiliary cache is always after the
 759      special empty string.  */
 760   unsigned int str_offset = 1;
 761
 762   /* An array for all strings.  */
 763   char *str = (char *) file_entries + file_entries_size;
 764   *str++ = '\0';
 765
 766   size_t idx = 0;
 767   for (size_t i = 0; i < aux_hash_size; ++i)
 768     for (struct aux_cache_entry *entry = aux_hash[i];
 769          entry != NULL; entry = entry->next)
 770       if (entry->used)
 771         {
 772           file_entries->libs[idx].id = entry->id;
 773           file_entries->libs[idx].flags = entry->flags;
 774           if (entry->soname == NULL)
 775             file_entries->libs[idx].soname = 0;
 776           else
 777             {
 778               file_entries->libs[idx].soname = str_offset;
 779
 780               size_t len = strlen (entry->soname) + 1;
 781               str = mempcpy (str, entry->soname, len);
 782               str_offset += len;
 783             }
 784           file_entries->libs[idx].osversion = entry->osversion;
 785           file_entries->libs[idx++].pad = 0;
 786         }
 787
 788   /* Write out auxiliary cache file.  */
 789   /* Write auxiliary cache first to a temporary file and rename it later.  */
 790
 791   char *temp_name = xmalloc (strlen (aux_cache_name) + 2);
 792   sprintf (temp_name, "%s~", aux_cache_name);
 793
 794   /* Check that directory exists and create if needed.  */
 795   char *dir = strdupa (aux_cache_name);
 796   dir = dirname (dir);
 797
 798   struct stat64 st;
 799   if (stat64 (dir, &st) < 0)
 800     {
 801       if (mkdir (dir, 0700) < 0)
 802         goto out_fail;
 803     }
 804
 805   /* Create file.  */
 806   int fd = open (temp_name, O_CREAT|O_WRONLY|O_TRUNC|O_NOFOLLOW,
 807                  S_IRUSR|S_IWUSR);
 808   if (fd < 0)
 809     goto out_fail;
 810
 811   if (write (fd, file_entries, file_entries_size + total_strlen)
 812       != (ssize_t) (file_entries_size + total_strlen)
 813       || close (fd))
 814     {
 815       unlink (temp_name);
 816       goto out_fail;
 817     }
 818
 819   /* Move temporary to its final location.  */
 820   if (rename (temp_name, aux_cache_name))
 821     unlink (temp_name);
 822
 823 out_fail:
 824   /* Free allocated memory.  */
 825   free (temp_name);
 826   free (file_entries);
 827 }