2005-12-25 Kristian Van Der Vliet <vanders@liqwyd.com>
[kopensolaris-gnu/glibc.git] / elf / cache.c
1 /* Copyright (C) 1999,2000,2001,2002,2003,2005
2         Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4    Contributed by Andreas Jaeger <aj@suse.de>, 1999.
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License version 2 as
8    published by the Free Software Foundation.
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           if (write (fd, zero, pad) != (ssize_t)pad)
434             error (EXIT_FAILURE, errno, _("Writing of cache data failed"));
435         }
436       if (write (fd, file_entries_new, file_entries_new_size)
437           != (ssize_t)file_entries_new_size)
438         error (EXIT_FAILURE, errno, _("Writing of cache data failed"));
439     }
440
441   if (write (fd, strings, total_strlen) != (ssize_t)total_strlen)
442     error (EXIT_FAILURE, errno, _("Writing of cache data failed."));
443
444   close (fd);
445
446   /* Make sure user can always read cache file */
447   if (chmod (temp_name, S_IROTH|S_IRGRP|S_IRUSR|S_IWUSR))
448     error (EXIT_FAILURE, errno,
449            _("Changing access rights of %s to %#o failed"), temp_name,
450            S_IROTH|S_IRGRP|S_IRUSR|S_IWUSR);
451
452   /* Move temporary to its final location.  */
453   if (rename (temp_name, cache_name))
454     error (EXIT_FAILURE, errno, _("Renaming of %s to %s failed"), temp_name,
455            cache_name);
456
457   /* Free all allocated memory.  */
458   free (file_entries);
459   free (strings);
460
461   while (entries)
462     {
463       entry = entries;
464       free (entry->path);
465       free (entry->lib);
466       entries = entries->next;
467       free (entry);
468     }
469 }
470
471
472 /* Add one library to the cache.  */
473 void
474 add_to_cache (const char *path, const char *lib, int flags,
475               unsigned int osversion, uint64_t hwcap)
476 {
477   struct cache_entry *new_entry, *ptr, *prev;
478   char *full_path;
479   size_t len, i;
480
481   new_entry = (struct cache_entry *) xmalloc (sizeof (struct cache_entry));
482
483   len = strlen (lib) + strlen (path) + 2;
484
485   full_path = (char *) xmalloc (len);
486   snprintf (full_path, len, "%s/%s", path, lib);
487
488   new_entry->lib = xstrdup (lib);
489   new_entry->path = full_path;
490   new_entry->flags = flags;
491   new_entry->osversion = osversion;
492   new_entry->hwcap = hwcap;
493   new_entry->bits_hwcap = 0;
494
495   /* Count the number of bits set in the masked value.  */
496   for (i = 0; (~((1ULL << i) - 1) & hwcap) != 0 && i < 8 * sizeof (hwcap); ++i)
497     if ((hwcap & (1ULL << i)) != 0)
498       ++new_entry->bits_hwcap;
499
500
501   /* Keep the list sorted - search for right place to insert.  */
502   ptr = entries;
503   prev = entries;
504   while (ptr != NULL)
505     {
506       if (compare (ptr, new_entry) > 0)
507         break;
508       prev = ptr;
509       ptr = ptr->next;
510     }
511   /* Is this the first entry?  */
512   if (ptr == entries)
513     {
514       new_entry->next = entries;
515       entries = new_entry;
516     }
517   else
518     {
519       new_entry->next = prev->next;
520       prev->next = new_entry;
521     }
522 }