rpms/glibc/devel glibc-i386-rwlock.patch, NONE, 1.1 glibc-ldconfig-speedup.patch, NONE, 1.1 glibc-private-futex.patch, NONE, 1.1 glibc-warning-patrol.patch, NONE, 1.1 glibc.spec, 1.309, 1.310

[Jakub Jelinek (jakub)]

Author: jakub

Update of /cvs/pkgs/rpms/glibc/devel
In directory cvs-int.fedora.redhat.com:/tmp/cvs-serv15017

Modified Files:
	glibc.spec 
Added Files:
	glibc-i386-rwlock.patch glibc-ldconfig-speedup.patch 
	glibc-private-futex.patch glibc-warning-patrol.patch 
Log Message:
2.6.90-1

glibc-i386-rwlock.patch:

--- NEW FILE glibc-i386-rwlock.patch ---
2007-07-30  Jakub Jelinek  <jakub at redhat.com>

	* sysdeps/unix/sysv/linux/i386/i486/pthread_rwlock_timedrdlock.S
	(pthread_rwlock_timedrdlock): Copy futex retval to %esi rather than
	%ecx.
	* sysdeps/unix/sysv/linux/i386/i486/pthread_rwlock_timedwrlock.S
	(pthread_rwlock_timedwrlock): Likewise.
	* sysdeps/unix/sysv/linux/i386/i486/pthread_rwlock_unlock.S
	(__pthread_rwlock_unlock): Fix MUTEX != 0 args to __lll_*.

--- libc/nptl/sysdeps/unix/sysv/linux/i386/i486/pthread_rwlock_timedrdlock.S.jj	2007-06-04 08:42:06.000000000 +0200
+++ libc/nptl/sysdeps/unix/sysv/linux/i386/i486/pthread_rwlock_timedrdlock.S	2007-07-30 18:10:05.000000000 +0200
@@ -124,7 +124,7 @@ pthread_rwlock_timedrdlock:
 	leal	READERS_WAKEUP(%ebp), %ebx
 	movl	$SYS_futex, %eax
 	ENTER_KERNEL
-	movl	%eax, %ecx
+	movl	%eax, %esi
 17:
 
 	/* Reget the lock.  */
@@ -139,7 +139,7 @@ pthread_rwlock_timedrdlock:
 	jnz	12f
 
 13:	subl	$1, READERS_QUEUED(%ebp)
-	cmpl	$-ETIMEDOUT, %ecx
+	cmpl	$-ETIMEDOUT, %esi
 	jne	2b
 
 18:	movl	$ETIMEDOUT, %ecx
@@ -217,7 +217,7 @@ pthread_rwlock_timedrdlock:
 	call	__lll_mutex_lock_wait
 	jmp	13b
 
-16:	movl	$-ETIMEDOUT, %ecx
+16:	movl	$-ETIMEDOUT, %esi
 	jmp	17b
 
 19:	movl	$EINVAL, %ecx
--- libc/nptl/sysdeps/unix/sysv/linux/i386/i486/pthread_rwlock_timedwrlock.S.jj	2007-06-04 08:42:06.000000000 +0200
+++ libc/nptl/sysdeps/unix/sysv/linux/i386/i486/pthread_rwlock_timedwrlock.S	2007-07-30 18:10:59.000000000 +0200
@@ -122,7 +122,7 @@ pthread_rwlock_timedwrlock:
 	leal	WRITERS_WAKEUP(%ebp), %ebx
 	movl	$SYS_futex, %eax
 	ENTER_KERNEL
-	movl	%eax, %ecx
+	movl	%eax, %esi
 17:
 
 	/* Reget the lock.  */
@@ -137,7 +137,7 @@ pthread_rwlock_timedwrlock:
 	jnz	12f
 
 13:	subl	$1, WRITERS_QUEUED(%ebp)
-	cmpl	$-ETIMEDOUT, %ecx
+	cmpl	$-ETIMEDOUT, %esi
 	jne	2b
 
 18:	movl	$ETIMEDOUT, %ecx
@@ -210,7 +210,7 @@ pthread_rwlock_timedwrlock:
 	call	__lll_mutex_lock_wait
 	jmp	13b
 
-16:	movl	$-ETIMEDOUT, %ecx
+16:	movl	$-ETIMEDOUT, %esi
 	jmp	17b
 
 19:	movl	$EINVAL, %ecx
--- libc/nptl/sysdeps/unix/sysv/linux/i386/i486/pthread_rwlock_unlock.S.jj	2007-06-04 08:42:06.000000000 +0200
+++ libc/nptl/sysdeps/unix/sysv/linux/i386/i486/pthread_rwlock_unlock.S	2007-07-30 18:19:01.000000000 +0200
@@ -117,7 +117,7 @@ __pthread_rwlock_unlock:
 #if MUTEX == 0
 	movl	%edi, %ecx
 #else
-	leal	MUTEX(%edx), %ecx
+	leal	MUTEX(%edi), %ecx
 #endif
 	call	__lll_mutex_lock_wait
 	jmp	2b
@@ -126,7 +126,7 @@ __pthread_rwlock_unlock:
 #if MUTEX == 0
 	movl	%edi, %eax
 #else
-	leal	MUTEX(%edx), %eax
+	leal	MUTEX(%edi), %eax
 #endif
 	call	__lll_mutex_unlock_wake
 	jmp	4b
@@ -135,7 +135,7 @@ __pthread_rwlock_unlock:
 #if MUTEX == 0
 	movl	%edi, %eax
 #else
-	leal	MUTEX(%edx), %eax
+	leal	MUTEX(%edi), %eax
 #endif
 	call	__lll_mutex_unlock_wake
 	jmp	8b


glibc-ldconfig-speedup.patch:

--- NEW FILE glibc-ldconfig-speedup.patch ---
2007-07-27  Andreas Jaeger  <aj at suse.de>
	    Jakub Jelinek  <jakub at redhat.com>

	* elf/ldconfig.c (opt_ignore_aux_cache): Add new option.
	(options): Add option.
	(parse_opt): Handle option.
	(manual_link): Adjust process_file caller.  Call implicit_soname.
	(search_dir): Formatting.  Use and populate auxiliary cache.
	(main): Load and save auxiliary cache.
	* elf/readlib.c (process_file): Add stat_buf argument.  Pass struct
	stat64 from fstat64 to caller.
	(implicit_soname): New function.
	* elf/readelflib.c (process_elf_file): If DT_SONAME is not present,
	leave *soname as NULL.
	* elf/cache.c: Include libgen.h.
	(print_entry, print_cache, compare, save_cache, add_to_cache):
	Formatting and cleanups.
	(aux_cache_entry_id, aux_cache_entry, aux_cache_file_entry,
	aux_cache_file): New structures.
	(AUX_CACHEMAGIC): Define.
	(primes): New array.
	(aux_hash_size, aux_hash): New variables.
	(aux_cache_entry_id_hash, nextprime, init_aux_cache,
	search_aux_cache, insert_to_aux_cache, add_to_aux_cache,
	load_aux_cache, save_aux_cache): New functions.
	* sysdeps/generic/ldconfig.h (_PATH_LDCONFIG_AUX_CACHE): Define.
	(init_aux_cache, search_aux_cache, add_to_aux_cache,
	load_aux_cache, save_aux_cache, implicit_soname): New prototypes.
	(process_file): Adjust prototype.

--- libc/elf/readlib.c.jj	2007-07-16 09:58:46.000000000 +0200
+++ libc/elf/readlib.c	2007-07-27 17:45:36.000000000 +0200
@@ -1,4 +1,4 @@
-/* Copyright (C) 1999-2003, 2005 Free Software Foundation, Inc.
+/* Copyright (C) 1999-2003, 2005, 2007 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Andreas Jaeger <aj at suse.de>, 1999 and
 		  Jakub Jelinek <jakub at redhat.com>, 1999.
@@ -69,7 +69,7 @@ static struct known_names known_libs[] =
 int
 process_file (const char *real_file_name, const char *file_name,
 	      const char *lib, int *flag, unsigned int *osversion,
-	      char **soname, int is_link)
+	      char **soname, int is_link, struct stat64 *stat_buf)
 {
   FILE *file;
   struct stat64 statbuf;
@@ -135,7 +135,7 @@ process_file (const char *real_file_name
       )
     {
       /* Aout files don't have a soname, just return the name
-         including the major number.  */
+	 including the major number.  */
       char *copy, *major, *dot;
       copy = xstrdup (lib);
       major = strstr (copy, ".so.");
@@ -175,8 +175,31 @@ process_file (const char *real_file_name
   munmap (file_contents, statbuf.st_size);
   fclose (file);
 
+  *stat_buf = statbuf;
   return ret;
 }
 
+/* Returns made up soname if lib doesn't have explicit DT_SONAME.  */
+
+char *
+implicit_soname (const char *lib, int flag)
+{
+  char *soname = xstrdup (lib);
+
+  if ((flag & FLAG_TYPE_MASK) != FLAG_LIBC4)
+    return soname;
+
+  /* Aout files don't have a soname, just return the name
+     including the major number.  */
+  char *major = strstr (soname, ".so.");
+  if (major)
+    {
+      char *dot = strstr (major + 4, ".");
+      if (dot)
+	*dot = '\0';
+    }
+  return soname;
+}
+
 /* Get architecture specific version of process_elf_file.  */
 #include <readelflib.c>
--- libc/elf/readelflib.c.jj	2007-07-03 12:36:59.000000000 +0200
+++ libc/elf/readelflib.c	2007-07-27 15:24:36.000000000 +0200
@@ -231,11 +231,5 @@ process_elf_file (const char *file_name,
 	}
     }
 
-  /* We reach this point only if the file doesn't contain a DT_SONAME
-     or if we can't classify the library.  If it doesn't have a
-     soname, return the name of the library.  */
-  if (*soname == NULL)
-    *soname = xstrdup (lib);
-
   return 0;
 }
--- libc/elf/ldconfig.c.jj	2007-07-16 09:58:46.000000000 +0200
+++ libc/elf/ldconfig.c	2007-07-27 18:07:32.000000000 +0200
@@ -112,6 +112,9 @@ static char *opt_chroot;
 /* Manually link given shared libraries.  */
 static int opt_manual_link;
 
+/* Should we ignore an old auxiliary cache file?  */
+static int opt_ignore_aux_cache;
+
 /* Cache file to use.  */
 static char *cache_file;
 
@@ -142,6 +145,7 @@ static const struct argp_option options[
   { 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', N_("FORMAT"), 0, N_("Format to use: new, old or compat (default)"), 0},
+  { "ignore-aux-cache", 'i', NULL, 0, N_("Ignore auxiliary cache file"), 0},
   { NULL, 0, NULL, 0, NULL, 0 }
 };
 
@@ -238,10 +242,15 @@ parse_opt (int key, char *arg, struct ar
     {
     case 'C':
       cache_file = arg;
+      /* Ignore auxiliary cache since we use non-standard cache.  */
+      opt_ignore_aux_cache = 1;
       break;
     case 'f':
       config_file = arg;
       break;
+    case 'i':
+      opt_ignore_aux_cache = 1;
+      break;
     case 'l':
       opt_manual_link = 1;
       break;
@@ -518,7 +527,7 @@ manual_link (char *library)
   if (libname)
     {
       /* Successfully split names.  Check if path is just "/" to avoid
-         an empty path.  */
+	 an empty path.  */
       if (libname == path)
 	{
 	  libname = library + 1;
@@ -572,14 +581,17 @@ manual_link (char *library)
       free (path);
       return;
     }
+
   if (process_file (real_library, library, libname, &flag, &osversion,
-		    &soname, 0))
+		    &soname, 0, &stat_buf))
     {
       error (0, 0, _("No link created since soname could not be found for %s"),
 	     library);
       free (path);
       return;
     }
+  if (soname == NULL)
+    soname = implicit_soname (libname, flag);
   create_links (real_path, path, libname, soname);
   free (soname);
   free (path);
@@ -625,23 +637,7 @@ struct dlib_entry
 static void
 search_dir (const struct dir_entry *entry)
 {
-  DIR *dir;
-  struct dirent64 *direntry;
-  char *file_name, *dir_name, *real_file_name, *real_name;
-  int file_name_len, real_file_name_len, len;
-  char *soname;
-  struct dlib_entry *dlibs;
-  struct dlib_entry *dlib_ptr;
-  struct stat64 lstat_buf, stat_buf;
-  int is_link, is_dir;
   uint64_t hwcap = path_hwcap (entry->path);
-  unsigned int osversion;
-
-  file_name_len = PATH_MAX;
-  file_name = alloca (file_name_len);
-
-  dlibs = NULL;
-
   if (opt_verbose)
     {
       if (hwcap != 0)
@@ -650,6 +646,11 @@ search_dir (const struct dir_entry *entr
 	printf ("%s:\n", entry->path);
     }
 
+  char *dir_name;
+  char *real_file_name;
+  size_t real_file_name_len;
+  size_t file_name_len = PATH_MAX;
+  char *file_name = alloca (file_name_len);
   if (opt_chroot)
     {
       dir_name = chroot_canon (opt_chroot, entry->path);
@@ -663,6 +664,7 @@ search_dir (const struct dir_entry *entr
       real_file_name = file_name;
     }
 
+  DIR *dir;
   if (dir_name == NULL || (dir = opendir (dir_name)) == NULL)
     {
       if (opt_verbose)
@@ -672,6 +674,8 @@ search_dir (const struct dir_entry *entr
       return;
     }
 
+  struct dirent64 *direntry;
+  struct dlib_entry *dlibs = NULL;
   while ((direntry = readdir64 (dir)) != NULL)
     {
       int flag;
@@ -695,7 +699,8 @@ search_dir (const struct dir_entry *entr
 #endif
 	      !is_hwcap_platform (direntry->d_name)))
 	continue;
-      len = strlen (direntry->d_name);
+
+      size_t len = strlen (direntry->d_name);
       /* Skip temporary files created by the prelink program.  Files with
 	 names like these are never really DSOs we want to look at.  */
       if (len >= sizeof (".#prelink#") - 1)
@@ -727,7 +732,10 @@ search_dir (const struct dir_entry *entr
 	    }
 	  sprintf (real_file_name, "%s/%s", dir_name, direntry->d_name);
 	}
+
+      struct stat64 lstat_buf;
 #ifdef _DIRENT_HAVE_D_TYPE
+      /* We optimize and try to do the lstat call only if needed.  */
       if (direntry->d_type != DT_UNKNOWN)
 	lstat_buf.st_mode = DTTOIF (direntry->d_type);
       else
@@ -738,9 +746,11 @@ search_dir (const struct dir_entry *entr
 	    continue;
 	  }
 
-      is_link = S_ISLNK (lstat_buf.st_mode);
+      struct stat64 stat_buf;
+      int is_dir;
+      int is_link = S_ISLNK (lstat_buf.st_mode);
       if (is_link)
-        {
+	{
 	  /* In case of symlink, we check if the symlink refers to
 	     a directory. */
 	  if (__builtin_expect (stat64 (real_file_name, &stat_buf), 0))
@@ -754,6 +764,12 @@ search_dir (const struct dir_entry *entr
 	      continue;
 	    }
 	  is_dir = S_ISDIR (stat_buf.st_mode);
+
+	  /* lstat_buf is later stored, update contents.  */
+	  lstat_buf.st_dev = stat_buf.st_dev;
+	  lstat_buf.st_ino = stat_buf.st_ino;
+	  lstat_buf.st_size = stat_buf.st_size;
+	  lstat_buf.st_ctime = stat_buf.st_ctime;
 	}
       else
 	is_dir = S_ISDIR (lstat_buf.st_mode);
@@ -767,36 +783,28 @@ search_dir (const struct dir_entry *entr
 	  new_entry->path = xstrdup (file_name);
 	  new_entry->flag = entry->flag;
 	  new_entry->next = NULL;
-	  if (is_link)
+#ifdef _DIRENT_HAVE_D_TYPE
+	  /* We have filled in lstat only #ifndef
+	     _DIRENT_HAVE_D_TYPE.  Fill it in if needed.  */
+	  if (!is_link
+	      && direntry->d_type != DT_UNKNOWN
+	      && __builtin_expect (lstat64 (real_file_name, &lstat_buf), 0))
 	    {
-	      new_entry->ino = stat_buf.st_ino;
-	      new_entry->dev = stat_buf.st_dev;
+	      error (0, errno, _("Cannot lstat %s"), file_name);
+	      free (new_entry->path);
+	      free (new_entry);
+	      continue;
 	    }
-	  else
-	    {
-#ifdef _DIRENT_HAVE_D_TYPE
-	      /* We have filled in lstat only #ifndef
-		 _DIRENT_HAVE_D_TYPE.  Fill it in if needed.  */
-	      if (direntry->d_type != DT_UNKNOWN
-		  && __builtin_expect (lstat64 (real_file_name, &lstat_buf),
-				       0))
-		{
-		  error (0, errno, _("Cannot lstat %s"), file_name);
-		  free (new_entry->path);
-		  free (new_entry);
-		  continue;
-		}
 #endif
-
-	      new_entry->ino = lstat_buf.st_ino;
-	      new_entry->dev = lstat_buf.st_dev;
-	    }
+	  new_entry->ino = lstat_buf.st_ino;
+	  new_entry->dev = lstat_buf.st_dev;
 	  add_single_dir (new_entry, 0);
 	  continue;
 	}
       else if (!S_ISREG (lstat_buf.st_mode) && !is_link)
 	continue;
 
+      char *real_name;
       if (opt_chroot && is_link)
 	{
 	  real_name = chroot_canon (opt_chroot, file_name);
@@ -810,14 +818,36 @@ search_dir (const struct dir_entry *entr
       else
 	real_name = real_file_name;
 
-      if (process_file (real_name, file_name, direntry->d_name, &flag,
-			&osversion, &soname, is_link))
+#ifdef _DIRENT_HAVE_D_TYPE
+      /* Call lstat64 if not done yet.  */
+      if (!is_link
+	  && direntry->d_type != DT_UNKNOWN
+	  && __builtin_expect (lstat64 (real_file_name, &lstat_buf), 0))
 	{
-	  if (real_name != real_file_name)
-	    free (real_name);
+	  error (0, errno, _("Cannot lstat %s"), file_name);
 	  continue;
 	}
+#endif
+
+      /* First search whether the auxiliary cache contains this
+	 library already and it's not changed.  */
+      char *soname;
+      unsigned int osversion;
+      if (!search_aux_cache (&lstat_buf, &flag, &osversion, &soname))
+	{
+	  if (process_file (real_name, file_name, direntry->d_name, &flag,
+			    &osversion, &soname, is_link, &lstat_buf))
+	    {
+	      if (real_name != real_file_name)
+		free (real_name);
+	      continue;
+	    }
+	  else if (opt_build_cache)
+	    add_to_aux_cache (&lstat_buf, flag, osversion, soname);
+	}
 
+      if (soname == NULL)
+	soname = implicit_soname (direntry->d_name, flag);
 
       /* A link may just point to itself.  */
       if (is_link)
@@ -834,7 +864,7 @@ search_dir (const struct dir_entry *entr
 		  || strncmp (real_base_name, soname, len) != 0)
 		is_link = 0;
 	    }
-        }
+	}
 
       if (real_name != real_file_name)
 	free (real_name);
@@ -849,6 +879,7 @@ search_dir (const struct dir_entry *entr
 	  && (entry->flag == FLAG_ELF_LIBC5
 	      || entry->flag == FLAG_ELF_LIBC6))
 	flag = entry->flag;
+
       /* Some sanity checks to print warnings.  */
       if (opt_verbose)
 	{
@@ -864,6 +895,7 @@ search_dir (const struct dir_entry *entr
 	}
 
       /* Add library to list.  */
+      struct dlib_entry *dlib_ptr;
       for (dlib_ptr = dlibs; dlib_ptr != NULL; dlib_ptr = dlib_ptr->next)
 	{
 	  /* Is soname already in list?  */
@@ -888,12 +920,13 @@ search_dir (const struct dir_entry *entr
 			dlib_ptr->flag = flag;
 		      else
 			error (0, 0, _("libraries %s and %s in directory %s have same soname but different type."),
-			       dlib_ptr->name, direntry->d_name, entry->path);
+			       dlib_ptr->name, direntry->d_name,
+			       entry->path);
 		    }
 		  free (dlib_ptr->name);
-		  dlib_ptr->osversion = osversion;
 		  dlib_ptr->name = xstrdup (direntry->d_name);
 		  dlib_ptr->is_link = is_link;
+		  dlib_ptr->osversion = osversion;
 		}
 	      /* Don't add this library, abort loop.  */
 	      /* Also free soname, since it's dynamically allocated.  */
@@ -906,10 +939,10 @@ search_dir (const struct dir_entry *entr
 	{
 	  dlib_ptr = (struct dlib_entry *)xmalloc (sizeof (struct dlib_entry));
 	  dlib_ptr->name = xstrdup (direntry->d_name);
-	  dlib_ptr->flag = flag;
-	  dlib_ptr->osversion = osversion;
 	  dlib_ptr->soname = soname;
+	  dlib_ptr->flag = flag;
 	  dlib_ptr->is_link = is_link;
+	  dlib_ptr->osversion = osversion;
 	  /* Add at head of list.  */
 	  dlib_ptr->next = dlibs;
 	  dlibs = dlib_ptr;
@@ -920,6 +953,7 @@ search_dir (const struct dir_entry *entr
 
   /* Now dlibs contains a list of all libs - add those to the cache
      and created all symbolic links.  */
+  struct dlib_entry *dlib_ptr;
   for (dlib_ptr = dlibs; dlib_ptr != NULL; dlib_ptr = dlib_ptr->next)
     {
       /* Don't create links to links.  */
@@ -1246,7 +1280,7 @@ main (int argc, char **argv)
   if (opt_chroot)
     {
       /* Canonicalize the directory name of cache_file, not cache_file,
-         because we'll rename a temporary cache file to it.  */
+	 because we'll rename a temporary cache file to it.  */
       char *p = strrchr (cache_file, '/');
       char *canon = chroot_canon (opt_chroot,
 				  p ? (*p = '\0', cache_file) : "/");
@@ -1293,10 +1327,18 @@ main (int argc, char **argv)
 	add_system_dir (LIBDIR);
     }
 
+  if (! opt_ignore_aux_cache)
+    load_aux_cache (_PATH_LDCONFIG_AUX_CACHE);
+  else
+    init_aux_cache ();
+
   search_dirs ();
 
   if (opt_build_cache)
-    save_cache (cache_file);
+    {
+      save_cache (cache_file);
+      save_aux_cache (_PATH_LDCONFIG_AUX_CACHE);
+    }
 
   return 0;
 }
--- libc/elf/cache.c.jj	2007-07-16 09:58:46.000000000 +0200
+++ libc/elf/cache.c	2007-07-27 18:20:09.000000000 +0200
@@ -1,4 +1,4 @@
-/* Copyright (C) 1999-2003,2005,2006 Free Software Foundation, Inc.
+/* Copyright (C) 1999-2003,2005,2006,2007 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Andreas Jaeger <aj at suse.de>, 1999.
 
@@ -20,6 +20,7 @@
 #include <error.h>
 #include <dirent.h>
 #include <inttypes.h>
+#include <libgen.h>
 #include <libintl.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -80,16 +81,16 @@ print_entry (const char *lib, int flag, 
       fputs (",x86-64", stdout);
       break;
     case FLAG_S390_LIB64:
-      fputs(",64bit", stdout);
+      fputs (",64bit", stdout);
       break;
     case FLAG_POWERPC_LIB64:
-      fputs(",64bit", stdout);
+      fputs (",64bit", stdout);
       break;
     case FLAG_MIPS64_LIBN32:
-      fputs(",N32", stdout);
+      fputs (",N32", stdout);
       break;
     case FLAG_MIPS64_LIBN64:
-      fputs(",64bit", stdout);
+      fputs (",64bit", stdout);
     case 0:
       break;
     default:
@@ -128,19 +129,11 @@ print_entry (const char *lib, int flag, 
 void
 print_cache (const char *cache_name)
 {
-  size_t cache_size;
-  struct stat64 st;
-  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);
+  int fd = open (cache_name, O_RDONLY);
   if (fd < 0)
     error (EXIT_FAILURE, errno, _("Can't open cache file %s\n"), cache_name);
 
+  struct stat64 st;
   if (fstat64 (fd, &st) < 0
       /* No need to map the file if it is empty.  */
       || st.st_size == 0)
@@ -149,14 +142,19 @@ print_cache (const char *cache_name)
       return;
     }
 
-  cache = mmap (0, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
+  struct cache_file *cache
+    = mmap (NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
   if (cache == MAP_FAILED)
     error (EXIT_FAILURE, errno, _("mmap of cache file failed.\n"));
-  cache_size = st.st_size;
 
+  size_t cache_size = st.st_size;
   if (cache_size < sizeof (struct cache_file))
     error (EXIT_FAILURE, 0, _("File is not a cache file.\n"));
 
+  struct cache_file_new *cache_new = NULL;
+  const char *cache_data;
+  int format = 0;
+
   if (memcmp (cache->magic, CACHEMAGIC, sizeof CACHEMAGIC - 1))
     {
       /* This can only be the new format without the old one.  */
@@ -201,7 +199,7 @@ print_cache (const char *cache_name)
       printf (_("%d libs found in cache `%s'\n"), cache->nlibs, cache_name);
 
       /* Print everything.  */
-      for (i = 0; i < cache->nlibs; i++)
+      for (unsigned int i = 0; i < cache->nlibs; i++)
 	print_entry (cache_data + cache->libs[i].key,
 		     cache->libs[i].flags, 0, 0,
 		     cache_data + cache->libs[i].value);
@@ -212,7 +210,7 @@ print_cache (const char *cache_name)
 	      cache_new->nlibs, cache_name);
 
       /* Print everything.  */
-      for (i = 0; i < cache_new->nlibs; i++)
+      for (unsigned int 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].osversion,
@@ -231,15 +229,11 @@ init_cache (void)
   entries = NULL;
 }
 
-
-
-static
-int compare (const struct cache_entry *e1, const struct cache_entry *e2)
+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 = _dl_cache_libcmp (e2->lib, e1->lib);
+  int res = _dl_cache_libcmp (e2->lib, e1->lib);
   if (res == 0)
     {
       if (e1->flags < e2->flags)
@@ -267,29 +261,19 @@ int compare (const struct cache_entry *e
 void
 save_cache (const char *cache_name)
 {
-  struct cache_entry *entry;
-  int fd, idx_old, idx_new;
-  size_t total_strlen, len;
-  char *strings, *str, *temp_name;
-  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;
-  /* Pad for alignment of cache_file_new.  */
-  size_t pad;
-
   /* 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;
+  size_t total_strlen = 0;
+  struct cache_entry *entry;
+  /* Number of cache entries.  */
+  int cache_entry_count = 0;
+  /* Number of normal cache entries.  */
+  int cache_entry_old_count = 0;
+
   for (entry = entries; entry != NULL; entry = entry->next)
     {
       /* Account the final NULs.  */
@@ -300,8 +284,8 @@ save_cache (const char *cache_name)
     }
 
   /* Create the on disk cache structure.  */
-  /* First an array for all strings.  */
-  strings = (char *)xmalloc (total_strlen);
+  struct cache_file *file_entries = NULL;
+  size_t file_entries_size = 0;
 
   if (opt_format != 2)
     {
@@ -315,25 +299,27 @@ save_cache (const char *cache_name)
       /* 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);
+      file_entries = xmalloc (file_entries_size);
 
       /* Fill in the header.  */
-      memset (file_entries, 0, sizeof (struct cache_file));
+      memset (file_entries, '\0', sizeof (struct cache_file));
       memcpy (file_entries->magic, CACHEMAGIC, sizeof CACHEMAGIC - 1);
 
       file_entries->nlibs = cache_entry_old_count;
     }
 
+  struct cache_file_new *file_entries_new = NULL;
+  size_t file_entries_new_size = 0;
+
   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);
+      file_entries_new = xmalloc (file_entries_new_size);
 
       /* Fill in the header.  */
-      memset (file_entries_new, 0, sizeof (struct cache_file_new));
+      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,
@@ -343,17 +329,24 @@ save_cache (const char *cache_name)
       file_entries_new->len_strings = total_strlen;
     }
 
-  pad = ALIGN_CACHE (file_entries_size) - file_entries_size;
+  /* Pad for alignment of cache_file_new.  */
+  size_t pad = ALIGN_CACHE (file_entries_size) - file_entries_size;
 
   /* 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.  */
+  unsigned int str_offset;
   if (opt_format != 0)
     str_offset = file_entries_new_size;
   else
     str_offset = 0;
 
-  str = strings;
+  /* An array for all strings.  */
+  char *strings = xmalloc (total_strlen);
+  char *str = strings;
+  int idx_old;
+  int idx_new;
+
   for (idx_old = 0, idx_new = 0, entry = entries; entry != NULL;
        entry = entry->next, ++idx_new)
     {
@@ -375,21 +368,18 @@ save_cache (const char *cache_name)
 	  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;
+
+      size_t len = strlen (entry->lib) + 1;
+      str = mempcpy (str, entry->lib, len);
+      str_offset += len;
       /* Then the path.  */
       if (opt_format != 2 && entry->hwcap == 0)
 	file_entries->libs[idx_old].value = str_offset + pad;
       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;
+      len = strlen (entry->path) + 1;
+      str = mempcpy (str, entry->path, len);
+      str_offset += len;
       /* Ignore entries with hwcap for old format.  */
       if (entry->hwcap == 0)
 	++idx_old;
@@ -403,16 +393,12 @@ save_cache (const char *cache_name)
   /* Write out the cache.  */
 
   /* Write cache first to a temporary file and rename it later.  */
-  temp_name = xmalloc (strlen (cache_name) + 2);
+  char *temp_name = xmalloc (strlen (cache_name) + 2);
   sprintf (temp_name, "%s~", cache_name);
-  /* First remove an old copy if it exists.  */
-  if (unlink (temp_name) && errno != ENOENT)
-    error (EXIT_FAILURE, errno, _("Can't remove old temporary cache file %s"),
-	   temp_name);
 
   /* Create file.  */
-  fd = open (temp_name, O_CREAT|O_WRONLY|O_TRUNC|O_NOFOLLOW,
-	     S_IROTH|S_IRGRP|S_IRUSR|S_IWUSR);
+  int fd = open (temp_name, O_CREAT|O_WRONLY|O_TRUNC|O_NOFOLLOW,
+		 S_IRUSR|S_IWUSR);
   if (fd < 0)
     error (EXIT_FAILURE, errno, _("Can't create temporary cache file %s"),
 	   temp_name);
@@ -439,11 +425,10 @@ save_cache (const char *cache_name)
 	error (EXIT_FAILURE, errno, _("Writing of cache data failed"));
     }
 
-  if (write (fd, strings, total_strlen) != (ssize_t) total_strlen)
+  if (write (fd, strings, total_strlen) != (ssize_t) total_strlen
+      || close (fd))
     error (EXIT_FAILURE, errno, _("Writing of cache data failed"));
 
-  close (fd);
-
   /* Make sure user can always read cache file */
   if (chmod (temp_name, S_IROTH|S_IRGRP|S_IRUSR|S_IWUSR))
     error (EXIT_FAILURE, errno,
@@ -463,8 +448,6 @@ save_cache (const char *cache_name)
   while (entries)
     {
       entry = entries;
-      free (entry->path);
-      free (entry->lib);
       entries = entries->next;
       free (entry);
     }
@@ -476,33 +459,29 @@ void
 add_to_cache (const char *path, const char *lib, int flags,
 	      unsigned int osversion, uint64_t hwcap)
 {
-  struct cache_entry *new_entry, *ptr, *prev;
-  char *full_path;
-  size_t len, i;
-
-  new_entry = (struct cache_entry *) xmalloc (sizeof (struct cache_entry));
-
-  len = strlen (lib) + strlen (path) + 2;
-
-  full_path = (char *) xmalloc (len);
-  snprintf (full_path, len, "%s/%s", path, lib);
-
-  new_entry->lib = xstrdup (lib);
-  new_entry->path = full_path;
+  size_t liblen = strlen (lib) + 1;
+  size_t len = liblen + strlen (path) + 1;
+  struct cache_entry *new_entry
+    = xmalloc (sizeof (struct cache_entry) + liblen + len);
+
+  new_entry->lib = memcpy ((char *) (new_entry + 1), lib, liblen);
+  new_entry->path = new_entry->lib + liblen;
+  snprintf (new_entry->path, len, "%s/%s", path, lib);
   new_entry->flags = flags;
   new_entry->osversion = osversion;
   new_entry->hwcap = hwcap;
   new_entry->bits_hwcap = 0;
 
   /* Count the number of bits set in the masked value.  */
-  for (i = 0; (~((1ULL << i) - 1) & hwcap) != 0 && i < 8 * sizeof (hwcap); ++i)
+  for (size_t i = 0;
+       (~((1ULL << i) - 1) & hwcap) != 0 && i < 8 * sizeof (hwcap); ++i)
     if ((hwcap & (1ULL << i)) != 0)
       ++new_entry->bits_hwcap;
 
 
   /* Keep the list sorted - search for right place to insert.  */
-  ptr = entries;
-  prev = entries;
+  struct cache_entry *ptr = entries;
+  struct cache_entry *prev = entries;
   while (ptr != NULL)
     {
       if (compare (ptr, new_entry) > 0)
@@ -522,3 +501,304 @@ add_to_cache (const char *path, const ch
       prev->next = new_entry;
     }
 }
+
+
+/* Auxiliary cache.  */
+
+struct aux_cache_entry_id
+{
+  uint64_t ino;
+  uint64_t ctime;
+  uint64_t size;
+  uint64_t dev;
+};
+
+struct aux_cache_entry
+{
+  struct aux_cache_entry_id id;
+  int flags;
+  unsigned int osversion;
+  int used;
+  char *soname;
+  struct aux_cache_entry *next;
+};
+
+#define AUX_CACHEMAGIC		"glibc-ld.so.auxcache-1.0"
+
+struct aux_cache_file_entry
+{
+  struct aux_cache_entry_id id;	/* Unique id of entry.  */
+  int32_t flags;		/* This is 1 for an ELF library.  */
+  uint32_t soname;		/* String table indice.  */
+  uint32_t osversion;		/* Required OS version.	 */
+  int32_t pad;
+};
+
+/* ldconfig maintains an auxiliary cache file that allows
+   only reading those libraries that have changed since the last iteration.
+   For this for each library some information is cached in the auxiliary
+   cache.  */
+struct aux_cache_file
+{
+  char magic[sizeof AUX_CACHEMAGIC - 1];
+  uint32_t nlibs;		/* Number of entries.  */
+  uint32_t len_strings;		/* Size of string table. */
+  struct aux_cache_file_entry libs[0]; /* Entries describing libraries.  */
+  /* After this the string table of size len_strings is found.	*/
+};
+
+static unsigned int primes[] =
+{
+  1021, 2039, 4093, 8191, 16381, 32749, 65521, 131071, 262139,
+  524287, 1048573, 2097143, 4194301, 8388593, 16777213, 33554393,
+  67108859, 134217689, 268435399, 536870909, 1073741789, 2147483647
+};
+
+static size_t aux_hash_size;
+static struct aux_cache_entry **aux_hash;
+
+/* Simplistic hash function for aux_cache_entry_id.  */
+static unsigned int
+aux_cache_entry_id_hash (struct aux_cache_entry_id *id)
+{
+  uint64_t ret = ((id->ino * 11 + id->ctime) * 11 + id->size) * 11 + id->dev;
+  return ret ^ (ret >> 32);
+}
+
+static size_t nextprime (size_t x)
+{
+  for (unsigned int i = 0; i < sizeof (primes) / sizeof (primes[0]); ++i)
+    if (primes[i] >= x)
+      return primes[i];
+  return x;
+}
+
+void
+init_aux_cache (void)
+{
+  aux_hash_size = primes[3];
+  aux_hash = xcalloc (aux_hash_size, sizeof (struct aux_cache_entry *));
+}
+
+int
+search_aux_cache (struct stat64 *stat_buf, int *flags,
+		  unsigned int *osversion, char **soname)
+{
+  struct aux_cache_entry_id id;
+  id.ino = (uint64_t) stat_buf->st_ino;
+  id.ctime = (uint64_t) stat_buf->st_ctime;
+  id.size = (uint64_t) stat_buf->st_size;
+  id.dev = (uint64_t) stat_buf->st_dev;
+
+  unsigned int hash = aux_cache_entry_id_hash (&id);
+  struct aux_cache_entry *entry;
+  for (entry = aux_hash[hash % aux_hash_size]; entry; entry = entry->next)
+    if (id.ino == entry->id.ino
+	&& id.ctime == entry->id.ctime
+	&& id.size == entry->id.size
+	&& id.dev == entry->id.dev)
+      {
+	*flags = entry->flags;
+	*osversion = entry->osversion;
+	if (entry->soname != NULL)
+	  *soname = xstrdup (entry->soname);
+	else
+	  *soname = NULL;
+	entry->used = 1;
+	return 1;
+      }
+
+  return 0;
+}
+
+static void
+insert_to_aux_cache (struct aux_cache_entry_id *id, int flags,
+		     unsigned int osversion, const char *soname, int used)
+{
+  size_t hash = aux_cache_entry_id_hash (id) % aux_hash_size;
+  struct aux_cache_entry *entry;
+  for (entry = aux_hash[hash]; entry; entry = entry->next)
+    if (id->ino == entry->id.ino
+	&& id->ctime == entry->id.ctime
+	&& id->size == entry->id.size
+	&& id->dev == entry->id.dev)
+      abort ();
+
+  size_t len = soname ? strlen (soname) + 1 : 0;
+  entry = xmalloc (sizeof (struct aux_cache_entry) + len);
+  entry->id = *id;
+  entry->flags = flags;
+  entry->osversion = osversion;
+  entry->used = used;
+  if (soname != NULL)
+    entry->soname = memcpy ((char *) (entry + 1), soname, len);
+  else
+    entry->soname = NULL;
+  entry->next = aux_hash[hash];
+  aux_hash[hash] = entry;
+}
+
+void
+add_to_aux_cache (struct stat64 *stat_buf, int flags,
+		  unsigned int osversion, const char *soname)
+{
+  struct aux_cache_entry_id id;
+  id.ino = (uint64_t) stat_buf->st_ino;
+  id.ctime = (uint64_t) stat_buf->st_ctime;
+  id.size = (uint64_t) stat_buf->st_size;
+  id.dev = (uint64_t) stat_buf->st_dev;
+  insert_to_aux_cache (&id, flags, osversion, soname, 1);
+}
+
+/* Load auxiliary cache to search for unchanged entries.   */
+void
+load_aux_cache (const char *aux_cache_name)
+{
+  int fd = open (aux_cache_name, O_RDONLY);
+  if (fd < 0)
+    {
+      init_aux_cache ();
+      return;
+    }
+
+  struct stat64 st;
+  if (fstat64 (fd, &st) < 0 || st.st_size < sizeof (struct aux_cache_file))
+    {
+      close (fd);
+      init_aux_cache ();
+      return;
+    }
+
+  size_t aux_cache_size = st.st_size;
+  struct aux_cache_file *aux_cache
+    = mmap (NULL, aux_cache_size, PROT_READ, MAP_PRIVATE, fd, 0);
+  if (aux_cache == MAP_FAILED
+      || aux_cache_size < sizeof (struct aux_cache_file)
+      || memcmp (aux_cache->magic, AUX_CACHEMAGIC, sizeof AUX_CACHEMAGIC - 1)
+      || aux_cache->nlibs < 0
+      || aux_cache->nlibs >= aux_cache_size)
+    {
+      close (fd);
+      init_aux_cache ();
+      return;
+    }
+
+  aux_hash_size = nextprime (aux_cache->nlibs);
+  aux_hash = xcalloc (aux_hash_size, sizeof (struct aux_cache_entry *));
+
+  const char *aux_cache_data
+    = (const char *) &aux_cache->libs[aux_cache->nlibs];
+  for (unsigned int i = 0; i < aux_cache->nlibs; ++i)
+    insert_to_aux_cache (&aux_cache->libs[i].id,
+			 aux_cache->libs[i].flags,
+			 aux_cache->libs[i].osversion,
+			 aux_cache->libs[i].soname == 0
+			 ? NULL : aux_cache_data + aux_cache->libs[i].soname,
+			 0);
+
+  munmap (aux_cache, aux_cache_size);
+  close (fd);
+}
+
+/* Save the contents of the auxiliary cache.  */
+void
+save_aux_cache (const char *aux_cache_name)
+{
+  /* Count the length of all sonames.  We start with empty string.  */
+  size_t total_strlen = 1;
+  /* Number of cache entries.  */
+  int cache_entry_count = 0;
+
+  for (size_t i = 0; i < aux_hash_size; ++i)
+    for (struct aux_cache_entry *entry = aux_hash[i];
+	 entry != NULL; entry = entry->next)
+      if (entry->used)
+	{
+	  ++cache_entry_count;
+	  if (entry->soname != NULL)
+	    total_strlen += strlen (entry->soname) + 1;
+	}
+
+  /* Auxiliary cache.  */
+  size_t file_entries_size
+    = sizeof (struct aux_cache_file)
+      + cache_entry_count * sizeof (struct aux_cache_file_entry);
+  struct aux_cache_file *file_entries
+    = xmalloc (file_entries_size + total_strlen);
+
+  /* Fill in the header of the auxiliary cache.  */
+  memset (file_entries, '\0', sizeof (struct aux_cache_file));
+  memcpy (file_entries->magic, AUX_CACHEMAGIC, sizeof AUX_CACHEMAGIC - 1);
+
+  file_entries->nlibs = cache_entry_count;
+  file_entries->len_strings = total_strlen;
+
+  /* Initial String offset for auxiliary cache is always after the
+     special empty string.  */
+  unsigned int str_offset = 1;
+
+  /* An array for all strings.  */
+  char *str = (char *) file_entries + file_entries_size;
+  *str++ = '\0';
+
+  size_t idx = 0;
+  for (size_t i = 0; i < aux_hash_size; ++i)
+    for (struct aux_cache_entry *entry = aux_hash[i];
+	 entry != NULL; entry = entry->next)
+      if (entry->used)
+	{
+	  file_entries->libs[idx].id = entry->id;
+	  file_entries->libs[idx].flags = entry->flags;
+	  if (entry->soname == NULL)
+	    file_entries->libs[idx].soname = 0;
+	  else
+	    {
+	      file_entries->libs[idx].soname = str_offset;
+
+	      size_t len = strlen (entry->soname) + 1;
+	      str = mempcpy (str, entry->soname, len);
+	      str_offset += len;
+	    }
+	  file_entries->libs[idx].osversion = entry->osversion;
+	  file_entries->libs[idx++].pad = 0;
+	}
+
+  /* Write out auxiliary cache file.  */
+  /* Write auxiliary cache first to a temporary file and rename it later.  */
+
+  char *temp_name = xmalloc (strlen (aux_cache_name) + 2);
+  sprintf (temp_name, "%s~", aux_cache_name);
+
+  /* Check that directory exists and create if needed.  */
+  char *dir = strdupa (aux_cache_name);
+  dir = dirname (dir);
+
+  struct stat64 st;
+  if (stat64 (dir, &st) < 0)
+    {
+      if (mkdir (dir, 0700) < 0)
+	error (EXIT_FAILURE, errno, _("Cannot create directory %s"), dir);
+    }
+
+  /* Create file.  */
+  int fd = open (temp_name, O_CREAT|O_WRONLY|O_TRUNC|O_NOFOLLOW,
+		 S_IRUSR|S_IWUSR);
+  if (fd < 0)
+    error (EXIT_FAILURE, errno,
+	   _("Can't create temporary auxiliary cache file %s"),
+	   temp_name);
+
+  if (write (fd, file_entries, file_entries_size + total_strlen)
+      != (ssize_t) (file_entries_size + total_strlen)
+      || close (fd))
+    error (EXIT_FAILURE, errno,
+	   _("Writing of auxiliary cache data failed"));
+
+  /* Move temporary to its final location.  */
+  if (rename (temp_name, aux_cache_name))
+    error (EXIT_FAILURE, errno, _("Renaming of %s to %s failed"), temp_name,
+	   aux_cache_name);
+
+  /* Free allocated memory.  */
+  free (file_entries);
+}
--- libc/sysdeps/generic/ldconfig.h.jj	2003-03-14 06:32:49.000000000 +0100
+++ libc/sysdeps/generic/ldconfig.h	2007-07-27 17:39:46.000000000 +0200
@@ -1,4 +1,4 @@
-/* Copyright (C) 1999, 2000, 2002, 2003 Free Software Foundation, Inc.
+/* Copyright (C) 1999, 2000, 2002, 2003, 2007 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Andreas Jaeger <aj at suse.de>, 1999.
 
@@ -35,6 +35,9 @@
 #define FLAG_MIPS64_LIBN32	0x0600
 #define FLAG_MIPS64_LIBN64	0x0700
 
+/* Name of auxiliary cache.  */
+#define _PATH_LDCONFIG_AUX_CACHE "/var/cache/ldconfig/aux-cache"
+
 /* Declared in cache.c.  */
 extern void print_cache (const char *cache_name);
 
@@ -45,10 +48,24 @@ extern void save_cache (const char *cach
 extern void add_to_cache (const char *path, const char *lib, int flags,
 			  unsigned int osversion, uint64_t hwcap);
 
+extern void init_aux_cache (void);
+
+extern void load_aux_cache (const char *aux_cache_name);
+
+extern int search_aux_cache (struct stat64 *stat_buf, int *flags,
+			     unsigned int *osversion, char **soname);
+
+extern void add_to_aux_cache (struct stat64 *stat_buf, int flags,
+			      unsigned int osversion, const char *soname);
+
+extern void save_aux_cache (const char *aux_cache_name);
+
 /* Declared in readlib.c.  */
 extern int process_file (const char *real_file_name, const char *file_name,
 			 const char *lib, int *flag, unsigned int *osversion,
-			 char **soname, int is_link);
+			 char **soname, int is_link, struct stat64 *stat_buf);
+
+extern char *implicit_soname (const char *lib, int flag);
 
 /* Declared in readelflib.c.  */
 extern int process_elf_file (const char *file_name, const char *lib, int *flag,


glibc-private-futex.patch:

--- NEW FILE glibc-private-futex.patch ---
2007-07-31  Anton Blanchard  <anton at samba.org>

	* sysdeps/unix/sysv/linux/powerpc/sem_post.c (__new_sem_post):
	Use __asm __volatile (__lll_acq_instr ::: "memory") instead of
	atomic_full_barrier.

2007-07-31  Jakub Jelinek  <jakub at redhat.com>

	* allocatestack.c (stack_cache_lock): Change type to int.
	(get_cached_stack, allocate_stack, __deallocate_stack,
	__make_stacks_executable, __find_thread_by_id, __nptl_setxid,
	__pthread_init_static_tls, __wait_lookup_done): Add LLL_PRIVATE
	as second argument to lll_lock and lll_unlock macros on
	stack_cache_lock.
	* pthread_create.c (__find_in_stack_list): Likewise.
	(start_thread): Similarly with pd->lock.  Use lll_robust_dead
	macro instead of lll_robust_mutex_dead, pass LLL_SHARED to it
	as second argument.
	* descr.h (struct pthread): Change lock and setxid_futex field
	type to int.
	* old_pthread_cond_broadcast.c (__pthread_cond_broadcast_2_0): Use
	LLL_LOCK_INITIALIZER instead of LLL_MUTEX_LOCK_INITIALIZER.
	* old_pthread_cond_signal.c (__pthread_cond_signal_2_0): Likewise.
	* old_pthread_cond_timedwait.c (__pthread_cond_timedwait_2_0):
	Likewise.
	* old_pthread_cond_wait.c (__pthread_cond_wait_2_0): Likewise.
	* pthread_cond_init.c (__pthread_cond_init): Likewise.
	* pthreadP.h (__attr_list_lock): Change type to int.
	* pthread_attr_init.c (__attr_list_lock): Likewise.
	* pthread_barrier_destroy.c (pthread_barrier_destroy): Pass
	ibarrier->private ^ FUTEX_PRIVATE_FLAG as second argument to
	lll_{,un}lock.
	* pthread_barrier_wait.c (pthread_barrier_wait): Likewise and
	also for lll_futex_{wake,wait}.
	* pthread_barrier_init.c (pthread_barrier_init): Make iattr
	a pointer to const.
	* pthread_cond_broadcast.c (__pthread_cond_broadcast): Pass
	LLL_SHARED as second argument to lll_{,un}lock.
	* pthread_cond_destroy.c (__pthread_cond_destroy): Likewise.
	* pthread_cond_signal.c (__pthread_cond_singal): Likewise.
	* pthread_cond_timedwait.c (__pthread_cond_timedwait): Likewise.
	* pthread_cond_wait.c (__condvar_cleanup, __pthread_cond_wait):
	Likewise.
	* pthread_getattr_np.c (pthread_getattr_np): Add LLL_PRIVATE
	as second argument to lll_{,un}lock macros on pd->lock.
	* pthread_getschedparam.c (__pthread_getschedparam): Likewise.
	* pthread_setschedparam.c (__pthread_setschedparam): Likewise.
	* pthread_setschedprio.c (pthread_setschedprio): Likewise.
	* tpp.c (__pthread_tpp_change_priority, __pthread_current_priority):
	Likewise.
	* sysdeps/pthread/createthread.c (do_clone, create_thread):
	Likewise.
	* pthread_once.c (once_lock): Change type to int.
	(__pthread_once): Pass LLL_PRIVATE as second argument to
	lll_{,un}lock macros on once_lock.
	* pthread_rwlock_rdlock.c (__pthread_rwlock_rdlock): Use
	lll_{,un}lock macros instead of lll_mutex_{,un}lock, pass
	rwlock->__data.__shared as second argument to them and similarly
	for lll_futex_w*.
	* pthread_rwlock_timedrdlock.c (pthread_rwlock_timedrdlock):
	Likewise.
	* pthread_rwlock_timedwrlock.c (pthread_rwlock_timedwrlock):
	Likewise.
	* pthread_rwlock_tryrdlock.c (__pthread_rwlock_tryrdlock): Likewise.
	* pthread_rwlock_trywrlock.c (__pthread_rwlock_trywrlock): Likewise.
	* pthread_rwlock_unlock.c (__pthread_rwlock_unlock): Likewise.
	* pthread_rwlock_wrlock.c (__pthread_rwlock_wrlock): Likewise.
	* sem_close.c (sem_close): Pass LLL_PRIVATE as second argument
	to lll_{,un}lock macros on __sem_mappings_lock.
	* sem_open.c (check_add_mapping): Likewise.
	(__sem_mappings_lock): Change type to int.
	* semaphoreP.h (__sem_mappings_lock): Likewise.
	* pthread_mutex_lock.c (LLL_MUTEX_LOCK, LLL_MUTEX_TRYLOCK,
	LLL_ROBUST_MUTEX_LOCK): Use lll_{,try,robust_}lock macros
	instead of lll_*mutex_*, pass LLL_SHARED as last
	argument.
	(__pthread_mutex_lock): Use lll_unlock instead of lll_mutex_unlock,
	pass LLL_SHARED as last argument.
	* sysdeps/unix/sysv/linux/pthread_mutex_cond_lock.c (LLL_MUTEX_LOCK,
	LLL_MUTEX_TRYLOCK, LLL_ROBUST_MUTEX_LOCK): Use
	lll_{cond_,cond_try,robust_cond}lock macros instead of lll_*mutex_*,
	pass LLL_SHARED as last argument.
	* pthread_mutex_timedlock.c (pthread_mutex_timedlock): Use
	lll_{timed,try,robust_timed,un}lock instead of lll_*mutex*, pass
	LLL_SHARED as last argument.
	* pthread_mutex_trylock.c (__pthread_mutex_trylock): Similarly.
	* pthread_mutex_unlock.c (__pthread_mutex_unlock_usercnt):
	Similarly.
	* sysdeps/pthread/bits/libc-lock.h (__libc_lock_lock,
	__libc_lock_lock_recursive, __libc_lock_unlock,
	__libc_lock_unlock_recursive): Pass LLL_PRIVATE as second
	argument to lll_{,un}lock.
	* sysdeps/pthread/bits/stdio-lock.h (_IO_lock_lock,
	_IO_lock_unlock): Likewise.
	* sysdeps/unix/sysv/linux/fork.c (__libc_fork): Don't use
	compound literal.
	* sysdeps/unix/sysv/linux/unregister-atfork.c (__unregister_atfork):
	Pass LLL_PRIVATE as second argument to lll_{,un}lock macros on
	__fork_lock.
	* sysdeps/unix/sysv/linux/register-atfork.c (__register_atfork,
	free_mem): Likewise.
	(__fork_lock): Change type to int.
	* sysdeps/unix/sysv/linux/fork.h (__fork_lock): Likewise.
	* sysdeps/unix/sysv/linux/sem_post.c (__new_sem_post): Pass
	isem->private ^ FUTEX_PRIVATE_FLAG as second argument to
	lll_futex_wake.
	* sysdeps/unix/sysv/linux/sem_timedwait.c (sem_timedwait): Likewise.
	* sysdeps/unix/sysv/linux/sem_wait.c (__new_sem_wait): Likewise.
	* sysdeps/unix/sysv/linux/lowlevellock.c (__lll_lock_wait_private):
	New function.
	(__lll_lock_wait, __lll_timedlock_wait): Add private argument and
	pass it through to lll_futex_*wait, only compile in when
	IS_IN_libpthread.
	* sysdeps/unix/sysv/linux/lowlevelrobustlock.c
	(__lll_robust_lock_wait, __lll_robust_timedlock_wait): Add private
	argument and pass it through to lll_futex_*wait.
	* sysdeps/unix/sysv/linux/alpha/lowlevellock.h: Renamed all
	lll_mutex_* resp. lll_robust_mutex_* macros to lll_* resp.
	lll_robust_*.  Renamed all __lll_mutex_* resp. __lll_robust_mutex_*
	inline functions to __lll_* resp. __lll_robust_*.
	(LLL_MUTEX_LOCK_INITIALIZER): Remove.
	(lll_mutex_dead): Add private argument.
	(__lll_lock_wait_private): New prototype.
	(__lll_lock_wait, __lll_robust_lock_wait, __lll_lock_timedwait,
	__lll_robust_lock_timedwait): Add private argument to prototypes.
	(__lll_lock): Add private argument, if it is constant LLL_PRIVATE,
	call __lll_lock_wait_private, otherwise pass private to
	__lll_lock_wait.
	(__lll_robust_lock, __lll_cond_lock, __lll_timedlock,
	__lll_robust_timedlock): Add private argument, pass it to
	__lll_*wait functions.
	(__lll_unlock): Add private argument, if it is constant LLL_PRIVATE,
	call __lll_unlock_wake_private, otherwise pass private to
	__lll_unlock_wake.
	(__lll_robust_unlock): Add private argument, pass it to
	__lll_robust_unlock_wake.
	(lll_lock, lll_robust_lock, lll_cond_lock, lll_timedlock,
	lll_robust_timedlock, lll_unlock, lll_robust_unlock): Add private
	argument, pass it through to __lll_* inline function.
	(__lll_mutex_unlock_force, lll_mutex_unlock_force): Remove.
	(lll_lock_t): Remove.
	(__lll_cond_wait, __lll_cond_timedwait, __lll_cond_wake,
	__lll_cond_broadcast, lll_cond_wait, lll_cond_timedwait,
	lll_cond_wake, lll_cond_broadcast): Remove.
	* sysdeps/unix/sysv/linux/ia64/lowlevellock.h: Likewise.
	* sysdeps/unix/sysv/linux/powerpc/lowlevellock.h: Likewise.
	* sysdeps/unix/sysv/linux/s390/lowlevellock.h: Likewise.
	* sysdeps/unix/sysv/linux/sparc/lowlevellock.h: Likewise.
	* sysdeps/unix/sysv/linux/i386/lowlevellock.h: Allow including
	the header from assembler.  Renamed all lll_mutex_* resp.
	lll_robust_mutex_* macros to lll_* resp. lll_robust_*.
	(LOCK, FUTEX_CMP_REQUEUE, FUTEX_WAKE_OP,
	FUTEX_OP_CLEAR_WAKE_IF_GT_ONE): Define.
	(LLL_MUTEX_LOCK_INITIALIZER, LLL_MUTEX_LOCK_INITIALIZER_LOCKED,
	LLL_MUTEX_LOCK_INITIALIZER_WAITERS): Remove.
	(__lll_mutex_lock_wait, __lll_mutex_timedlock_wait,
	__lll_mutex_unlock_wake, __lll_lock_wait, __lll_unlock_wake):
	Remove prototype.
	(__lll_trylock_asm, __lll_lock_asm_start, __lll_unlock_asm): Define.
	(lll_robust_trylock, lll_cond_trylock): Use LLL_LOCK_INITIALIZER*
	rather than LLL_MUTEX_LOCK_INITIALIZER* macros.
	(lll_trylock): Likewise, use __lll_trylock_asm, pass
	MULTIPLE_THREADS_OFFSET as another asm operand.
	(lll_lock): Add private argument, use __lll_lock_asm_start, pass
	MULTIPLE_THREADS_OFFSET as last asm operand, call
	__lll_lock_wait_private if private is constant LLL_PRIVATE,
	otherwise pass private as another argument to __lll_lock_wait.
	(lll_robust_lock, lll_cond_lock, lll_robust_cond_lock,
	lll_timedlock, lll_robust_timedlock): Add private argument, pass
	private as another argument to __lll_*lock_wait call.
	(lll_unlock): Add private argument, use __lll_unlock_asm, pass
	MULTIPLE_THREADS_OFFSET as another asm operand, call
	__lll_unlock_wake_private if private is constant LLL_PRIVATE,
	otherwise pass private as another argument to __lll_unlock_wake.
	(lll_robust_unlock): Add private argument, pass private as another
	argument to __lll_unlock_wake.
	(lll_robust_dead): Add private argument, use __lll_private_flag
	macro.
	(lll_islocked): Use LLL_LOCK_INITIALIZER instead of
	LLL_MUTEX_LOCK_INITIALIZER.
	(lll_lock_t): Remove.
	(LLL_LOCK_INITIALIZER_WAITERS): Define.
	(__lll_cond_wait, __lll_cond_timedwait, __lll_cond_wake,
	__lll_cond_broadcast, lll_cond_wait, lll_cond_timedwait,
	lll_cond_wake, lll_cond_broadcast): Remove.
	* sysdeps/unix/sysv/linux/x86_64/lowlevellock.h: Likewise.
	* sysdeps/unix/sysv/linux/i386/i486/libc-lowlevellock.S: Revert
	2007-05-2{3,9} changes.
	* sysdeps/unix/sysv/linux/i386/i486/lowlevellock.S: Include
	kernel-features.h and lowlevellock.h.
	(LOAD_PRIVATE_FUTEX_WAIT): Define.
	(LOAD_FUTEX_WAIT): Rewritten.
	(LOCK, SYS_gettimeofday, SYS_futex, FUTEX_WAIT, FUTEX_WAKE): Don't
	define.
	(__lll_lock_wait_private, __lll_unlock_wake_private): New functions.
	(__lll_mutex_lock_wait): Rename to ...
	(__lll_lock_wait): ... this.  Take futex addr from %edx instead of
	%ecx, %ecx is now private argument.  Don't compile in for libc.so.
	(__lll_mutex_timedlock_wait): Rename to ...
[...7589 lines suppressed...]
@@ -303,26 +286,4 @@ extern int __lll_timedwait_tid (int *, c
     __res;						\
   })
 
-
-/* Conditional variable handling.  */
-
-extern void __lll_cond_wait (pthread_cond_t *cond)
-     attribute_hidden;
-extern int __lll_cond_timedwait (pthread_cond_t *cond,
-				 const struct timespec *abstime)
-     attribute_hidden;
-extern void __lll_cond_wake (pthread_cond_t *cond)
-     attribute_hidden;
-extern void __lll_cond_broadcast (pthread_cond_t *cond)
-     attribute_hidden;
-
-#define lll_cond_wait(cond) \
-  __lll_cond_wait (cond)
-#define lll_cond_timedwait(cond, abstime) \
-  __lll_cond_timedwait (cond, abstime)
-#define lll_cond_wake(cond) \
-  __lll_cond_wake (cond)
-#define lll_cond_broadcast(cond) \
-  __lll_cond_broadcast (cond)
-
 #endif	/* lowlevellock.h */
--- libc/nptl/sysdeps/unix/sysv/linux/sparc/pthread_barrier_wait.c.jj	2007-07-30 22:49:29.000000000 +0200
+++ libc/nptl/sysdeps/unix/sysv/linux/sparc/pthread_barrier_wait.c	2007-07-30 22:50:08.000000000 +0200
@@ -0,0 +1,78 @@
+/* Copyright (C) 2003, 2004, 2006, 2007 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Martin Schwidefsky <schwidefsky at de.ibm.com>, 2003.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#include <errno.h>
+#include <sysdep.h>
+#include <lowlevellock.h>
+#include <pthreadP.h>
+
+/* Wait on barrier.  */
+int
+pthread_barrier_wait (barrier)
+     pthread_barrier_t *barrier;
+{
+  union sparc_pthread_barrier *ibarrier
+    = (union sparc_pthread_barrier *) barrier;
+  int result = 0;
+  int private = ibarrier->s.pshared ? LLL_SHARED : LLL_PRIVATE;
+
+  /* Make sure we are alone.  */
+  lll_lock (ibarrier->b.lock, private);
+
+  /* One more arrival.  */
+  --ibarrier->b.left;
+
+  /* Are these all?  */
+  if (ibarrier->b.left == 0)
+    {
+      /* Yes. Increment the event counter to avoid invalid wake-ups and
+	 tell the current waiters that it is their turn.  */
+      ++ibarrier->b.curr_event;
+
+      /* Wake up everybody.  */
+      lll_futex_wake (&ibarrier->b.curr_event, INT_MAX, private);
+
+      /* This is the thread which finished the serialization.  */
+      result = PTHREAD_BARRIER_SERIAL_THREAD;
+    }
+  else
+    {
+      /* The number of the event we are waiting for.  The barrier's event
+	 number must be bumped before we continue.  */
+      unsigned int event = ibarrier->b.curr_event;
+
+      /* Before suspending, make the barrier available to others.  */
+      lll_unlock (ibarrier->b.lock, private);
+
+      /* Wait for the event counter of the barrier to change.  */
+      do
+	lll_futex_wait (&ibarrier->b.curr_event, event, private);
+      while (event == ibarrier->b.curr_event);
+    }
+
+  /* Make sure the init_count is stored locally or in a register.  */
+  unsigned int init_count = ibarrier->b.init_count;
+
+  /* If this was the last woken thread, unlock.  */
+  if (atomic_increment_val (&ibarrier->b.left) == init_count)
+    /* We are done.  */
+    lll_unlock (ibarrier->b.lock, private);
+
+  return result;
+}
--- libc/nptl/sysdeps/unix/sysv/linux/sparc/internaltypes.h.jj	2007-07-30 22:44:59.000000000 +0200
+++ libc/nptl/sysdeps/unix/sysv/linux/sparc/internaltypes.h	2007-07-30 22:45:46.000000000 +0200
@@ -0,0 +1,18 @@
+#ifndef _INTERNALTYPES_H
+#include "../internaltypes.h"
+
+union sparc_pthread_barrier
+{
+  struct pthread_barrier b;
+  struct sparc_pthread_barrier_s
+    {
+      unsigned int curr_event;
+      int lock;
+      unsigned int left;
+      unsigned int init_count;
+      unsigned char left_lock;
+      unsigned char pshared;
+    } s;
+};
+
+#endif
--- libc/nptl/sysdeps/unix/sysv/linux/pthread_mutex_cond_lock.c.jj	2006-02-15 18:01:17.000000000 +0100
+++ libc/nptl/sysdeps/unix/sysv/linux/pthread_mutex_cond_lock.c	2007-07-29 11:48:55.000000000 +0200
@@ -1,8 +1,8 @@
 #include <pthreadP.h>
 
-#define LLL_MUTEX_LOCK(mutex) lll_mutex_cond_lock (mutex)
-#define LLL_MUTEX_TRYLOCK(mutex) lll_mutex_cond_trylock (mutex)
-#define LLL_ROBUST_MUTEX_LOCK(mutex, id) lll_robust_mutex_cond_lock (mutex, id)
+#define LLL_MUTEX_LOCK(mutex) lll_cond_lock (mutex, /* XYZ */ LLL_SHARED)
+#define LLL_MUTEX_TRYLOCK(mutex) lll_cond_trylock (mutex)
+#define LLL_ROBUST_MUTEX_LOCK(mutex, id) lll_robust_cond_lock (mutex, id, /* XYZ */ LLL_SHARED)
 #define __pthread_mutex_lock __pthread_mutex_cond_lock
 #define NO_INCR
 
--- libc/nptl/sysdeps/unix/sysv/linux/sem_wait.c.jj	2007-06-08 09:13:52.000000000 +0200
+++ libc/nptl/sysdeps/unix/sysv/linux/sem_wait.c	2007-07-29 11:48:55.000000000 +0200
@@ -57,8 +57,7 @@ __new_sem_wait (sem_t *sem)
       int oldtype = __pthread_enable_asynccancel ();
 
       err = lll_futex_wait (&isem->value, 0,
-			    // XYZ check mutex flag
-			    LLL_SHARED);
+			    isem->private ^ FUTEX_PRIVATE_FLAG);
 
       /* Disable asynchronous cancellation.  */
       __pthread_disable_asynccancel (oldtype);
--- libc/nptl/tpp.c.jj	2006-08-15 01:02:29.000000000 +0200
+++ libc/nptl/tpp.c	2007-07-29 11:48:55.000000000 +0200
@@ -1,5 +1,5 @@
 /* Thread Priority Protect helpers.
-   Copyright (C) 2006 Free Software Foundation, Inc.
+   Copyright (C) 2006, 2007 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Jakub Jelinek <jakub at redhat.com>, 2006.
 
@@ -93,7 +93,7 @@ __pthread_tpp_change_priority (int previ
   if (priomax == newpriomax)
     return 0;
 
-  lll_lock (self->lock);
+  lll_lock (self->lock, LLL_PRIVATE);
 
   tpp->priomax = newpriomax;
 
@@ -129,7 +129,7 @@ __pthread_tpp_change_priority (int previ
 	}
     }
 
-  lll_unlock (self->lock);
+  lll_unlock (self->lock, LLL_PRIVATE);
 
   return result;
 }
@@ -144,7 +144,7 @@ __pthread_current_priority (void)
 
   int result = 0;
 
-  lll_lock (self->lock);
+  lll_lock (self->lock, LLL_PRIVATE);
 
   if ((self->flags & ATTR_FLAG_SCHED_SET) == 0)
     {
@@ -166,7 +166,7 @@ __pthread_current_priority (void)
   if (result != -1)
     result = self->schedparam.sched_priority;
 
-  lll_unlock (self->lock);
+  lll_unlock (self->lock, LLL_PRIVATE);
 
   return result;
 }

glibc-warning-patrol.patch:

--- NEW FILE glibc-warning-patrol.patch ---
2007-07-30  Jakub Jelinek  <jakub at redhat.com>

	* stdlib/tst-strtod2.c (do_test): Use %tu in fmt string for ptrdiff_t
	value.

	* stdio-common/tst-fmemopen2.c (do_test): Avoid fmt string warning
	if off_t is different rank from size_t.

	* sysdeps/generic/unwind-dw2.c (extract_cie_info, execute_cfa_program,
	uw_frame_state_for): Avoid type punning warnings.
	* sysdeps/generic/unwind-dw2-fde-glibc.c
	(_Unwind_IteratePhdrCallback): Likewise.
	* sysdeps/generic/unwind-dw2-fde.c (_Unwind_Find_FDE): Likewise.
	(binary_search_single_encoding_fdes, binary_search_mixed_encoding_fdes,
	get_cie_encoding, linear_search_fdes): Don't mix char and unsigned char
	pointers.
nptl/
	* tst-rwlock14.c (do_test): Avoid warnings on 32-bit arches.
localedata/
	* tst-strptime.c (do_test): Use %tu in fmt string for ptrdiff_t value.

--- libc/stdlib/tst-strtod2.c.jj	2007-07-30 19:13:57.000000000 +0200
+++ libc/stdlib/tst-strtod2.c	2007-07-30 19:13:57.000000000 +0200
@@ -32,7 +32,7 @@ do_test (void)
 	}
       if (ep != tests[i].str + tests[i].offset)
 	{
-	  printf ("test %zu strtod parsed %ju characters, expected %zu\n",
+	  printf ("test %zu strtod parsed %tu characters, expected %zu\n",
 		  i, ep - tests[i].str, tests[i].offset);
 	  status = 1;
 	}
--- libc/localedata/tst-strptime.c.jj	2007-07-11 00:12:28.000000000 +0200
+++ libc/localedata/tst-strptime.c	2007-07-30 19:13:23.000000000 +0200
@@ -15,7 +15,7 @@ do_test (void)
   static const char s[] = "\
 \x54\x68\xb8\x6e\x67\x20\x6d\xad\xea\x69\x20\x6d\xe9\x74";
   char *r = strptime (s, "%b", &tm);
-  printf ("r = %p, r-s = %ju, tm.tm_mon = %d\n", r, r - s, tm.tm_mon);
+  printf ("r = %p, r-s = %tu, tm.tm_mon = %d\n", r, r - s, tm.tm_mon);
   return r == NULL || r - s != 14 || tm.tm_mon != 10;
 }
 
--- libc/nptl/tst-rwlock14.c.jj	2007-07-30 19:23:34.000000000 +0200
+++ libc/nptl/tst-rwlock14.c	2007-07-30 19:30:46.000000000 +0200
@@ -1,4 +1,4 @@
-/* Copyright (C) 2004 Free Software Foundation, Inc.
+/* Copyright (C) 2004, 2007 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Ulrich Drepper <drepper at redhat.com>, 2004.
 
@@ -130,8 +130,8 @@ do_test (void)
       result = 1;
     }
 
-  ts.tv_nsec = 0x100001000LL;
-  if (ts.tv_nsec != 0x100001000LL)
+  ts.tv_nsec = (__typeof (ts.tv_nsec)) 0x100001000LL;
+  if ((__typeof (ts.tv_nsec)) 0x100001000LL != 0x100001000LL)
     ts.tv_nsec = 2000000000;
 
   e = pthread_rwlock_timedrdlock (&r, &ts);
--- libc/stdio-common/tst-fmemopen2.c.jj	2007-07-30 19:16:50.000000000 +0200
+++ libc/stdio-common/tst-fmemopen2.c	2007-07-30 19:16:50.000000000 +0200
@@ -28,7 +28,7 @@ do_test (void)
   o = ftello (fp);
   if (o != 0)
     {
-      printf ("second ftello returned %ld, expected %zu\n", o, (off_t) 0);
+      printf ("second ftello returned %ld, expected 0\n", o);
       result = 1;
     }
   if (fseeko (fp, 0, SEEK_END) != 0)
--- libc/sysdeps/generic/unwind-dw2.c.jj	2006-05-02 02:45:11.000000000 +0200
+++ libc/sysdeps/generic/unwind-dw2.c	2007-07-30 19:45:31.000000000 +0200
@@ -1,5 +1,5 @@
 /* DWARF2 exception handling and frame unwind runtime interface routines.
-   Copyright (C) 1997,1998,1999,2000,2001,2002,2003,2005,2006
+   Copyright (C) 1997,1998,1999,2000,2001,2002,2003,2005,2006,2007
    	Free Software Foundation, Inc.
 
    This file is part of the GNU C Library.
@@ -309,8 +309,9 @@ extract_cie_info (struct dwarf_cie *cie,
       /* "P" indicates a personality routine in the CIE augmentation.  */
       else if (aug[0] == 'P')
 	{
-	  p = read_encoded_value (context, *p, p + 1,
-				  (_Unwind_Ptr *) &fs->personality);
+	  _Unwind_Ptr personality;
+	  p = read_encoded_value (context, *p, p + 1, &personality);
+	  fs->personality = (_Unwind_Personality_Fn) personality;
 	  aug += 1;
 	}
 
@@ -771,8 +772,12 @@ execute_cfa_program (const unsigned char
       else switch (insn)
 	{
 	case DW_CFA_set_loc:
-	  insn_ptr = read_encoded_value (context, fs->fde_encoding,
-					 insn_ptr, (_Unwind_Ptr *) &fs->pc);
+	  {
+	    _Unwind_Ptr pc;
+	    insn_ptr = read_encoded_value (context, fs->fde_encoding,
+					   insn_ptr, &pc);
+	    fs->pc = (void *) pc;
+	  }
 	  break;
 
 	case DW_CFA_advance_loc1:
@@ -992,8 +997,11 @@ uw_frame_state_for (struct _Unwind_Conte
       insn = aug + i;
     }
   if (fs->lsda_encoding != DW_EH_PE_omit)
-    aug = read_encoded_value (context, fs->lsda_encoding, aug,
-			      (_Unwind_Ptr *) &context->lsda);
+    {
+      _Unwind_Ptr lsda;
+      aug = read_encoded_value (context, fs->lsda_encoding, aug, &lsda);
+      context->lsda = (void *) lsda;
+    }
 
   /* Then the insns in the FDE up to our target PC.  */
   if (insn == NULL)
--- libc/sysdeps/generic/unwind-dw2-fde-glibc.c.jj	2004-05-25 20:48:24.000000000 +0200
+++ libc/sysdeps/generic/unwind-dw2-fde-glibc.c	2007-07-30 19:46:17.000000000 +0200
@@ -1,4 +1,4 @@
-/* Copyright (C) 2001, 2002 Free Software Foundation, Inc.
+/* Copyright (C) 2001, 2002, 2007 Free Software Foundation, Inc.
    Contributed by Jakub Jelinek <jakub at redhat.com>.
 
    This file is part of the GNU C Library.
@@ -235,10 +235,11 @@ _Unwind_IteratePhdrCallback (struct dl_p
   if (data->ret != NULL)
     {
       unsigned int encoding = get_fde_encoding (data->ret);
+      _Unwind_Ptr func;
       read_encoded_value_with_base (encoding,
 				    base_from_cb_data (encoding, data),
-				    data->ret->pc_begin,
-				    (_Unwind_Ptr *)&data->func);
+				    data->ret->pc_begin, &func);
+      data->func = (void *) func;
     }
   return 1;
 }
--- libc/sysdeps/generic/unwind-dw2-fde.c.jj	2006-04-07 22:50:31.000000000 +0200
+++ libc/sysdeps/generic/unwind-dw2-fde.c	2007-07-30 19:45:55.000000000 +0200
@@ -1,5 +1,5 @@
 /* Subroutines needed for unwinding stack frames for exception handling.  */
-/* Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2006
+/* Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2006, 2007
    Free Software Foundation, Inc.
    Contributed by Jason Merrill <jason at cygnus.com>.
 
@@ -301,7 +301,8 @@ get_cie_encoding (struct dwarf_cie *cie)
   if (aug[0] != 'z')
     return DW_EH_PE_absptr;
 
-  p = aug + strlen (aug) + 1;		/* Skip the augmentation string.  */
+  /* Skip the augmentation string.  */
+  p = aug + strlen ((const char *) aug) + 1;
   p = read_uleb128 (p, &utmp);		/* Skip code alignment.  */
   p = read_sleb128 (p, &stmp);		/* Skip data alignment.  */
   p++;					/* Skip return address column.  */
@@ -838,7 +839,7 @@ linear_search_fdes (struct object *ob, f
       else
 	{
 	  _Unwind_Ptr mask;
-	  const char *p;
+	  const unsigned char *p;
 
 	  p = read_encoded_value_with_base (encoding, base,
 					    this_fde->pc_begin, &pc_begin);
@@ -908,7 +909,7 @@ binary_search_single_encoding_fdes (stru
       size_t i = (lo + hi) / 2;
       fde *f = vec->array[i];
       _Unwind_Ptr pc_begin, pc_range;
-      const char *p;
+      const unsigned char *p;
 
       p = read_encoded_value_with_base (encoding, base, f->pc_begin,
 					&pc_begin);
@@ -936,7 +937,7 @@ binary_search_mixed_encoding_fdes (struc
       size_t i = (lo + hi) / 2;
       fde *f = vec->array[i];
       _Unwind_Ptr pc_begin, pc_range;
-      const char *p;
+      const unsigned char *p;
       int encoding;
 
       encoding = get_fde_encoding (f);
@@ -1046,6 +1047,7 @@ _Unwind_Find_FDE (void *pc, struct dwarf
   if (f)
     {
       int encoding;
+      _Unwind_Ptr func;
 
       bases->tbase = ob->tbase;
       bases->dbase = ob->dbase;
@@ -1054,7 +1056,8 @@ _Unwind_Find_FDE (void *pc, struct dwarf
       if (ob->s.b.mixed_encoding)
 	encoding = get_fde_encoding (f);
       read_encoded_value_with_base (encoding, base_from_object (encoding, ob),
-				    f->pc_begin, (_Unwind_Ptr *)&bases->func);
+				    f->pc_begin, &func);
+      bases->func = (void *) func;
     }
 
   return f;



Index: glibc.spec
===================================================================
RCS file: /cvs/pkgs/rpms/glibc/devel/glibc.spec,v
retrieving revision 1.309
retrieving revision 1.310
diff -u -r1.309 -r1.310
--- glibc.spec	31 Jul 2007 18:18:37 -0000	1.309
+++ glibc.spec	31 Jul 2007 18:24:22 -0000	1.310
@@ -36,6 +36,10 @@
 Source3: %{glibcname}-fedora-%{glibcdate}.tar.bz2
 Patch0: %{glibcname}-fedora.patch
 Patch1: %{name}-ia64-lib64.patch
+Patch2: glibc-warning-patrol.patch
+Patch3: glibc-i386-rwlock.patch
+Patch4: glibc-ldconfig-speedup.patch
+Patch5: glibc-private-futex.patch
 Buildroot: %{_tmppath}/glibc-%{PACKAGE_VERSION}-root
 Obsoletes: zoneinfo, libc-static, libc-devel, libc-profile, libc-headers,
 Obsoletes: gencat, locale, ldconfig, locale-ja, glibc-profile
@@ -247,6 +251,10 @@
 %patch1 -p1
 %endif
 %endif
+%patch2 -p1
+%patch3 -p1
+%patch4 -p1
+%patch5 -p1
 
 # Hack till glibc-kernheaders get updated, argh
 mkdir -p override_headers/linux