Handle DSOs without any dependency in ld.so

diff --git a/ChangeLog b/ChangeLog
index f5309dfb363bf7e9fd9dacd3093d19f3cfbb115b..31719ab503e78cabf4ccdc0e874c449618e1c6a6 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,11 @@
 2011-05-30  Ulrich Drepper  <drepper@gmail.com>
 
+       [BZ #12454]
+       * elf/dl-deps.c (_dl_map_object_deps): Run initializer sorting only
+       when there are multiple maps.
+       * elf/dl-fini.c (_dl_sort_fini): Check for list of one.
+       (_dl_fini): Remove test here.
+
        * elf/rtld.c (dl_main): Don't allow the loader to load itself.
 
 2011-05-29  Ulrich Drepper  <drepper@gmail.com>

diff --git a/NEWS b/NEWS
index 05f603f541f96e29972e07dee7e361e7c69436cf..b3d8005c7c4766db461a1bec0ae9bf16ed23935d 100644 (file)
--- a/NEWS
+++ b/NEWS
@@ -1,4 +1,4 @@
-GNU C Library NEWS -- history of user-visible changes.  2011-5-29
+GNU C Library NEWS -- history of user-visible changes.  2011-5-30
 Copyright (C) 1992-2009, 2010, 2011 Free Software Foundation, Inc.
 See the end for copying conditions.
 
@@ -23,7 +23,7 @@ Version 2.14
 * The RPC implementation in libc is obsoleted.  Old programs keep working
   but new programs cannot be linked with the routines in libc anymore.
   Programs in need of RPC functionality must be linked against TI-RPC.
-  The TI-RPC implemtation is IPv6 enabled and there are other benefits.
+  The TI-RPC implementation is IPv6 enabled and there are other benefits.
 
   Visible changes of this change include (obviously) the inability to link
   programs using RPC functions without referencing the TI-RPC library and the

diff --git a/elf/dl-deps.c b/elf/dl-deps.c
index d3c27f14cc2b808cec43f6eb8d1f01ca61b16a73..0b03b903fea8df99afa1e53dc2fe115eb2a76209 100644 (file)
--- a/elf/dl-deps.c
+++ b/elf/dl-deps.c
@@ -617,61 +617,64 @@ Filters not supported with LD_TRACE_PRELINKING"));
        map->l_searchlist.r_list[i]->l_reserved = 0;
     }
 
-  /* Now determine the order in which the initialization has to happen.  */
+  /* Sort the initializer list to take dependencies into account.  The binary
+     itself will always be initialize last.  */
   memcpy (l_initfini, map->l_searchlist.r_list,
          nlist * sizeof (struct link_map *));
-
-  /* We can skip looking for the binary itself which is at the front
-     of the search list.  */
-  assert (nlist > 1);
-  i = 1;
-  bool seen[nlist];
-  memset (seen, false, nlist * sizeof (seen[0]));
-  while (1)
+  if (__builtin_expect (nlist > 1, 1))
     {
-      /* Keep track of which object we looked at this round.  */
-      seen[i] = true;
-      struct link_map *thisp = l_initfini[i];
-
-      /* Find the last object in the list for which the current one is
-        a dependency and move the current object behind the object
-        with the dependency.  */
-      unsigned int k = nlist - 1;
-      while (k > i)
+      /* We can skip looking for the binary itself which is at the front
+        of the search list.  */
+      i = 1;
+      bool seen[nlist];
+      memset (seen, false, nlist * sizeof (seen[0]));
+      while (1)
        {
-         struct link_map **runp = l_initfini[k]->l_initfini;
-         if (runp != NULL)
-           /* Look through the dependencies of the object.  */
-           while (*runp != NULL)
-             if (__builtin_expect (*runp++ == thisp, 0))
-               {
-                 /* Move the current object to the back past the last
-                    object with it as the dependency.  */
-                 memmove (&l_initfini[i], &l_initfini[i + 1],
-                          (k - i) * sizeof (l_initfini[0]));
-                 l_initfini[k] = thisp;
-
-                 if (seen[i + 1])
+         /* Keep track of which object we looked at this round.  */
+         seen[i] = true;
+         struct link_map *thisp = l_initfini[i];
+
+         /* Find the last object in the list for which the current one is
+            a dependency and move the current object behind the object
+            with the dependency.  */
+         unsigned int k = nlist - 1;
+         while (k > i)
+           {
+             struct link_map **runp = l_initfini[k]->l_initfini;
+             if (runp != NULL)
+               /* Look through the dependencies of the object.  */
+               while (*runp != NULL)
+                 if (__builtin_expect (*runp++ == thisp, 0))
                    {
-                     ++i;
-                     goto next_clear;
+                     /* Move the current object to the back past the last
+                        object with it as the dependency.  */
+                     memmove (&l_initfini[i], &l_initfini[i + 1],
+                              (k - i) * sizeof (l_initfini[0]));
+                     l_initfini[k] = thisp;
+
+                     if (seen[i + 1])
+                       {
+                         ++i;
+                         goto next_clear;
+                       }
+
+                     memmove (&seen[i], &seen[i + 1],
+                              (k - i) * sizeof (seen[0]));
+                     seen[k] = true;
+
+                     goto next;
                    }
 
-                 memmove (&seen[i], &seen[i + 1], (k - i) * sizeof (seen[0]));
-                 seen[k] = true;
+             --k;
+           }
 
-                 goto next;
-               }
+         if (++i == nlist)
+           break;
+       next_clear:
+         memset (&seen[i], false, (nlist - i) * sizeof (seen[0]));
 
-         --k;
+       next:;
        }
-
-      if (++i == nlist)
-       break;
-    next_clear:
-      memset (&seen[i], false, (nlist - i) * sizeof (seen[0]));
-
-    next:;
     }
 
   /* Terminate the list of dependencies.  */

diff --git a/elf/dl-fini.c b/elf/dl-fini.c
index ba6c62a55d8fa1fbf3bd0415d6184190ec5148e3..269bcece4c39c229c6770d76e935e53ad09a5ef4 100644 (file)
--- a/elf/dl-fini.c
+++ b/elf/dl-fini.c
@@ -33,9 +33,12 @@ internal_function
 _dl_sort_fini (struct link_map *l, struct link_map **maps, size_t nmaps,
               char *used, Lmid_t ns)
 {
+  /* A list of one element need not be sorted.  */
+  if (nmaps == 1)
+    return;
+
   /* We can skip looking for the binary itself which is at the front
      of the search list for the main namespace.  */
-  assert (nmaps > 1);
   unsigned int i = ns == LM_ID_BASE;
   bool seen[nmaps];
   memset (seen, false, nmaps * sizeof (seen[0]));
@@ -195,9 +198,8 @@ _dl_fini (void)
       assert (ns == LM_ID_BASE || i == nloaded || i == nloaded - 1);
       nmaps = i;
 
-      if (nmaps > 1)
-       /* Now we have to do the sorting.  */
-       _dl_sort_fini (GL(dl_ns)[ns]._ns_loaded, maps, nmaps, NULL, ns);
+      /* Now we have to do the sorting.  */
+      _dl_sort_fini (GL(dl_ns)[ns]._ns_loaded, maps, nmaps, NULL, ns);
 
       /* We do not rely on the linked list of loaded object anymore from
         this point on.  We have our own list here (maps).  The various

diff --git a/elf/rtld.c b/elf/rtld.c
index 48c557485c18e04f3b90c7a2824e28aae857eaf8..9eb9289eadf7750d344d59b9edb18ee694ddcd4a 100644 (file)
--- a/elf/rtld.c
+++ b/elf/rtld.c
@@ -922,7 +922,6 @@ dl_main (const ElfW(Phdr) *phdr,
 
   /* Process the environment variable which control the behaviour.  */
   process_envvars (&mode);
-  mode=trace;
 
 #ifndef HAVE_INLINED_SYSCALLS
   /* Set up a flag which tells we are just starting.  */