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