+2000-05-06 Bruno Haible <haible@clisp.cons.org>
+
+ * iconv/gconv_open.c (__gconv_open): If __gconv_find_transform
+ returned != __GCONV_OK, there is nothing to clean up.
+
+2000-05-06 Bruno Haible <haible@clisp.cons.org>
+
+ * intl/tst-gettext.c (main): Disable possibly existing LC_CTYPE and
+ OUTPUT_CHARSET environment variables.
+
+2000-05-06 Andreas Jaeger <aj@suse.de>
+
+ * sysdeps/generic/dl-cache.h (struct file_entry_new): New.
+ (struct cache_file_new): New.
+ (struct file_entry): New (moved from cache.c).
+ (struct cache_file): New (moved from cache.c).
+
+ * sysdeps/generic/dl-cache.c (SEARCH_CACHE): New macro, broken out
+ from _dl_load_cache_lookup.
+ (_dl_load_cache_lookup): Move search to SEARCH_CACHE macro, handle
+ the different cache formats.
+ New variable cache_new for new format.
+
+ * elf/ldconfig.h: Change according to changes in cache.c and
+ ldconfig.c; remove cache_libcmp; add opt_format.
+
+ * elf/ldconfig.c: Include "dl-cache.h" and "dl-procinfo.h"; remove
+ stuff that's defined in those headers.
+ Add hwcap to struct lib_entry.
+ (opt_format): New variable to select cache format.
+ (options): Add format parameter.
+ (is_hwcap): New function.
+ (path_hwcap): New function.
+ (parse_opt): Handle new format parameter.
+ (search_dir): Handle hwcap, search also subdirectories with hwcap.
+
+ * elf/cache.c (_GNU_SOURCE): Removed. Not needed anymore since
+ ldconfig is part of glibc.
+ Include dl-cache.h and remove stuff that's defined there.
+ (struct cache_entry): Add new member hwcap.
+ (print_entry): Print hwcap, cleanup a bit.
+ (print_cache): Print new and old formats.
+ (compare): Use _dl_cache_libcmp from dl-cache.h; handle hwcap.
+ (save_cache): Save new and old formats.
+ (add_to_cache): Handle hwcap.
+
+ * sysdeps/generic/dl-cache.c (_dl_cache_libcmp): Moved from here...
+ * sysdeps/generic/dl-cache.h (_dl_cache_libcmp): ...to here.
+ * sysdeps/generic/dl-cache.c (LD_SO_CACHE): Moved from here...
+ * sysdeps/generic/dl-cache.h (LD_SO_CACHE): ...to here.
+ * sysdeps/generic/dl-cache.c (CACHEMAGIC): Moved from here...
+ * sysdeps/generic/dl-cache.h (CACHEMAGIC): ...to here.
+
+2000-05-05 Bruno Haible <haible@clisp.cons.org>
+
+ * intl/dcigettext.c (alignof): New macro.
+ (_nl_find_msg): Use it instead of __alignof__. Pass correct output
+ buffer length to __gconv/iconv. If malloc (freemem_size) fails, set
+ freemem_size to 0.
+
+2000-05-05 Bruno Haible <haible@clisp.cons.org>
+
+ * intl/dcigettext.c (dcigettext): Fix interpretation of tsearch
+ return value.
+
2000-05-06 Ulrich Drepper <drepper@redhat.com>
* intl/dcigettext.c (DCIGETTEXT): Always define local variable `index'.
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
-#define _GNU_SOURCE 1
-
-#include <assert.h>
#include <errno.h>
#include <error.h>
#include <dirent.h>
#include <sys/types.h>
#include "ldconfig.h"
-
-#define CACHEMAGIC "ld.so-1.7.0"
+#include "dl-cache.h"
struct cache_entry
{
- char *lib;
- char *path;
- int flags;
- struct cache_entry *next;
+ char *lib; /* Library name. */
+ char *path; /* Path to find library. */
+ int flags; /* Flags to indicate kind of library. */
+ unsigned long int hwcap; /* Important hardware capabilities. */
+ int bits_hwcap; /* Number of bits set in hwcap. */
+ struct cache_entry *next; /* Next entry in list. */
};
-struct file_entry
-{
- int flags; /* This is 1 for an ELF library. */
- unsigned int key, value; /* String table indices. */
-};
-
-
-struct cache_file
-{
- char magic[sizeof CACHEMAGIC - 1];
- unsigned int nlibs;
- struct file_entry libs[0];
-};
-
-
/* List of all cache entries. */
static struct cache_entry *entries;
/* Print a single entry. */
static void
-print_entry (const char *lib, int flag, const char *key)
+print_entry (const char *lib, int flag, unsigned long int hwcap, const char *key)
{
printf ("\t%s (", lib);
switch (flag & FLAG_TYPE_MASK)
case 0:
break;
default:
- fprintf (stdout, ",%d", flag & FLAG_REQUIRED_MASK);
+ printf (",%d", flag & FLAG_REQUIRED_MASK);
break;
}
+ if (hwcap != 0)
+ printf (", hwcap: 0x%lx", hwcap);
printf (") => %s\n", key);
}
-/* Print the whole cache file. */
+/* Print the whole cache file, if a file contains the new cache format
+ hidden in the old one, print the contents of the new format. */
void
print_cache (const char *cache_name)
{
int fd;
unsigned int i;
struct cache_file *cache;
+ struct cache_file_new *cache_new = NULL;
const char *cache_data;
+ int format = 0;
fd = open (cache_name, O_RDONLY);
if (fd < 0)
error (EXIT_FAILURE, errno, _("mmap of cache file failed.\n"));
cache_size = st.st_size;
- if (cache_size < sizeof (struct cache_file)
- || memcmp (cache->magic, CACHEMAGIC, sizeof CACHEMAGIC - 1))
- return;
- /* This is where the strings start. */
- cache_data = (const char *) &cache->libs[cache->nlibs];
+ if (cache_size < sizeof (struct cache_file))
+ error (EXIT_FAILURE, 0, _("File is not a cache file.\n"));
+
+ if (memcmp (cache->magic, CACHEMAGIC, sizeof CACHEMAGIC - 1))
+ {
+ /* This can only be the new format without the old one. */
+ cache_new = (struct cache_file_new *) cache;
+
+ if (memcmp (cache_new->magic, CACHEMAGIC_NEW, sizeof CACHEMAGIC_NEW - 1)
+ || memcmp (cache_new->version, CACHE_VERSION,
+ sizeof CACHE_VERSION - 1))
+ error (EXIT_FAILURE, 0, _("File is not a cache file.\n"));
+ format = 1;
+ /* This is where the strings start. */
+ cache_data = (const char *) cache;
+ }
+ else
+ {
+ /* This is where the strings start. */
+ cache_data = (const char *) &cache->libs[cache->nlibs];
+
+ /* Check for a new cache embedded in the old format. */
+ if (cache_size >
+ (sizeof (struct cache_file)
+ + cache->nlibs * sizeof (struct file_entry)
+ + sizeof (struct cache_file_new)))
+ {
+ cache_new = (struct cache_file_new *) cache_data;
- printf (_("%d libs found in cache `%s'\n"), cache->nlibs, cache_name);
+ if (!memcmp (cache_new->magic, CACHEMAGIC_NEW, sizeof CACHEMAGIC_NEW - 1)
+ && !memcmp (cache_new->version, CACHE_VERSION,
+ sizeof CACHE_VERSION - 1))
+ format = 1;
+ }
+ }
- /* Print everything. */
- for (i = 0; i < cache->nlibs; i++)
- print_entry (cache_data + cache->libs[i].key,
- cache->libs[i].flags,
- cache_data + cache->libs[i].value);
+ if (format == 0)
+ {
+ printf (_("%d libs found in cache `%s'\n"), cache->nlibs, cache_name);
+ /* Print everything. */
+ for (i = 0; i < cache->nlibs; i++)
+ print_entry (cache_data + cache->libs[i].key,
+ cache->libs[i].flags, 0,
+ cache_data + cache->libs[i].value);
+ }
+ else if (format == 1)
+ {
+ printf (_("%d libs found in cache `%s'\n"), cache_new->nlibs, cache_name);
+
+ /* Print everything. */
+ for (i = 0; i < cache_new->nlibs; i++)
+ print_entry (cache_data + cache_new->libs[i].key,
+ cache_new->libs[i].flags,
+ cache_new->libs[i].hwcap,
+ cache_data + cache_new->libs[i].value);
+ }
/* Cleanup. */
munmap (cache, cache_size);
close (fd);
}
-/* Helper function which must match the one in the dynamic linker, so that
- we rely on the same sort order. */
-int
-cache_libcmp (const char *p1, const char *p2)
-{
- while (*p1 != '\0')
- {
- if (*p1 >= '0' && *p1 <= '9')
- {
- if (*p2 >= '0' && *p2 <= '9')
- {
- /* Must compare this numerically. */
- int val1;
- int val2;
-
- val1 = *p1++ - '0';
- val2 = *p2++ - '0';
- while (*p1 >= '0' && *p1 <= '9')
- val1 = val1 * 10 + *p1++ - '0';
- while (*p2 >= '0' && *p2 <= '9')
- val2 = val2 * 10 + *p2++ - '0';
- if (val1 != val2)
- return val1 - val2;
- }
- else
- return 1;
- }
- else if (*p2 >= '0' && *p2 <= '9')
- return -1;
- else if (*p1 != *p2)
- return *p1 - *p2;
- else
- {
- ++p1;
- ++p2;
- }
- }
- return *p1 - *p2;
-}
static
int compare (const struct cache_entry *e1, const struct cache_entry *e2)
int res;
/* We need to swap entries here to get the correct sort order. */
- res = cache_libcmp (e2->lib, e1->lib);
+ res = _dl_cache_libcmp (e2->lib, e1->lib);
if (res == 0)
{
if (e1->flags < e2->flags)
return 1;
else if (e1->flags > e2->flags)
return -1;
+ /* Sort by most specific hwcap. */
+ else if (e2->bits_hwcap > e1->bits_hwcap)
+ return 1;
+ else if (e2->bits_hwcap < e1->bits_hwcap)
+ return -1;
+ else if (e2->hwcap > e1->hwcap)
+ return 1;
+ else if (e2->hwcap < e1->hwcap)
+ return -1;
}
return res;
}
-
/* Save the contents of the cache. */
void
save_cache (const char *cache_name)
{
struct cache_entry *entry;
- int i, fd;
+ int fd, idx_old, idx_new;
size_t total_strlen, len;
char *strings, *str, *temp_name;
- struct cache_file *file_entries;
- size_t file_entries_size;
+ struct cache_file *file_entries = NULL;
+ struct cache_file_new *file_entries_new = NULL;
+ size_t file_entries_size = 0;
+ size_t file_entries_new_size = 0;
unsigned int str_offset;
/* Number of cache entries. */
int cache_entry_count = 0;
+ /* Number of normal cache entries. */
+ int cache_entry_old_count = 0;
/* The cache entries are sorted already, save them in this order. */
/* Count the length of all strings. */
+ /* The old format doesn't contain hwcap entries and doesn't contain
+ libraries in subdirectories with hwcaps entries. Count therefore
+ also all entries with hwcap == 0. */
total_strlen = 0;
for (entry = entries; entry != NULL; entry = entry->next)
{
/* Account the final NULs. */
total_strlen += strlen (entry->lib) + strlen (entry->path) + 2;
++cache_entry_count;
+ if (entry->hwcap == 0)
+ ++cache_entry_old_count;
}
/* Create the on disk cache structure. */
/* First an array for all strings. */
- strings = (char *)xmalloc (total_strlen + 1);
+ strings = (char *)xmalloc (total_strlen);
- /* And the list of all entries. */
- file_entries_size = sizeof (struct cache_file)
- + cache_entry_count * sizeof (struct file_entry);
- file_entries = (struct cache_file *) xmalloc (file_entries_size);
+ if (opt_format != 2)
+ {
+ /* And the list of all entries in the old format. */
+ file_entries_size = sizeof (struct cache_file)
+ + cache_entry_old_count * sizeof (struct file_entry);
+ file_entries = (struct cache_file *) xmalloc (file_entries_size);
+
+ /* Fill in the header. */
+ memset (file_entries, 0, sizeof (struct cache_file));
+ memcpy (file_entries->magic, CACHEMAGIC, sizeof CACHEMAGIC - 1);
- /* Fill in the header. */
- memset (file_entries, 0, sizeof (struct cache_file));
- memcpy (file_entries->magic, CACHEMAGIC, sizeof CACHEMAGIC - 1);
+ file_entries->nlibs = cache_entry_old_count;
+ }
- file_entries->nlibs = cache_entry_count;
+ if (opt_format != 0)
+ {
+ /* And the list of all entries in the new format. */
+ file_entries_new_size = sizeof (struct cache_file_new)
+ + cache_entry_count * sizeof (struct file_entry_new);
+ file_entries_new = (struct cache_file_new *) xmalloc (file_entries_new_size);
+
+ /* Fill in the header. */
+ memset (file_entries_new, 0, sizeof (struct cache_file_new));
+ memcpy (file_entries_new->magic, CACHEMAGIC_NEW, sizeof CACHEMAGIC_NEW - 1);
+ memcpy (file_entries_new->version, CACHE_VERSION, sizeof CACHE_VERSION - 1);
+
+ file_entries_new->nlibs = cache_entry_count;
+ file_entries_new->len_strings = total_strlen;
+ }
+
+ /* If we have both formats, we hide the new format in the strings
+ table, we have to adjust all string indices for this so that
+ old libc5/glibc 2 dynamic linkers just ignore them. */
+ if (opt_format == 1)
+ str_offset = file_entries_new_size;
+ else
+ str_offset = 0;
- str_offset = 0;
str = strings;
- for (i = 0, entry = entries; entry != NULL; entry = entry->next, ++i)
+ for (idx_old = 0, idx_new = 0, entry = entries; entry != NULL;
+ entry = entry->next, ++idx_new)
{
- file_entries->libs[i].flags = entry->flags;
/* First the library. */
- /* XXX: Actually we can optimize here and remove duplicates. */
- file_entries->libs[i].key = str_offset;
+ if (opt_format != 2)
+ {
+ file_entries->libs[idx_old].flags = entry->flags;
+ /* XXX: Actually we can optimize here and remove duplicates. */
+ file_entries->libs[idx_old].key = str_offset;
+ }
+ if (opt_format != 0)
+ {
+ /* We could subtract file_entries_new_size from str_offset -
+ not doing so makes the code easier, the string table
+ always begins at the beginning of the the new cache
+ struct. */
+ file_entries_new->libs[idx_new].flags = entry->flags;
+ file_entries_new->libs[idx_new].hwcap = entry->hwcap;
+ file_entries_new->libs[idx_new].key = str_offset;
+ }
len = strlen (entry->lib);
str = stpcpy (str, entry->lib);
/* Account the final NUL. */
++str;
str_offset += len + 1;
/* Then the path. */
- file_entries->libs[i].value = str_offset;
+ if (opt_format != 2)
+ file_entries->libs[idx_old].value = str_offset;
+ if (opt_format != 0)
+ file_entries_new->libs[idx_new].value = str_offset;
len = strlen (entry->path);
str = stpcpy (str, entry->path);
/* Account the final NUL. */
++str;
str_offset += len + 1;
+ /* Ignore entries with hwcap for old format. */
+ if (entry->hwcap == 0)
+ ++idx_old;
}
- assert (str_offset == total_strlen);
/* Write out the cache. */
temp_name);
/* Write contents. */
- if (write (fd, file_entries, file_entries_size) != (ssize_t)file_entries_size)
- error (EXIT_FAILURE, errno, _("Writing of cache data failed"));
+ if (opt_format != 2)
+ {
+ if (write (fd, file_entries, file_entries_size) != (ssize_t)file_entries_size)
+ error (EXIT_FAILURE, errno, _("Writing of cache data failed"));
+ }
+ if (opt_format != 0)
+ {
+ if (write (fd, file_entries_new, file_entries_new_size)
+ != (ssize_t)file_entries_new_size)
+ error (EXIT_FAILURE, errno, _("Writing of cache data failed"));
+ }
if (write (fd, strings, total_strlen) != (ssize_t)total_strlen)
error (EXIT_FAILURE, errno, _("Writing of cache data failed."));
}
}
+
/* Add one library to the cache. */
void
-add_to_cache (const char *path, const char *lib, int flags)
+add_to_cache (const char *path, const char *lib, int flags,
+ unsigned long int hwcap)
{
struct cache_entry *new_entry, *ptr, *prev;
char *full_path;
- int len;
+ int len, i;
new_entry = (struct cache_entry *) xmalloc (sizeof (struct cache_entry));
new_entry->lib = xstrdup (lib);
new_entry->path = full_path;
new_entry->flags = flags;
+ new_entry->hwcap = hwcap;
+ new_entry->bits_hwcap = 0;
+
+ /* Count the number of bits set in the masked value. */
+ for (i = 0; (~((1UL << i) - 1) & hwcap) != 0; ++i)
+ if ((hwcap & (1UL << i)) != 0)
+ ++new_entry->bits_hwcap;
+
/* Keep the list sorted - search for right place to insert. */
ptr = entries;
-/* Copyright (C) 1999 Free Software Foundation, Inc.
+/* Copyright (C) 1999, 2000 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Andreas Jaeger <aj@suse.de>, 1999.
#include <sys/types.h>
#include "ldconfig.h"
+#include "dl-cache.h"
-#ifndef LD_SO_CACHE
-# define LD_SO_CACHE "/etc/ld.so.cache"
-#endif
+/* We don't need this here - silence the compiler. */
+#define _dl_sysdep_message(string, args...) do {} while (0);
+
+#include "dl-procinfo.h"
#ifndef LD_SO_CONF
# define LD_SO_CONF "/etc/ld.so.conf"
struct lib_entry
{
int flags;
+ unsigned long int hwcap;
char *lib;
char *path;
};
{"libc5", FLAG_ELF_LIBC5},
{"libc6", FLAG_ELF_LIBC6},
{"glibc2", FLAG_ELF_LIBC6}
-};
+};
/* List of directories to handle. */
/* Be verbose. */
int opt_verbose = 0;
+/* Format to support. */
+/* 0: only libc5/glibc2; 1: both; 2: only glibc 2.2. */
+int opt_format = 1;
+
/* Build cache. */
static int opt_build_cache = 1;
{ NULL, 'f', "CONF", 0, N_("Use CONF as configuration file"), 0},
{ NULL, 'n', NULL, 0, N_("Only process directories specified on the command line. Don't build cache."), 0},
{ NULL, 'l', NULL, 0, N_("Manually link individual libraries."), 0},
+ { "format", 'c', "FORMAT", 0, N_("Format to use: new, old or compat (default)"), 0},
{ NULL, 0, NULL, 0, NULL, 0 }
};
options, parse_opt, NULL, doc, NULL, NULL, NULL
};
+/* Check if string corresponds to an important hardware capability. */
+static int
+is_hwcap (const char *name)
+{
+ int hwcap_idx = _dl_string_hwcap (name);
+
+ if (hwcap_idx != -1 && ((1 << hwcap_idx) & HWCAP_IMPORTANT))
+ return 1;
+ return 0;
+}
+
+/* Get hwcap encoding of path. */
+static unsigned long int
+path_hwcap (const char *path)
+{
+ char *str = xstrdup (path);
+ char *ptr;
+ unsigned long int hwcap = 0;
+ unsigned long int h;
+
+ size_t len;
+
+ len = strlen (str);
+ if (str[len] == '/')
+ str[len] = '\0';
+
+ /* Search pathname from the end and check for hwcap strings. */
+ for (;;)
+ {
+ ptr = strrchr (str, '/');
+
+ if (ptr == NULL)
+ break;
+
+ h = _dl_string_hwcap (ptr+1);
+
+ if (h == -1)
+ break;
+ hwcap += 1 << h;
+ /* Search the next part of the path. */
+ *ptr = '\0';
+ }
+
+ free (str);
+ return hwcap;
+}
/* Handle program arguments. */
static error_t
case 'X':
opt_link = 0;
break;
+ case 'c':
+ if (strcmp (arg, "old") == 0)
+ opt_format = 0;
+ else if (strcmp (arg, "compat") == 0)
+ opt_format = 1;
+ else if (strcmp (arg, "new") == 0)
+ opt_format = 2;
+ break;
default:
return ARGP_ERR_UNKNOWN;
}
Copyright (C) %s Free Software Foundation, Inc.\n\
This is free software; see the source for copying conditions. There is NO\n\
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
-"), "1999");
+"), "2000");
fprintf (stream, gettext ("Written by %s.\n"),
"Andreas Jaeger");
}
char *equal_sign;
struct dir_entry *entry, *ptr, *prev;
unsigned int i;
-
+
entry = xmalloc (sizeof (struct dir_entry));
entry->next = NULL;
-
+
/* Search for an '=' sign. */
entry->path = xstrdup (line);
equal_sign = strchr (entry->path, '=');
entry->path [i] = '\0';
--i;
}
-
+
ptr = dir_entries;
prev = ptr;
while (ptr != NULL)
int do_link = 1;
int do_remove = 1;
/* XXX: The logics in this function should be simplified. */
-
+
/* Get complete path. */
snprintf (full_libname, sizeof full_libname, "%s/%s", path, libname);
snprintf (full_soname, sizeof full_soname, "%s/%s", path, soname);
- create symbolic links to the soname for each library
This has to be done separatly for each directory.
-
+
To keep track of which libraries to add to the cache and which
links to create, we save a list of all libraries.
if new library is newer, replace entry
otherwise ignore this library
otherwise add library to list
-
+
For example, if the two libraries libxy.so.1.1 and libxy.so.1.2
exist and both have the same soname, e.g. libxy.so, a symbolic link
is created from libxy.so.1.2 (the newer one) to libxy.so.
libxy.so.1.1. */
/* Information for one library. */
-struct dlib_entry
+struct dlib_entry
{
char *name;
char *soname;
int nchars;
struct stat stat_buf;
int is_link;
-
+ unsigned long int hwcap = path_hwcap (entry->path);
+
dlibs = NULL;
if (opt_verbose)
- printf ("%s:\n", entry->path);
-
+ {
+ if (hwcap != 0)
+ printf ("%s: (hwcap: 0x%lx)\n", entry->path, hwcap);
+ else
+ printf ("%s:\n", entry->path);
+ }
+
dir = opendir (entry->path);
if (dir == NULL)
{
error (0, errno, _("Can't open directory %s"), entry->path);
return;
}
-
+
while ((direntry = readdir (dir)) != NULL)
{
/* We only look at links and regular files. */
if (direntry->d_type != DT_UNKNOWN
&& direntry->d_type != DT_LNK
- && direntry->d_type != DT_REG)
+ && direntry->d_type != DT_REG
+ && direntry->d_type != DT_DIR)
continue;
#endif /* _DIRENT_HAVE_D_TYPE */
-
- /* Does this file look like a shared library? The dynamic
- linker is also considered as shared library. */
- if ((strncmp (direntry->d_name, "lib", 3) != 0
- && strncmp (direntry->d_name, "ld-", 3) != 0)
- || strstr (direntry->d_name, ".so") == NULL)
+ /* Does this file look like a shared library or is it a hwcap
+ subdirectory? The dynamic linker is also considered as
+ shared library. */
+ if (((strncmp (direntry->d_name, "lib", 3) != 0
+ && strncmp (direntry->d_name, "ld-", 3) != 0)
+ || strstr (direntry->d_name, ".so") == NULL)
+ && !is_hwcap (direntry->d_name))
continue;
nchars = snprintf (buf, sizeof (buf), "%s/%s", entry->path,
direntry->d_name);
error (0, errno, _("Can't lstat %s"), buf);
continue;
}
+ else if (S_ISDIR (stat_buf.st_mode) && is_hwcap (direntry->d_name))
+ {
+ /* Handle subdirectory also, make a recursive call. */
+ struct dir_entry new_entry;
+ new_entry.path = buf;
+ new_entry.flag = entry->flag;
+ new_entry.next = NULL;
+ search_dir (&new_entry);
+ continue;
+ }
else if (!S_ISREG (stat_buf.st_mode) && !S_ISLNK (stat_buf.st_mode))
continue;
free (soname);
soname = xstrdup (direntry->d_name);
}
-
+
if (flag == FLAG_ELF
&& (entry->flag == FLAG_ELF_LIBC5
|| entry->flag == FLAG_ELF_LIBC6))
&& entry->flag != FLAG_ANY)
error (0, 0, _("libc4 library %s in wrong directory"), buf);
}
-
+
/* Add library to list. */
for (dlib_ptr = dlibs; dlib_ptr != NULL; dlib_ptr = dlib_ptr->next)
{
is newer. */
if ((!is_link && dlib_ptr->is_link)
|| (is_link == dlib_ptr->is_link
- && cache_libcmp (dlib_ptr->name, direntry->d_name) < 0))
+ && _dl_cache_libcmp (dlib_ptr->name, direntry->d_name) < 0))
{
/* It's newer - add it. */
/* Flag should be the same - sanity check. */
if (dlib_ptr->is_link == 0)
create_links (entry->path, dlib_ptr->name, dlib_ptr->soname);
if (opt_build_cache)
- add_to_cache (entry->path, dlib_ptr->soname, dlib_ptr->flag);
+ add_to_cache (entry->path, dlib_ptr->soname, dlib_ptr->flag, hwcap);
}
/* Free all resources. */
- while (dlibs)
+ while (dlibs)
{
dlib_ptr = dlibs;
free (dlib_ptr->soname);
FILE *file;
char *line = NULL;
size_t len = 0;
-
+
file = fopen (filename, "r");
if (file == NULL)
main (int argc, char **argv)
{
int remaining;
-
+
/* Parse and process arguments. */
argp_parse (&argp, argc, argv, 0, &remaining, NULL);
if (config_file == NULL)
config_file = LD_SO_CONF;
-
+
/* Chroot first. */
if (opt_chroot)
{
exit (0);
}
-
-
+
+
if (opt_build_cache)
init_cache ();
parse_conf (config_file);
}
-
+
search_dirs ();
if (opt_build_cache)
-/* Copyright (C) 1999 Free Software Foundation, Inc.
+/* Copyright (C) 1999, 2000 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Andreas Jaeger <aj@suse.de>, 1999.
extern void save_cache (const char *cache_name);
-extern void add_to_cache (const char *path, const char *lib, int flags);
-
-extern int cache_libcmp (const char *p1, const char *p2);
-
+extern void add_to_cache (const char *path, const char *lib, int flags,
+ unsigned long int hwcap);
/* Declared in readlib.c. */
extern int process_file (const char *file_name, const char *lib, int *flag,
/* Declared in ldconfig.c. */
extern int opt_verbose;
+extern int opt_format;
+
/* Prototypes for a few program-wide used functions. */
extern void *xmalloc (size_t __n);
extern void *xcalloc (size_t __n, size_t __size);
extern char *xstrdup (const char *__str);
#endif /* ! _LDCONFIG_H */
-
result->__data[cnt].__internal_use = 0;
result->__data[cnt].__statep = &result->__data[cnt].__state;
}
- }
-
- if (res != __GCONV_OK)
- {
- /* Something went wrong. Free all the resources. */
- int serrno = errno;
- if (result != NULL)
+ if (res != __GCONV_OK)
{
- while (cnt-- > 0)
- free (result->__data[cnt].__outbuf);
+ /* Something went wrong. Free all the resources. */
+ int serrno = errno;
- free (result);
- result = NULL;
- }
+ if (result != NULL)
+ {
+ while (cnt-- > 0)
+ free (result->__data[cnt].__outbuf);
+
+ free (result);
+ result = NULL;
+ }
- __gconv_close_transform (steps, nsteps);
+ __gconv_close_transform (steps, nsteps);
- __set_errno (serrno);
+ __set_errno (serrno);
+ }
}
*handle = result;
# define __libc_rwlock_unlock(NAME)
#endif
+/* Alignment of types. */
+#if defined __GNUC__ && __GNUC__ >= 2
+# define alignof(TYPE) __alignof__ (TYPE)
+#else
+# define alignof(TYPE) \
+ ((int) &((struct { char dummy1; TYPE dummy2; } *) 0)->dummy2)
+#endif
+
/* @@ end of prolog @@ */
#ifdef _LIBC
resultlen = p - result;
}
- inbuf = result;
- outbuf = freemem + 4;
-
__libc_lock_lock (lock);
+ inbuf = result;
+ outbuf = freemem + sizeof (nls_uint32);
+
while (1)
{
# ifdef _LIBC
size_t non_reversible;
int res;
+ if (freemem_size < 4)
+ goto resize_freemem;
+
res = __gconv (domain->conv,
&inbuf, inbuf + resultlen,
- &outbuf, outbuf + freemem_size,
+ &outbuf,
+ outbuf + freemem_size - sizeof (nls_uint32),
&non_reversible);
if (res == __GCONV_OK || res == __GCONV_EMPTY_INPUT)
const char *inptr = (const char *) inbuf;
size_t inleft = resultlen;
char *outptr = (char *) outbuf;
- size_t outleft = freemem_size;
+ size_t outleft;
+
+ if (freemem_size < 4)
+ goto resize_freemem;
+ outleft = freemem_size - 4;
if (iconv (domain->conv, &inptr, &inleft, &outptr, &outleft)
!= (size_t) (-1))
{
# endif
# endif
+ resize_freemem:
/* We must resize the buffer. */
freemem_size = 2 * freemem_size;
if (freemem_size < 4064)
freemem = (char *) malloc (freemem_size);
if (__builtin_expect (freemem == NULL, 0))
{
+ freemem_size = 0;
__libc_lock_unlock (lock);
goto converted;
}
- outbuf = freemem + 4;
+ outbuf = freemem + sizeof (nls_uint32);
}
/* We have now in our buffer a converted string. Put this
/* Shrink freemem, but keep it aligned. */
freemem_size -= outbuf - freemem;
freemem = outbuf;
- freemem += freemem_size & (__alignof__ (nls_uint32) - 1);
- freemem_size = freemem_size & ~ (__alignof__ (nls_uint32) - 1);
+ freemem += freemem_size & (alignof (nls_uint32) - 1);
+ freemem_size = freemem_size & ~ (alignof (nls_uint32) - 1);
__libc_lock_unlock (lock);
}
/* Now domain->conv_tab[act] contains the translation of at least
the variants 0 .. INDEX. */
- result = domain->conv_tab[act] + 4;
+ result = domain->conv_tab[act] + sizeof (nls_uint32);
}
converted:
setenv ("LANGUAGE", "existing-locale", 1);
setenv ("LC_ALL", "non-existing-locale", 1);
setenv ("LC_MESSAGES", "non-existing-locale", 1);
+ setenv ("LC_CTYPE", "non-existing-locale", 1);
setenv ("LANG", "non-existing-locale", 1);
+ unsetenv ("OUTPUT_CHARSET");
/* This is the name of the existing domain with a catalog for the
LC_MESSAGES category. */
textdomain ("existing-domain");
--- /dev/null
+/* This is a test of the special shutdown that occurs
+ when all threads, including the main one, call
+ pthread_exit(). It demonstrates that atexit
+ handlers are properly called, and that the
+ output is properly flushed even when stdout is
+ redirected to a file, and therefore fully buffered. */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <pthread.h>
+
+#define NTHREADS 20 /* number of threads */
+
+static void *thread(void *arg)
+{
+ printf("thread terminating\n");
+ return 0;
+}
+
+void cleanup(void)
+{
+ printf("atexit handler called\n");
+}
+
+int main(void)
+{
+ int i;
+
+ atexit(cleanup);
+
+ for (i = 0; i < NTHREADS; i++) {
+ pthread_t id;
+ if (pthread_create(&id, 0, thread, 0) != 0) {
+ fprintf(stderr, "pthread_create failed\n");
+ abort();
+ }
+ }
+
+ pthread_exit(0);
+}
oldsemaphore events getcpuclockid
vpath %.c Examples
-tests = ex1 ex2 ex3 ex4 ex5 ex6
+tests = ex1 ex2 ex3 ex4 ex5 ex6 ex7
include ../Rules
$(objpfx)ex4: $(libpthread)
$(objpfx)ex5: $(libpthread)
$(objpfx)ex6: $(libpthread)
+$(objpfx)ex7: $(libpthread)
pthread_descr req_thread; /* Thread doing the request */
enum { /* Request kind */
REQ_CREATE, REQ_FREE, REQ_PROCESS_EXIT, REQ_MAIN_THREAD_EXIT,
- REQ_POST, REQ_DEBUG
+ REQ_POST, REQ_DEBUG, REQ_KICK
} req_kind;
union { /* Arguments for request */
struct { /* For REQ_CREATE: */
request.req_kind = REQ_MAIN_THREAD_EXIT;
__libc_write(__pthread_manager_request, (char *)&request, sizeof(request));
suspend(self);
+ /* Main thread flushes stdio streams and runs atexit functions.
+ It also calls a handler within LinuxThreads which sends a process exit
+ request to the thread manager. */
+ exit(0);
}
- /* Exit the process (but don't flush stdio streams, and don't run
- atexit functions). */
+ /* Threads other than the main one terminate without flushing stdio streams
+ or running atexit functions. */
_exit(0);
}
case REQ_PROCESS_EXIT:
pthread_handle_exit(request.req_thread,
request.req_args.exit.code);
+ /* NOTREACHED */
break;
case REQ_MAIN_THREAD_EXIT:
main_thread_exiting = 1;
+ /* Reap children in case all other threads died and the signal handler
+ went off before we set main_thread_exiting to 1, and therefore did
+ not do REQ_KICK. */
+ pthread_reap_children();
+
if (__pthread_main_thread->p_nextlive == __pthread_main_thread) {
restart(__pthread_main_thread);
- return 0;
- }
+ /* The main thread will now call exit() which will trigger an
+ __on_exit handler, which in turn will send REQ_PROCESS_EXIT
+ to the thread manager. In case you are wondering how the
+ manager terminates from its loop here. */
+ }
break;
case REQ_POST:
__new_sem_post(request.req_args.post);
if (__pthread_threads_debug && __pthread_sig_debug > 0)
raise(__pthread_sig_debug);
break;
+ case REQ_KICK:
+ /* This is just a prod to get the manager to reap some
+ threads right away, avoiding a potential delay at shutdown. */
+ break;
}
}
}
if (main_thread_exiting &&
__pthread_main_thread->p_nextlive == __pthread_main_thread) {
restart(__pthread_main_thread);
- _exit(0);
+ /* Same logic as REQ_MAIN_THREAD_EXIT. */
}
}
void __pthread_manager_sighandler(int sig)
{
+ int kick_manager = terminated_children == 0 && main_thread_exiting;
terminated_children = 1;
+
+ /* If the main thread is terminating, kick the thread manager loop
+ each time some threads terminate. This eliminates a two second
+ shutdown delay caused by the thread manager sleeping in the
+ call to __poll(). Instead, the thread manager is kicked into
+ action, reaps the outstanding threads and resumes the main thread
+ so that it can complete the shutdown. */
+
+ if (kick_manager) {
+ struct pthread_request request;
+ request.req_thread = 0;
+ request.req_kind = REQ_KICK;
+ __libc_write(__pthread_manager_request, (char *) &request, sizeof(request));
+ }
}
/* Adjust priority of thread manager so that it always run at a priority
#include <sys/mman.h>
#include <dl-cache.h>
+
/* System-dependent function to read a file's whole contents
in the most convenient manner available. */
extern void *_dl_sysdep_read_whole_file (const char *filename,
size_t *filesize_ptr,
int mmap_prot);
-#ifndef LD_SO_CACHE
-# define LD_SO_CACHE "/etc/ld.so.cache"
-#endif
-
-#define CACHEMAGIC "ld.so-1.7.0"
-
-struct cache_file
- {
- char magic[sizeof CACHEMAGIC - 1];
- unsigned int nlibs;
- struct
- {
- int flags; /* This is 1 for an ELF library. */
- unsigned int key, value; /* String table indices. */
- } libs[0];
- };
-
/* This is the starting address and the size of the mmap()ed file. */
static struct cache_file *cache;
+static struct cache_file_new *cache_new;
static size_t cachesize;
/* 1 if cache_data + PTR points into the cache. */
binaries. */
int _dl_correct_cache_id = _DL_CACHE_DEFAULT_ID;
-/* Helper function which must match the one in ldconfig, so that
- we rely on the same sort order. */
-static int
-_dl_cache_libcmp (const char *p1, const char *p2)
-{
- while (*p1 != '\0')
- {
- if (*p1 >= '0' && *p1 <= '9')
- {
- if (*p2 >= '0' && *p2 <= '9')
- {
- /* Must compare this numerically. */
- int val1;
- int val2;
-
- val1 = *p1++ - '0';
- val2 = *p2++ - '0';
- while (*p1 >= '0' && *p1 <= '9')
- val1 = val1 * 10 + *p1++ - '0';
- while (*p2 >= '0' && *p2 <= '9')
- val2 = val2 * 10 + *p2++ - '0';
- if (val1 != val2)
- return val1 - val2;
- }
- else
- return 1;
- }
- else if (*p2 >= '0' && *p2 <= '9')
- return -1;
- else if (*p1 != *p2)
- return *p1 - *p2;
- else
- {
- ++p1;
- ++p2;
- }
- }
- return *p1 - *p2;
-}
+#define SEARCH_CACHE(cache) \
+/* We use binary search since the table is sorted in the cache file. \
+ The first matching entry in the table is returned. \
+ It is important to use the same algorithm as used while generating \
+ the cache file. */ \
+do \
+ { \
+ left = 0; \
+ right = cache->nlibs - 1; \
+ middle = (left + right) / 2; \
+ cmpres = 1; \
+ \
+ while (left <= right) \
+ { \
+ /* Make sure string table indices are not bogus before using \
+ them. */ \
+ if (! _dl_cache_verify_ptr (cache->libs[middle].key)) \
+ { \
+ cmpres = 1; \
+ break; \
+ } \
+ \
+ /* Actually compare the entry with the key. */ \
+ cmpres = _dl_cache_libcmp (name, \
+ cache_data + cache->libs[middle].key); \
+ if (cmpres == 0) \
+ /* Found it. */ \
+ break; \
+ \
+ if (cmpres < 0) \
+ left = middle + 1; \
+ else \
+ right = middle - 1; \
+ \
+ middle = (left + right) / 2; \
+ } \
+ \
+ if (cmpres == 0) \
+ { \
+ /* LEFT now marks the last entry for which we know the name is \
+ correct. */ \
+ left = middle; \
+ \
+ /* There might be entries with this name before the one we \
+ found. So we have to find the beginning. */ \
+ while (middle > 0 \
+ /* Make sure string table indices are not bogus before \
+ using them. */ \
+ && _dl_cache_verify_ptr (cache->libs[middle - 1].key) \
+ /* Actually compare the entry. */ \
+ && (_dl_cache_libcmp (name, \
+ cache_data \
+ + cache->libs[middle - 1].key) \
+ == 0)) \
+ --middle; \
+ \
+ do \
+ { \
+ int flags; \
+ \
+ /* Only perform the name test if necessary. */ \
+ if (middle > left \
+ /* We haven't seen this string so far. Test whether the \
+ index is ok and whether the name matches. Otherwise \
+ we are done. */ \
+ && (! _dl_cache_verify_ptr (cache->libs[middle].key) \
+ || (_dl_cache_libcmp (name, \
+ cache_data \
+ + cache->libs[middle].key) \
+ != 0))) \
+ break; \
+ \
+ flags = cache->libs[middle].flags; \
+ if (_dl_cache_check_flags (flags) \
+ && _dl_cache_verify_ptr (cache->libs[middle].value)) \
+ { \
+ if (best == NULL || flags == _dl_correct_cache_id) \
+ { \
+ HWCAP_CHECK; \
+ best = cache_data + cache->libs[middle].value; \
+ \
+ if (flags == _dl_correct_cache_id) \
+ /* We've found an exact match for the shared \
+ object and no general `ELF' release. Stop \
+ searching. */ \
+ break; \
+ } \
+ } \
+ } \
+ while (++middle <= right); \
+ } \
+ } \
+while (0)
+
/* Look up NAME in ld.so.cache and return the file name stored there,
/* Read the contents of the file. */
void *file = _dl_sysdep_read_whole_file (LD_SO_CACHE, &cachesize,
PROT_READ);
+
+ /* We can handle three different cache file formats here:
+ - the old libc5/glibc2.0/2.1 format
+ - the old format with the new format in it
+ - only the new format
+ The following checks if the cache contains any of these formats. */
if (file && cachesize > sizeof *cache &&
!memcmp (file, CACHEMAGIC, sizeof CACHEMAGIC - 1))
- /* Looks ok. */
- cache = file;
+ {
+ /* Looks ok. */
+ cache = file;
+
+ /* Check for new version. */
+ cache_new = (struct cache_file_new *) &cache->libs[cache->nlibs];
+ if (cachesize <
+ (sizeof (struct cache_file) + cache->nlibs * sizeof (struct file_entry)
+ + sizeof (struct cache_file_new))
+ || memcmp (cache_new->magic, CACHEMAGIC_NEW,
+ sizeof CACHEMAGIC_NEW - 1)
+ || memcmp (cache_new->version, CACHE_VERSION,
+ sizeof CACHE_VERSION - 1))
+ cache_new = (void *) -1;
+ }
+ else if (file && cachesize > sizeof *cache_new)
+ {
+ cache_new = (struct cache_file_new *) file;
+ if (memcmp (cache_new->magic, CACHEMAGIC_NEW,
+ sizeof CACHEMAGIC_NEW - 1)
+ || memcmp (cache_new->version, CACHE_VERSION,
+ sizeof CACHE_VERSION - 1))
+ cache_new = (void *) -1;
+ }
else
{
if (file)
best = NULL;
- /* We use binary search since the table is sorted in the cache file.
- It is important to use the same algorithm as used while generating
- the cache file. */
- left = 0;
- right = cache->nlibs - 1;
- middle = (left + right) / 2;
- cmpres = 1;
-
- while (left <= right)
+ if (cache_new != (void *) -1)
{
- /* Make sure string table indices are not bogus before using them. */
- if (! _dl_cache_verify_ptr (cache->libs[middle].key))
- {
- cmpres = 1;
- break;
- }
+ /* This file ends in static libraries where we don't have a hwcap. */
+ unsigned long int *hwcap;
+ weak_extern (_dl_hwcap);
- /* Actually compare the entry with the key. */
- cmpres = _dl_cache_libcmp (name, cache_data + cache->libs[middle].key);
- if (cmpres == 0)
- /* Found it. */
- break;
+ hwcap = &_dl_hwcap;
- if (cmpres < 0)
- left = middle + 1;
- else
- right = middle - 1;
-
- middle = (left + right) / 2;
- }
-
- if (cmpres == 0)
- {
- /* LEFT now marks the last entry for which we know the name is
- correct. */
- left = middle;
-
- /* There might be entries with this name before the one we
- found. So we have to find the beginning. */
- while (middle > 0
- /* Make sure string table indices are not bogus before
- using them. */
- && _dl_cache_verify_ptr (cache->libs[middle - 1].key)
- /* Actually compare the entry. */
- && (_dl_cache_libcmp (name,
- cache_data + cache->libs[middle - 1].key)
- == 0))
- --middle;
-
- do
- {
- int flags;
-
- /* Only perform the name test if necessary. */
- if (middle > left
- /* We haven't seen this string so far. Test whether the
- index is ok and whether the name matches. Otherwise
- we are done. */
- && (! _dl_cache_verify_ptr (cache->libs[middle].key)
- || (_dl_cache_libcmp (name,
- cache_data + cache->libs[middle].key)
- != 0)))
- break;
-
- flags = cache->libs[middle].flags;
- if (_dl_cache_check_flags (flags)
- && _dl_cache_verify_ptr (cache->libs[middle].value))
- {
- if (best == NULL || flags == _dl_correct_cache_id)
- {
- best = cache_data + cache->libs[middle].value;
-
- if (flags == _dl_correct_cache_id)
- /* We've found an exact match for the shared
- object and no general `ELF' release. Stop
- searching. */
- break;
- }
- }
- }
- while (++middle <= right);
+#define HWCAP_CHECK \
+ if (hwcap && (cache_new->libs[middle].hwcap & *hwcap) > _dl_hwcap) \
+ continue
+ SEARCH_CACHE (cache_new);
}
+ else
+#undef HWCAP_CHECK
+#define HWCAP_CHECK do {} while (0)
+ SEARCH_CACHE (cache);
/* Print our result if wanted. */
if (_dl_debug_libs && best != NULL)
/* Support for reading /etc/ld.so.cache files written by Linux ldconfig.
- Copyright (C) 1999 Free Software Foundation, Inc.
+ Copyright (C) 1999, 2000 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
#define _dl_cache_check_flags(flags) \
((flags) == 1 || (flags) == _DL_CACHE_DEFAULT_ID)
+
+
+#ifndef LD_SO_CACHE
+# define LD_SO_CACHE "/etc/ld.so.cache"
+#endif
+
+#define CACHEMAGIC "ld.so-1.7.0"
+
+/* libc5 and glibc 2.0/2.1 use the same format. For glibc 2.2 another
+ format has been added in a compatible way:
+ The beginning of the string table is used for the new table:
+ old_magic
+ nlibs
+ libs[0]
+ ...
+ libs[nlibs-1]
+ new magic
+ newnlibs
+ ...
+ newlibs[0]
+ ...
+ newlibs[newnlibs-1]
+ string 1
+ string 2
+ ...
+*/
+struct file_entry
+{
+ int flags; /* This is 1 for an ELF library. */
+ unsigned int key, value; /* String table indices. */
+};
+
+struct cache_file
+{
+ char magic[sizeof CACHEMAGIC - 1];
+ unsigned int nlibs;
+ struct file_entry libs[0];
+};
+
+#define CACHEMAGIC_NEW "glibc-ld.so.cache"
+#define CACHE_VERSION "1.0"
+
+
+struct file_entry_new
+{
+ int flags; /* This is 1 for an ELF library. */
+ unsigned int key, value; /* String table indices. */
+ unsigned long hwcap; /* Hwcap entry. */
+};
+
+struct cache_file_new
+{
+ char magic[sizeof CACHEMAGIC_NEW - 1];
+ char version[sizeof CACHE_VERSION - 1];
+ unsigned int nlibs; /* Number of entries. */
+ unsigned int len_strings; /* Size of string table. */
+ unsigned int unused[4]; /* Leave space for future extensions. */
+ struct file_entry_new libs[0]; /* Entries describing libraries. */
+ /* After this the string table of size len_strings is found. */
+};
+
+static int
+_dl_cache_libcmp (const char *p1, const char *p2)
+{
+ while (*p1 != '\0')
+ {
+ if (*p1 >= '0' && *p1 <= '9')
+ {
+ if (*p2 >= '0' && *p2 <= '9')
+ {
+ /* Must compare this numerically. */
+ int val1;
+ int val2;
+
+ val1 = *p1++ - '0';
+ val2 = *p2++ - '0';
+ while (*p1 >= '0' && *p1 <= '9')
+ val1 = val1 * 10 + *p1++ - '0';
+ while (*p2 >= '0' && *p2 <= '9')
+ val2 = val2 * 10 + *p2++ - '0';
+ if (val1 != val2)
+ return val1 - val2;
+ }
+ else
+ return 1;
+ }
+ else if (*p2 >= '0' && *p2 <= '9')
+ return -1;
+ else if (*p1 != *p2)
+ return *p1 - *p2;
+ else
+ {
+ ++p1;
+ ++p2;
+ }
+ }
+ return *p1 - *p2;
+}
projects / platform / upstream / glibc.git / commitdiff