1 /* Copyright (C) 1999-2021 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3 Contributed by Andreas Jaeger <aj@suse.de>, 1999.
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.
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.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, see <https://www.gnu.org/licenses/>. */
30 #include <sys/fcntl.h>
32 #include <sys/param.h>
34 #include <sys/types.h>
39 #include <stringtable.h>
41 /* Used to store library names, paths, and other strings. */
42 static struct stringtable strings
;
44 /* Keeping track of "glibc-hwcaps" subdirectories. During cache
45 construction, a linear search by name is performed to deduplicate
47 struct glibc_hwcaps_subdirectory
49 struct glibc_hwcaps_subdirectory
*next
;
51 /* Interned string with the subdirectory name. */
52 struct stringtable_entry
*name
;
54 /* Array index in the cache_extension_tag_glibc_hwcaps section in
55 the stored cached file. This is computed after all the
56 subdirectories have been processed, so that subdirectory names in
57 the extension section can be sorted. */
58 uint32_t section_index
;
60 /* True if the subdirectory is actually used for anything. */
65 glibc_hwcaps_subdirectory_name (const struct glibc_hwcaps_subdirectory
*dir
)
67 return dir
->name
->string
;
70 /* Linked list of known hwcaps subdirecty names. */
71 static struct glibc_hwcaps_subdirectory
*hwcaps
;
73 struct glibc_hwcaps_subdirectory
*
74 new_glibc_hwcaps_subdirectory (const char *name
)
76 struct stringtable_entry
*name_interned
= stringtable_add (&strings
, name
);
77 for (struct glibc_hwcaps_subdirectory
*p
= hwcaps
; p
!= NULL
; p
= p
->next
)
78 if (p
->name
== name_interned
)
80 struct glibc_hwcaps_subdirectory
*p
= xmalloc (sizeof (*p
));
82 p
->name
= name_interned
;
89 /* Helper for sorting struct glibc_hwcaps_subdirectory elements by
92 assign_glibc_hwcaps_indices_compare (const void *l
, const void *r
)
94 const struct glibc_hwcaps_subdirectory
*left
95 = *(struct glibc_hwcaps_subdirectory
**)l
;
96 const struct glibc_hwcaps_subdirectory
*right
97 = *(struct glibc_hwcaps_subdirectory
**)r
;
98 return strcmp (glibc_hwcaps_subdirectory_name (left
),
99 glibc_hwcaps_subdirectory_name (right
));
102 /* Count the number of hwcaps subdirectories which are actually
105 glibc_hwcaps_count (void)
108 for (struct glibc_hwcaps_subdirectory
*p
= hwcaps
; p
!= NULL
; p
= p
->next
)
114 /* Compute the section_index fields for all */
116 assign_glibc_hwcaps_indices (void)
118 /* Convert the linked list into an array, so that we can use qsort.
119 Only copy the subdirectories which are actually used. */
120 size_t count
= glibc_hwcaps_count ();
121 struct glibc_hwcaps_subdirectory
**array
122 = xmalloc (sizeof (*array
) * count
);
125 for (struct glibc_hwcaps_subdirectory
*p
= hwcaps
; p
!= NULL
; p
= p
->next
)
134 qsort (array
, count
, sizeof (*array
), assign_glibc_hwcaps_indices_compare
);
136 /* Assign the array indices. */
137 for (size_t i
= 0; i
< count
; ++i
)
138 array
[i
]->section_index
= i
;
145 struct stringtable_entry
*lib
; /* Library name. */
146 struct stringtable_entry
*path
; /* Path to find library. */
147 int flags
; /* Flags to indicate kind of library. */
148 unsigned int osversion
; /* Required OS version. */
149 unsigned int isa_level
; /* Required ISA level. */
150 uint64_t hwcap
; /* Important hardware capabilities. */
151 int bits_hwcap
; /* Number of bits set in hwcap. */
153 /* glibc-hwcaps subdirectory. If not NULL, hwcap must be zero. */
154 struct glibc_hwcaps_subdirectory
*hwcaps
;
156 struct cache_entry
*next
; /* Next entry in list. */
159 /* List of all cache entries. */
160 static struct cache_entry
*entries
;
162 static const char *flag_descr
[] =
163 { "libc4", "ELF", "libc5", "libc6"};
165 /* Print a single entry. */
167 print_entry (const char *lib
, int flag
, unsigned int osversion
,
168 uint64_t hwcap
, const char *hwcap_string
, const char *key
)
170 printf ("\t%s (", lib
);
171 switch (flag
& FLAG_TYPE_MASK
)
177 fputs (flag_descr
[flag
& FLAG_TYPE_MASK
], stdout
);
180 fputs (_("unknown"), stdout
);
183 switch (flag
& FLAG_REQUIRED_MASK
)
185 case FLAG_SPARC_LIB64
:
186 fputs (",64bit", stdout
);
188 case FLAG_IA64_LIB64
:
189 fputs (",IA-64", stdout
);
191 case FLAG_X8664_LIB64
:
192 fputs (",x86-64", stdout
);
194 case FLAG_S390_LIB64
:
195 fputs (",64bit", stdout
);
197 case FLAG_POWERPC_LIB64
:
198 fputs (",64bit", stdout
);
200 case FLAG_MIPS64_LIBN32
:
201 fputs (",N32", stdout
);
203 case FLAG_MIPS64_LIBN64
:
204 fputs (",64bit", stdout
);
206 case FLAG_X8664_LIBX32
:
207 fputs (",x32", stdout
);
210 fputs (",hard-float", stdout
);
212 case FLAG_AARCH64_LIB64
:
213 fputs (",AArch64", stdout
);
215 /* Uses the ARM soft-float ABI. */
217 fputs (",soft-float", stdout
);
219 case FLAG_MIPS_LIB32_NAN2008
:
220 fputs (",nan2008", stdout
);
222 case FLAG_MIPS64_LIBN32_NAN2008
:
223 fputs (",N32,nan2008", stdout
);
225 case FLAG_MIPS64_LIBN64_NAN2008
:
226 fputs (",64bit,nan2008", stdout
);
228 case FLAG_RISCV_FLOAT_ABI_SOFT
:
229 fputs (",soft-float", stdout
);
231 case FLAG_RISCV_FLOAT_ABI_DOUBLE
:
232 fputs (",double-float", stdout
);
237 printf (",%d", flag
& FLAG_REQUIRED_MASK
);
240 if (hwcap_string
!= NULL
)
241 printf (", hwcap: \"%s\"", hwcap_string
);
243 printf (", hwcap: %#.16" PRIx64
, hwcap
);
246 static const char *const abi_tag_os
[] =
254 [6] = N_("Unknown OS")
256 #define MAXTAG (sizeof abi_tag_os / sizeof abi_tag_os[0] - 1)
257 unsigned int os
= osversion
>> 24;
259 printf (_(", OS ABI: %s %d.%d.%d"),
260 _(abi_tag_os
[os
> MAXTAG
? MAXTAG
: os
]),
261 (osversion
>> 16) & 0xff,
262 (osversion
>> 8) & 0xff,
265 printf (") => %s\n", key
);
268 /* Returns the string with the name of the glibcs-hwcaps subdirectory
269 associated with ENTRY->hwcap. file_base must be the base address
270 for string table indices. */
272 glibc_hwcaps_string (struct cache_extension_all_loaded
*ext
,
273 const void *file_base
, size_t file_size
,
274 struct file_entry_new
*entry
)
276 const uint32_t *hwcaps_array
277 = ext
->sections
[cache_extension_tag_glibc_hwcaps
].base
;
278 if (dl_cache_hwcap_extension (entry
) && hwcaps_array
!= NULL
)
280 uint32_t index
= (uint32_t) entry
->hwcap
;
281 if (index
< ext
->sections
[cache_extension_tag_glibc_hwcaps
].size
/ 4)
283 uint32_t string_table_index
= hwcaps_array
[index
];
284 if (string_table_index
< file_size
)
285 return file_base
+ string_table_index
;
291 /* Print an error and exit if the new-file cache is internally
294 check_new_cache (struct cache_file_new
*cache
)
296 if (! cache_file_new_matches_endian (cache
))
297 error (EXIT_FAILURE
, 0, _("Cache file has wrong endianness.\n"));
300 /* Print the extension information in *EXT. */
302 print_extensions (struct cache_extension_all_loaded
*ext
)
304 if (ext
->sections
[cache_extension_tag_generator
].base
!= NULL
)
306 fputs (_("Cache generated by: "), stdout
);
307 fwrite (ext
->sections
[cache_extension_tag_generator
].base
, 1,
308 ext
->sections
[cache_extension_tag_generator
].size
, stdout
);
313 /* Print the whole cache file, if a file contains the new cache format
314 hidden in the old one, print the contents of the new format. */
316 print_cache (const char *cache_name
)
318 int fd
= open (cache_name
, O_RDONLY
);
320 error (EXIT_FAILURE
, errno
, _("Can't open cache file %s\n"), cache_name
);
323 if (__fstat64 (fd
, &st
) < 0
324 /* No need to map the file if it is empty. */
331 struct cache_file
*cache
332 = mmap (NULL
, st
.st_size
, PROT_READ
, MAP_PRIVATE
, fd
, 0);
333 if (cache
== MAP_FAILED
)
334 error (EXIT_FAILURE
, errno
, _("mmap of cache file failed.\n"));
336 size_t cache_size
= st
.st_size
;
337 if (cache_size
< sizeof (struct cache_file
))
338 error (EXIT_FAILURE
, 0, _("File is not a cache file.\n"));
340 struct cache_file_new
*cache_new
= NULL
;
341 const char *cache_data
;
344 if (memcmp (cache
->magic
, CACHEMAGIC
, sizeof CACHEMAGIC
- 1))
346 /* This can only be the new format without the old one. */
347 cache_new
= (struct cache_file_new
*) cache
;
349 if (memcmp (cache_new
->magic
, CACHEMAGIC_NEW
, sizeof CACHEMAGIC_NEW
- 1)
350 || memcmp (cache_new
->version
, CACHE_VERSION
,
351 sizeof CACHE_VERSION
- 1))
352 error (EXIT_FAILURE
, 0, _("File is not a cache file.\n"));
353 check_new_cache (cache_new
);
355 /* This is where the strings start. */
356 cache_data
= (const char *) cache_new
;
360 /* Check for corruption, avoiding overflow. */
361 if ((cache_size
- sizeof (struct cache_file
)) / sizeof (struct file_entry
)
363 error (EXIT_FAILURE
, 0, _("File is not a cache file.\n"));
365 size_t offset
= ALIGN_CACHE (sizeof (struct cache_file
)
367 * sizeof (struct file_entry
)));
368 /* This is where the strings start. */
369 cache_data
= (const char *) &cache
->libs
[cache
->nlibs
];
371 /* Check for a new cache embedded in the old format. */
373 > (offset
+ sizeof (struct cache_file_new
)))
376 cache_new
= (struct cache_file_new
*) ((void *)cache
+ offset
);
378 if (memcmp (cache_new
->magic
, CACHEMAGIC_NEW
,
379 sizeof CACHEMAGIC_NEW
- 1) == 0
380 && memcmp (cache_new
->version
, CACHE_VERSION
,
381 sizeof CACHE_VERSION
- 1) == 0)
383 check_new_cache (cache_new
);
384 cache_data
= (const char *) cache_new
;
392 printf (_("%d libs found in cache `%s'\n"), cache
->nlibs
, cache_name
);
394 /* Print everything. */
395 for (unsigned int i
= 0; i
< cache
->nlibs
; i
++)
396 print_entry (cache_data
+ cache
->libs
[i
].key
,
397 cache
->libs
[i
].flags
, 0, 0, NULL
,
398 cache_data
+ cache
->libs
[i
].value
);
400 else if (format
== 1)
402 struct cache_extension_all_loaded ext
;
403 if (!cache_extension_load (cache_new
, cache
, cache_size
, &ext
))
404 error (EXIT_FAILURE
, 0,
405 _("Malformed extension data in cache file %s\n"), cache_name
);
407 printf (_("%d libs found in cache `%s'\n"),
408 cache_new
->nlibs
, cache_name
);
410 /* Print everything. */
411 for (unsigned int i
= 0; i
< cache_new
->nlibs
; i
++)
413 const char *hwcaps_string
414 = glibc_hwcaps_string (&ext
, cache
, cache_size
,
415 &cache_new
->libs
[i
]);
416 print_entry (cache_data
+ cache_new
->libs
[i
].key
,
417 cache_new
->libs
[i
].flags
,
418 cache_new
->libs
[i
].osversion
,
419 cache_new
->libs
[i
].hwcap
, hwcaps_string
,
420 cache_data
+ cache_new
->libs
[i
].value
);
422 print_extensions (&ext
);
425 munmap (cache
, cache_size
);
429 /* Initialize cache data structures. */
437 compare (const struct cache_entry
*e1
, const struct cache_entry
*e2
)
439 /* We need to swap entries here to get the correct sort order. */
440 int res
= _dl_cache_libcmp (e2
->lib
->string
, e1
->lib
->string
);
443 if (e1
->flags
< e2
->flags
)
445 else if (e1
->flags
> e2
->flags
)
447 /* Keep the glibc-hwcaps extension entries before the regular
448 entries, and sort them by their names. search_cache in
449 dl-cache.c stops searching once the first non-extension entry
450 is found, so the extension entries need to come first. */
451 else if (e1
->hwcaps
!= NULL
&& e2
->hwcaps
== NULL
)
453 else if (e1
->hwcaps
== NULL
&& e2
->hwcaps
!= NULL
)
455 else if (e1
->hwcaps
!= NULL
&& e2
->hwcaps
!= NULL
)
457 res
= strcmp (glibc_hwcaps_subdirectory_name (e1
->hwcaps
),
458 glibc_hwcaps_subdirectory_name (e2
->hwcaps
));
462 /* Sort by most specific hwcap. */
463 if (e2
->bits_hwcap
> e1
->bits_hwcap
)
465 else if (e2
->bits_hwcap
< e1
->bits_hwcap
)
467 else if (e2
->hwcap
> e1
->hwcap
)
469 else if (e2
->hwcap
< e1
->hwcap
)
471 if (e2
->osversion
> e1
->osversion
)
473 if (e2
->osversion
< e1
->osversion
)
479 /* Size of the cache extension directory. All tags are assumed to be
483 cache_extension_size
= (offsetof (struct cache_extension
, sections
)
484 + (cache_extension_count
485 * sizeof (struct cache_extension_section
)))
488 /* Write the cache extensions to FD. The string table is shifted by
489 STRING_TABLE_OFFSET. The extension directory is assumed to be
490 located at CACHE_EXTENSION_OFFSET. assign_glibc_hwcaps_indices
491 must have been called. */
493 write_extensions (int fd
, uint32_t str_offset
,
494 uint32_t cache_extension_offset
)
496 assert ((cache_extension_offset
% 4) == 0);
498 /* The length and contents of the glibc-hwcaps section. */
499 uint32_t hwcaps_count
= glibc_hwcaps_count ();
500 uint32_t hwcaps_offset
= cache_extension_offset
+ cache_extension_size
;
501 uint32_t hwcaps_size
= hwcaps_count
* sizeof (uint32_t);
502 uint32_t *hwcaps_array
= xmalloc (hwcaps_size
);
503 for (struct glibc_hwcaps_subdirectory
*p
= hwcaps
; p
!= NULL
; p
= p
->next
)
505 hwcaps_array
[p
->section_index
] = str_offset
+ p
->name
->offset
;
507 /* This is the offset of the generator string. */
508 uint32_t generator_offset
= hwcaps_offset
;
509 if (hwcaps_count
== 0)
510 /* There is no section for the hwcaps subdirectories. */
511 generator_offset
-= sizeof (struct cache_extension_section
);
513 /* The string table indices for the hwcaps subdirectories shift
514 the generator string backwards. */
515 generator_offset
+= hwcaps_size
;
517 struct cache_extension
*ext
= xmalloc (cache_extension_size
);
518 ext
->magic
= cache_extension_magic
;
520 /* Extension index current being filled. */
523 const char *generator
524 = "ldconfig " PKGVERSION RELEASE
" release version " VERSION
;
525 ext
->sections
[xid
].tag
= cache_extension_tag_generator
;
526 ext
->sections
[xid
].flags
= 0;
527 ext
->sections
[xid
].offset
= generator_offset
;
528 ext
->sections
[xid
].size
= strlen (generator
);
530 if (hwcaps_count
> 0)
533 ext
->sections
[xid
].tag
= cache_extension_tag_glibc_hwcaps
;
534 ext
->sections
[xid
].flags
= 0;
535 ext
->sections
[xid
].offset
= hwcaps_offset
;
536 ext
->sections
[xid
].size
= hwcaps_size
;
541 assert (xid
<= cache_extension_count
);
543 size_t ext_size
= (offsetof (struct cache_extension
, sections
)
544 + xid
* sizeof (struct cache_extension_section
));
545 if (write (fd
, ext
, ext_size
) != ext_size
546 || write (fd
, hwcaps_array
, hwcaps_size
) != hwcaps_size
547 || write (fd
, generator
, strlen (generator
)) != strlen (generator
))
548 error (EXIT_FAILURE
, errno
, _("Writing of cache extension data failed"));
554 /* Compute the hwcap value from ENTRY. */
555 static inline uint64_t
556 compute_hwcap_value (struct cache_entry
*entry
)
558 if (entry
->isa_level
> DL_CACHE_HWCAP_ISA_LEVEL_MASK
)
559 error (EXIT_FAILURE
, 0, _("%s: ISA level is too high (%d > %d)"),
560 entry
->path
->string
, entry
->isa_level
,
561 DL_CACHE_HWCAP_ISA_LEVEL_MASK
);
562 return (DL_CACHE_HWCAP_EXTENSION
563 | (((uint64_t) entry
->isa_level
) << 32)
564 | entry
->hwcaps
->section_index
);
567 /* Save the contents of the cache. */
569 save_cache (const char *cache_name
)
571 /* The cache entries are sorted already, save them in this order. */
573 assign_glibc_hwcaps_indices ();
575 struct cache_entry
*entry
;
576 /* Number of cache entries. */
577 int cache_entry_count
= 0;
578 /* The old format doesn't contain hwcap entries and doesn't contain
579 libraries in subdirectories with hwcaps entries. Count therefore
580 also all entries with hwcap == 0. */
581 int cache_entry_old_count
= 0;
583 for (entry
= entries
; entry
!= NULL
; entry
= entry
->next
)
586 if (entry
->hwcap
== 0)
587 ++cache_entry_old_count
;
590 struct stringtable_finalized strings_finalized
;
591 stringtable_finalize (&strings
, &strings_finalized
);
593 /* Create the on disk cache structure. */
594 struct cache_file
*file_entries
= NULL
;
595 size_t file_entries_size
= 0;
597 if (opt_format
!= opt_format_new
)
599 /* struct cache_file_new is 64-bit aligned on some arches while
600 only 32-bit aligned on other arches. Duplicate last old
601 cache entry so that new cache in ld.so.cache can be used by
603 if (opt_format
!= opt_format_old
)
604 cache_entry_old_count
= (cache_entry_old_count
+ 1) & ~1;
606 /* And the list of all entries in the old format. */
607 file_entries_size
= sizeof (struct cache_file
)
608 + cache_entry_old_count
* sizeof (struct file_entry
);
609 file_entries
= xmalloc (file_entries_size
);
611 /* Fill in the header. */
612 memset (file_entries
, '\0', sizeof (struct cache_file
));
613 memcpy (file_entries
->magic
, CACHEMAGIC
, sizeof CACHEMAGIC
- 1);
615 file_entries
->nlibs
= cache_entry_old_count
;
618 struct cache_file_new
*file_entries_new
= NULL
;
619 size_t file_entries_new_size
= 0;
621 if (opt_format
!= opt_format_old
)
623 /* And the list of all entries in the new format. */
624 file_entries_new_size
= sizeof (struct cache_file_new
)
625 + cache_entry_count
* sizeof (struct file_entry_new
);
626 file_entries_new
= xmalloc (file_entries_new_size
);
628 /* Fill in the header. */
629 memset (file_entries_new
, '\0', sizeof (struct cache_file_new
));
630 memcpy (file_entries_new
->magic
, CACHEMAGIC_NEW
,
631 sizeof CACHEMAGIC_NEW
- 1);
632 memcpy (file_entries_new
->version
, CACHE_VERSION
,
633 sizeof CACHE_VERSION
- 1);
635 file_entries_new
->nlibs
= cache_entry_count
;
636 file_entries_new
->len_strings
= strings_finalized
.size
;
637 file_entries_new
->flags
= cache_file_new_flags_endian_current
;
640 /* Pad for alignment of cache_file_new. */
641 size_t pad
= ALIGN_CACHE (file_entries_size
) - file_entries_size
;
643 /* If we have both formats, we hide the new format in the strings
644 table, we have to adjust all string indices for this so that
645 old libc5/glibc 2 dynamic linkers just ignore them. */
646 unsigned int str_offset
;
647 if (opt_format
!= opt_format_old
)
648 str_offset
= file_entries_new_size
;
652 /* An array for all strings. */
656 for (idx_old
= 0, idx_new
= 0, entry
= entries
; entry
!= NULL
;
657 entry
= entry
->next
, ++idx_new
)
659 if (opt_format
!= opt_format_new
&& entry
->hwcap
== 0)
661 file_entries
->libs
[idx_old
].flags
= entry
->flags
;
662 /* XXX: Actually we can optimize here and remove duplicates. */
663 file_entries
->libs
[idx_old
].key
= str_offset
+ pad
;
664 file_entries
->libs
[idx_new
].key
= str_offset
+ entry
->lib
->offset
;
665 file_entries
->libs
[idx_new
].value
666 = str_offset
+ entry
->path
->offset
;
668 if (opt_format
!= opt_format_old
)
670 /* We could subtract file_entries_new_size from str_offset -
671 not doing so makes the code easier, the string table
672 always begins at the beginning of the new cache
674 file_entries_new
->libs
[idx_new
].flags
= entry
->flags
;
675 file_entries_new
->libs
[idx_new
].osversion
= entry
->osversion
;
676 if (entry
->hwcaps
== NULL
)
677 file_entries_new
->libs
[idx_new
].hwcap
= entry
->hwcap
;
679 file_entries_new
->libs
[idx_new
].hwcap
680 = compute_hwcap_value (entry
);
681 file_entries_new
->libs
[idx_new
].key
682 = str_offset
+ entry
->lib
->offset
;
683 file_entries_new
->libs
[idx_new
].value
684 = str_offset
+ entry
->path
->offset
;
687 /* Ignore entries with hwcap for old format. */
688 if (entry
->hwcap
== 0)
692 /* Duplicate last old cache entry if needed. */
693 if (opt_format
!= opt_format_new
694 && idx_old
< cache_entry_old_count
)
695 file_entries
->libs
[idx_old
] = file_entries
->libs
[idx_old
- 1];
697 /* Compute the location of the extension directory. This
698 implementation puts the directory after the string table. The
699 size computation matches the write calls below. The extension
700 directory does not exist with format 0, so the value does not
702 uint32_t extension_offset
= 0;
703 if (opt_format
!= opt_format_new
)
704 extension_offset
+= file_entries_size
;
705 if (opt_format
!= opt_format_old
)
707 if (opt_format
!= opt_format_new
)
708 extension_offset
+= pad
;
709 extension_offset
+= file_entries_new_size
;
711 extension_offset
+= strings_finalized
.size
;
712 extension_offset
= roundup (extension_offset
, 4); /* Provide alignment. */
713 if (opt_format
!= opt_format_old
)
714 file_entries_new
->extension_offset
= extension_offset
;
716 /* Write out the cache. */
718 /* Write cache first to a temporary file and rename it later. */
719 char *temp_name
= xmalloc (strlen (cache_name
) + 2);
720 sprintf (temp_name
, "%s~", cache_name
);
723 int fd
= open (temp_name
, O_CREAT
|O_WRONLY
|O_TRUNC
|O_NOFOLLOW
,
726 error (EXIT_FAILURE
, errno
, _("Can't create temporary cache file %s"),
729 /* Write contents. */
730 if (opt_format
!= opt_format_new
)
732 if (write (fd
, file_entries
, file_entries_size
)
733 != (ssize_t
) file_entries_size
)
734 error (EXIT_FAILURE
, errno
, _("Writing of cache data failed"));
736 if (opt_format
!= opt_format_old
)
739 if (opt_format
!= opt_format_new
)
742 memset (zero
, '\0', pad
);
743 if (write (fd
, zero
, pad
) != (ssize_t
) pad
)
744 error (EXIT_FAILURE
, errno
, _("Writing of cache data failed"));
746 if (write (fd
, file_entries_new
, file_entries_new_size
)
747 != (ssize_t
) file_entries_new_size
)
748 error (EXIT_FAILURE
, errno
, _("Writing of cache data failed"));
751 if (write (fd
, strings_finalized
.strings
, strings_finalized
.size
)
752 != (ssize_t
) strings_finalized
.size
)
753 error (EXIT_FAILURE
, errno
, _("Writing of cache data failed"));
755 if (opt_format
!= opt_format_old
)
757 /* Align file position to 4. */
758 off64_t old_offset
= lseek64 (fd
, extension_offset
, SEEK_SET
);
759 assert ((unsigned long long int) (extension_offset
- old_offset
) < 4);
760 write_extensions (fd
, str_offset
, extension_offset
);
763 /* Make sure user can always read cache file */
764 if (chmod (temp_name
, S_IROTH
|S_IRGRP
|S_IRUSR
|S_IWUSR
))
765 error (EXIT_FAILURE
, errno
,
766 _("Changing access rights of %s to %#o failed"), temp_name
,
767 S_IROTH
|S_IRGRP
|S_IRUSR
|S_IWUSR
);
769 /* Make sure that data is written to disk. */
770 if (fsync (fd
) != 0 || close (fd
) != 0)
771 error (EXIT_FAILURE
, errno
, _("Writing of cache data failed"));
773 /* Move temporary to its final location. */
774 if (rename (temp_name
, cache_name
))
775 error (EXIT_FAILURE
, errno
, _("Renaming of %s to %s failed"), temp_name
,
778 /* Free all allocated memory. */
779 free (file_entries_new
);
781 free (strings_finalized
.strings
);
787 entries
= entries
->next
;
793 /* Add one library to the cache. */
795 add_to_cache (const char *path
, const char *filename
, const char *soname
,
796 int flags
, unsigned int osversion
,
797 unsigned int isa_level
, uint64_t hwcap
,
798 struct glibc_hwcaps_subdirectory
*hwcaps
)
800 struct cache_entry
*new_entry
= xmalloc (sizeof (*new_entry
));
802 struct stringtable_entry
*path_interned
;
805 if (asprintf (&p
, "%s/%s", path
, filename
) < 0)
806 error (EXIT_FAILURE
, errno
, _("Could not create library path"));
807 path_interned
= stringtable_add (&strings
, p
);
811 new_entry
->lib
= stringtable_add (&strings
, soname
);
812 new_entry
->path
= path_interned
;
813 new_entry
->flags
= flags
;
814 new_entry
->osversion
= osversion
;
815 new_entry
->isa_level
= isa_level
;
816 new_entry
->hwcap
= hwcap
;
817 new_entry
->hwcaps
= hwcaps
;
818 new_entry
->bits_hwcap
= 0;
826 /* Count the number of bits set in the masked value. */
828 (~((1ULL << i
) - 1) & hwcap
) != 0 && i
< 8 * sizeof (hwcap
); ++i
)
829 if ((hwcap
& (1ULL << i
)) != 0)
830 ++new_entry
->bits_hwcap
;
833 /* Keep the list sorted - search for right place to insert. */
834 struct cache_entry
*ptr
= entries
;
835 struct cache_entry
*prev
= entries
;
838 if (compare (ptr
, new_entry
) > 0)
843 /* Is this the first entry? */
846 new_entry
->next
= entries
;
851 new_entry
->next
= prev
->next
;
852 prev
->next
= new_entry
;
857 /* Auxiliary cache. */
859 struct aux_cache_entry_id
867 struct aux_cache_entry
869 struct aux_cache_entry_id id
;
871 unsigned int osversion
;
872 unsigned int isa_level
;
875 struct aux_cache_entry
*next
;
878 #define AUX_CACHEMAGIC "glibc-ld.so.auxcache-1.0"
880 struct aux_cache_file_entry
882 struct aux_cache_entry_id id
; /* Unique id of entry. */
883 int32_t flags
; /* This is 1 for an ELF library. */
884 uint32_t soname
; /* String table indice. */
885 uint32_t osversion
; /* Required OS version. */
886 uint32_t isa_level
; /* Required ISA level. */
889 /* ldconfig maintains an auxiliary cache file that allows
890 only reading those libraries that have changed since the last iteration.
891 For this for each library some information is cached in the auxiliary
893 struct aux_cache_file
895 char magic
[sizeof AUX_CACHEMAGIC
- 1];
896 uint32_t nlibs
; /* Number of entries. */
897 uint32_t len_strings
; /* Size of string table. */
898 struct aux_cache_file_entry libs
[0]; /* Entries describing libraries. */
899 /* After this the string table of size len_strings is found. */
902 static const unsigned int primes
[] =
904 1021, 2039, 4093, 8191, 16381, 32749, 65521, 131071, 262139,
905 524287, 1048573, 2097143, 4194301, 8388593, 16777213, 33554393,
906 67108859, 134217689, 268435399, 536870909, 1073741789, 2147483647
909 static size_t aux_hash_size
;
910 static struct aux_cache_entry
**aux_hash
;
912 /* Simplistic hash function for aux_cache_entry_id. */
914 aux_cache_entry_id_hash (struct aux_cache_entry_id
*id
)
916 uint64_t ret
= ((id
->ino
* 11 + id
->ctime
) * 11 + id
->size
) * 11 + id
->dev
;
917 return ret
^ (ret
>> 32);
920 static size_t nextprime (size_t x
)
922 for (unsigned int i
= 0; i
< sizeof (primes
) / sizeof (primes
[0]); ++i
)
929 init_aux_cache (void)
931 aux_hash_size
= primes
[3];
932 aux_hash
= xcalloc (aux_hash_size
, sizeof (struct aux_cache_entry
*));
936 search_aux_cache (struct stat64
*stat_buf
, int *flags
,
937 unsigned int *osversion
, unsigned int *isa_level
,
940 struct aux_cache_entry_id id
;
941 id
.ino
= (uint64_t) stat_buf
->st_ino
;
942 id
.ctime
= (uint64_t) stat_buf
->st_ctime
;
943 id
.size
= (uint64_t) stat_buf
->st_size
;
944 id
.dev
= (uint64_t) stat_buf
->st_dev
;
946 unsigned int hash
= aux_cache_entry_id_hash (&id
);
947 struct aux_cache_entry
*entry
;
948 for (entry
= aux_hash
[hash
% aux_hash_size
]; entry
; entry
= entry
->next
)
949 if (id
.ino
== entry
->id
.ino
950 && id
.ctime
== entry
->id
.ctime
951 && id
.size
== entry
->id
.size
952 && id
.dev
== entry
->id
.dev
)
954 *flags
= entry
->flags
;
955 *osversion
= entry
->osversion
;
956 *isa_level
= entry
->isa_level
;
957 if (entry
->soname
!= NULL
)
958 *soname
= xstrdup (entry
->soname
);
969 insert_to_aux_cache (struct aux_cache_entry_id
*id
, int flags
,
970 unsigned int osversion
, unsigned int isa_level
,
971 const char *soname
, int used
)
973 size_t hash
= aux_cache_entry_id_hash (id
) % aux_hash_size
;
974 struct aux_cache_entry
*entry
;
975 for (entry
= aux_hash
[hash
]; entry
; entry
= entry
->next
)
976 if (id
->ino
== entry
->id
.ino
977 && id
->ctime
== entry
->id
.ctime
978 && id
->size
== entry
->id
.size
979 && id
->dev
== entry
->id
.dev
)
982 size_t len
= soname
? strlen (soname
) + 1 : 0;
983 entry
= xmalloc (sizeof (struct aux_cache_entry
) + len
);
985 entry
->flags
= flags
;
986 entry
->osversion
= osversion
;
987 entry
->isa_level
= isa_level
;
990 entry
->soname
= memcpy ((char *) (entry
+ 1), soname
, len
);
992 entry
->soname
= NULL
;
993 entry
->next
= aux_hash
[hash
];
994 aux_hash
[hash
] = entry
;
998 add_to_aux_cache (struct stat64
*stat_buf
, int flags
,
999 unsigned int osversion
, unsigned int isa_level
,
1002 struct aux_cache_entry_id id
;
1003 id
.ino
= (uint64_t) stat_buf
->st_ino
;
1004 id
.ctime
= (uint64_t) stat_buf
->st_ctime
;
1005 id
.size
= (uint64_t) stat_buf
->st_size
;
1006 id
.dev
= (uint64_t) stat_buf
->st_dev
;
1007 insert_to_aux_cache (&id
, flags
, osversion
, isa_level
, soname
, 1);
1010 /* Load auxiliary cache to search for unchanged entries. */
1012 load_aux_cache (const char *aux_cache_name
)
1014 int fd
= open (aux_cache_name
, O_RDONLY
);
1022 if (__fstat64 (fd
, &st
) < 0 || st
.st_size
< sizeof (struct aux_cache_file
))
1029 size_t aux_cache_size
= st
.st_size
;
1030 struct aux_cache_file
*aux_cache
1031 = mmap (NULL
, aux_cache_size
, PROT_READ
, MAP_PRIVATE
, fd
, 0);
1032 if (aux_cache
== MAP_FAILED
1033 || aux_cache_size
< sizeof (struct aux_cache_file
)
1034 || memcmp (aux_cache
->magic
, AUX_CACHEMAGIC
, sizeof AUX_CACHEMAGIC
- 1)
1035 || aux_cache_size
!= (sizeof (struct aux_cache_file
)
1036 + aux_cache
->nlibs
* sizeof (struct aux_cache_file_entry
)
1037 + aux_cache
->len_strings
))
1039 if (aux_cache
!= MAP_FAILED
)
1040 munmap (aux_cache
, aux_cache_size
);
1047 aux_hash_size
= nextprime (aux_cache
->nlibs
);
1048 aux_hash
= xcalloc (aux_hash_size
, sizeof (struct aux_cache_entry
*));
1050 const char *aux_cache_data
1051 = (const char *) &aux_cache
->libs
[aux_cache
->nlibs
];
1052 for (unsigned int i
= 0; i
< aux_cache
->nlibs
; ++i
)
1053 insert_to_aux_cache (&aux_cache
->libs
[i
].id
,
1054 aux_cache
->libs
[i
].flags
,
1055 aux_cache
->libs
[i
].osversion
,
1056 aux_cache
->libs
[i
].isa_level
,
1057 aux_cache
->libs
[i
].soname
== 0
1058 ? NULL
: aux_cache_data
+ aux_cache
->libs
[i
].soname
,
1061 munmap (aux_cache
, aux_cache_size
);
1065 /* Save the contents of the auxiliary cache. */
1067 save_aux_cache (const char *aux_cache_name
)
1069 /* Count the length of all sonames. We start with empty string. */
1070 size_t total_strlen
= 1;
1071 /* Number of cache entries. */
1072 int cache_entry_count
= 0;
1074 for (size_t i
= 0; i
< aux_hash_size
; ++i
)
1075 for (struct aux_cache_entry
*entry
= aux_hash
[i
];
1076 entry
!= NULL
; entry
= entry
->next
)
1079 ++cache_entry_count
;
1080 if (entry
->soname
!= NULL
)
1081 total_strlen
+= strlen (entry
->soname
) + 1;
1084 /* Auxiliary cache. */
1085 size_t file_entries_size
1086 = sizeof (struct aux_cache_file
)
1087 + cache_entry_count
* sizeof (struct aux_cache_file_entry
);
1088 struct aux_cache_file
*file_entries
1089 = xmalloc (file_entries_size
+ total_strlen
);
1091 /* Fill in the header of the auxiliary cache. */
1092 memset (file_entries
, '\0', sizeof (struct aux_cache_file
));
1093 memcpy (file_entries
->magic
, AUX_CACHEMAGIC
, sizeof AUX_CACHEMAGIC
- 1);
1095 file_entries
->nlibs
= cache_entry_count
;
1096 file_entries
->len_strings
= total_strlen
;
1098 /* Initial String offset for auxiliary cache is always after the
1099 special empty string. */
1100 unsigned int str_offset
= 1;
1102 /* An array for all strings. */
1103 char *str
= (char *) file_entries
+ file_entries_size
;
1107 for (size_t i
= 0; i
< aux_hash_size
; ++i
)
1108 for (struct aux_cache_entry
*entry
= aux_hash
[i
];
1109 entry
!= NULL
; entry
= entry
->next
)
1112 file_entries
->libs
[idx
].id
= entry
->id
;
1113 file_entries
->libs
[idx
].flags
= entry
->flags
;
1114 if (entry
->soname
== NULL
)
1115 file_entries
->libs
[idx
].soname
= 0;
1118 file_entries
->libs
[idx
].soname
= str_offset
;
1120 size_t len
= strlen (entry
->soname
) + 1;
1121 str
= mempcpy (str
, entry
->soname
, len
);
1124 file_entries
->libs
[idx
].osversion
= entry
->osversion
;
1125 file_entries
->libs
[idx
++].isa_level
= entry
->isa_level
;
1128 /* Write out auxiliary cache file. */
1129 /* Write auxiliary cache first to a temporary file and rename it later. */
1131 char *temp_name
= xmalloc (strlen (aux_cache_name
) + 2);
1132 sprintf (temp_name
, "%s~", aux_cache_name
);
1134 /* Check that directory exists and create if needed. */
1135 char *dir
= strdupa (aux_cache_name
);
1136 dir
= dirname (dir
);
1139 if (stat64 (dir
, &st
) < 0)
1141 if (mkdir (dir
, 0700) < 0)
1146 int fd
= open (temp_name
, O_CREAT
|O_WRONLY
|O_TRUNC
|O_NOFOLLOW
,
1151 bool fail
= ((write (fd
, file_entries
, file_entries_size
+ total_strlen
)
1152 != (ssize_t
) (file_entries_size
+ total_strlen
))
1153 || fdatasync (fd
) != 0);
1155 fail
|= close (fd
) != 0;
1163 /* Move temporary to its final location. */
1164 if (rename (temp_name
, aux_cache_name
))
1168 /* Free allocated memory. */
1170 free (file_entries
);