elf/dl-deps.c

   1 /* Load the dependencies of a mapped object.
   2    Copyright (C) 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Library General Public License as
   7    published by the Free Software Foundation; either version 2 of the
   8    License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Library General Public License for more details.
  14
  15    You should have received a copy of the GNU Library General Public
  16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
  17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18    Boston, MA 02111-1307, USA.  */
  19
  20 #include <assert.h>
  21 #include <dlfcn.h>
  22 #include <errno.h>
  23 #include <libintl.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <unistd.h>
  27 #include <sys/param.h>
  28 #include <ldsodefs.h>
  29
  30 #include <dl-dst.h>
  31
  32 /* Whether an shared object references one or more auxiliary objects
  33    is signaled by the AUXTAG entry in l_info.  */
  34 #define AUXTAG  (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGNUM \
  35                  + DT_EXTRATAGIDX (DT_AUXILIARY))
  36 /* Whether an shared object references one or more auxiliary objects
  37    is signaled by the AUXTAG entry in l_info.  */
  38 #define FILTERTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGNUM \
  39                    + DT_EXTRATAGIDX (DT_FILTER))
  40
  41 /* This is zero at program start to signal that the global scope map is
  42    allocated by rtld.  Later it keeps the size of the map.  It might be
  43    reset if in _dl_close if the last global object is removed.  */
  44 size_t _dl_global_scope_alloc;
  45
  46 extern size_t _dl_platformlen;
  47
  48 /* When loading auxiliary objects we must ignore errors.  It's ok if
  49    an object is missing.  */
  50 struct openaux_args
  51   {
  52     /* The arguments to openaux.  */
  53     struct link_map *map;
  54     int trace_mode;
  55     const char *strtab;
  56     const char *name;
  57
  58     /* The return value of openaux.  */
  59     struct link_map *aux;
  60   };
  61
  62 static void
  63 openaux (void *a)
  64 {
  65   struct openaux_args *args = (struct openaux_args *) a;
  66
  67   args->aux = _dl_map_object (args->map, args->name, 0,
  68                               (args->map->l_type == lt_executable
  69                                ? lt_library : args->map->l_type),
  70                               args->trace_mode);
  71 }
  72
  73
  74
  75 /* We use a very special kind of list to track the two kinds paths
  76    through the list of loaded shared objects.  We have to
  77
  78    - produce a flat list with unique members of all involved objects
  79
  80    - produce a flat list of all shared objects.
  81 */
  82 struct list
  83   {
  84     int done;                   /* Nonzero if this map was processed.  */
  85     struct link_map *map;       /* The data.  */
  86
  87     struct list *unique;        /* Elements for normal list.  */
  88     struct list *dup;           /* Elements in complete list.  */
  89   };
  90
  91
  92 /* Macro to expand DST.  It is an macro since we use `alloca'.  */
  93 #define expand_dst(l, str, fatal) \
  94   ({                                                                          \
  95     const char *__str = (str);                                                \
  96     const char *__result = __str;                                             \
  97     size_t __cnt = DL_DST_COUNT(__str, 0);                                    \
  98                                                                               \
  99     if (__cnt != 0)                                                           \
 100       {                                                                       \
 101         char *__newp;                                                         \
 102                                                                               \
 103         /* DST must not appear in SUID/SGID programs.  */                     \
 104         if (__libc_enable_secure)                                             \
 105           _dl_signal_error (0, __str,                                         \
 106                             N_("DST not allowed in SUID/SGID programs"));     \
 107                                                                               \
 108         __newp = (char *) alloca (DL_DST_REQUIRED (l, __str, strlen (__str),  \
 109                                                    __cnt));                   \
 110                                                                               \
 111         __result = DL_DST_SUBSTITUTE (l, __str, __newp, 0);                   \
 112                                                                               \
 113         if (*__result == '\0')                                                \
 114           {                                                                   \
 115             /* The replacement for the DST is not known.  We can't            \
 116                processed.  */                                                 \
 117             if (fatal)                                                        \
 118               _dl_signal_error (0, __str, N_("\
 119 empty dynamics string token substitution"));                                  \
 120             else                                                              \
 121               {                                                               \
 122                 /* This is for DT_AUXILIARY.  */                              \
 123                 if (__builtin_expect (_dl_debug_libs, 0))                     \
 124                   _dl_debug_message (1, "cannot load auxiliary `", __str,     \
 125                                      "' because of empty dynamic string"      \
 126                                      " token substitution\n", NULL);          \
 127                 continue;                                                     \
 128               }                                                               \
 129           }                                                                   \
 130       }                                                                       \
 131                                                                               \
 132     __result; })
 133
 134
 135 void
 136 internal_function
 137 _dl_map_object_deps (struct link_map *map,
 138                      struct link_map **preloads, unsigned int npreloads,
 139                      int trace_mode)
 140 {
 141   struct list known[1 + npreloads + 1];
 142   struct list *runp, *utail, *dtail;
 143   unsigned int nlist, nduplist, i;
 144
 145   inline void preload (struct link_map *map)
 146     {
 147       known[nlist].done = 0;
 148       known[nlist].map = map;
 149
 150       known[nlist].unique = &known[nlist + 1];
 151       known[nlist].dup = &known[nlist + 1];
 152
 153       ++nlist;
 154       /* We use `l_reserved' as a mark bit to detect objects we have
 155          already put in the search list and avoid adding duplicate
 156          elements later in the list.  */
 157       map->l_reserved = 1;
 158     }
 159
 160   /* No loaded object so far.  */
 161   nlist = 0;
 162
 163   /* First load MAP itself.  */
 164   preload (map);
 165
 166   /* Add the preloaded items after MAP but before any of its dependencies.  */
 167   for (i = 0; i < npreloads; ++i)
 168     preload (preloads[i]);
 169
 170   /* Terminate the lists.  */
 171   known[nlist - 1].unique = NULL;
 172   known[nlist - 1].dup = NULL;
 173
 174   /* Pointer to last unique object.  */
 175   utail = &known[nlist - 1];
 176   /* Pointer to last loaded object.  */
 177   dtail = &known[nlist - 1];
 178
 179   /* Until now we have the same number of libraries in the normal and
 180      the list with duplicates.  */
 181   nduplist = nlist;
 182
 183   /* Process each element of the search list, loading each of its
 184      auxiliary objects and immediate dependencies.  Auxiliary objects
 185      will be added in the list before the object itself and
 186      dependencies will be appended to the list as we step through it.
 187      This produces a flat, ordered list that represents a
 188      breadth-first search of the dependency tree.
 189
 190      The whole process is complicated by the fact that we better
 191      should use alloca for the temporary list elements.  But using
 192      alloca means we cannot use recursive function calls.  */
 193   for (runp = known; runp; )
 194     {
 195       struct link_map *l = runp->map;
 196       struct link_map **needed = NULL;
 197       unsigned int nneeded = 0;
 198
 199       /* Unless otherwise stated, this object is handled.  */
 200       runp->done = 1;
 201
 202       /* Allocate a temporary record to contain the references to the
 203          dependencies of this object.  */
 204       if (l->l_searchlist.r_list == NULL && l != map && l->l_ldnum > 0)
 205         needed = (struct link_map **) alloca (l->l_ldnum
 206                                               * sizeof (struct link_map *));
 207
 208       if (l->l_info[DT_NEEDED] || l->l_info[AUXTAG] || l->l_info[FILTERTAG])
 209         {
 210           const char *strtab = (const void *) D_PTR (l, l_info[DT_STRTAB]);
 211           struct openaux_args args;
 212           struct list *orig;
 213           const ElfW(Dyn) *d;
 214
 215           args.strtab = strtab;
 216           args.map = l;
 217           args.trace_mode = trace_mode;
 218           orig = runp;
 219
 220           for (d = l->l_ld; d->d_tag != DT_NULL; ++d)
 221             if (__builtin_expect (d->d_tag, DT_NEEDED) == DT_NEEDED)
 222               {
 223                 /* Map in the needed object.  */
 224                 struct link_map *dep;
 225                 /* Allocate new entry.  */
 226                 struct list *newp;
 227                 /* Object name.  */
 228                 const char *name;
 229
 230                 /* Recognize DSTs.  */
 231                 name = expand_dst (l, strtab + d->d_un.d_val, 0);
 232
 233                 dep = _dl_map_object (l, name, 0,
 234                                       l->l_type == lt_executable ? lt_library :
 235                                       l->l_type, trace_mode);
 236
 237                 /* Add it in any case to the duplicate list.  */
 238                 newp = alloca (sizeof (struct list));
 239                 newp->map = dep;
 240                 newp->dup = NULL;
 241                 dtail->dup = newp;
 242                 dtail = newp;
 243                 ++nduplist;
 244
 245                 if (dep->l_reserved)
 246                   /* This object is already in the search list we are
 247                      building.  Don't add a duplicate pointer.
 248                      Release the reference just added by
 249                      _dl_map_object.  */
 250                   --dep->l_opencount;
 251                 else
 252                   {
 253                     /* Append DEP to the unique list.  */
 254                     newp->done = 0;
 255                     newp->unique = NULL;
 256                     utail->unique = newp;
 257                     utail = newp;
 258                     ++nlist;
 259                     /* Set the mark bit that says it's already in the list.  */
 260                     dep->l_reserved = 1;
 261                   }
 262
 263                 /* Remember this dependency.  */
 264                 if (needed != NULL)
 265                   needed[nneeded++] = dep;
 266               }
 267             else if (d->d_tag == DT_AUXILIARY || d->d_tag == DT_FILTER)
 268               {
 269                 const char *objname;
 270                 const char *errstring;
 271                 struct list *newp;
 272                 /* Object name.  */
 273                 const char *name;
 274
 275                 /* Recognize DSTs.  */
 276                 name = expand_dst (l, strtab + d->d_un.d_val,
 277                                    d->d_tag == DT_AUXILIARY);
 278
 279                 if (d->d_tag == DT_AUXILIARY)
 280                   {
 281                     /* Store the tag in the argument structure.  */
 282                     args.name = name;
 283
 284                     /* Say that we are about to load an auxiliary library.  */
 285                     if (__builtin_expect (_dl_debug_libs, 0))
 286                       _dl_debug_message (1, "load auxiliary object=",
 287                                          name, " requested by file=",
 288                                          l->l_name[0]
 289                                          ? l->l_name : _dl_argv[0],
 290                                          "\n", NULL);
 291
 292                     /* We must be prepared that the addressed shared
 293                        object is not available.  */
 294                     if (_dl_catch_error (&objname, &errstring, openaux, &args))
 295                       {
 296                         /* We are not interested in the error message.  */
 297                         assert (errstring != NULL);
 298                         free ((char *) errstring);
 299
 300                         /* Simply ignore this error and continue the work.  */
 301                         continue;
 302                       }
 303                   }
 304                 else
 305                   {
 306                     /* Say that we are about to load an auxiliary library.  */
 307                     if (__builtin_expect (_dl_debug_libs, 0))
 308                       _dl_debug_message (1, "load filtered object=", name,
 309                                          " requested by file=",
 310                                          l->l_name[0]
 311                                          ? l->l_name : _dl_argv[0],
 312                                          "\n", NULL);
 313
 314                     /* For filter objects the dependency must be available.  */
 315                     args.aux = _dl_map_object (l, name, 0,
 316                                                (l->l_type == lt_executable
 317                                                 ? lt_library : l->l_type),
 318                                                trace_mode);
 319                   }
 320
 321                 /* The auxiliary object is actually available.
 322                    Incorporate the map in all the lists.  */
 323
 324                 /* Allocate new entry.  This always has to be done.  */
 325                 newp = alloca (sizeof (struct list));
 326
 327                 /* We want to insert the new map before the current one,
 328                    but we have no back links.  So we copy the contents of
 329                    the current entry over.  Note that ORIG and NEWP now
 330                    have switched their meanings.  */
 331                 orig->dup = memcpy (newp, orig, sizeof (*newp));
 332
 333                 /* Initialize new entry.  */
 334                 orig->done = 0;
 335                 orig->map = args.aux;
 336
 337                 /* Remember this dependency.  */
 338                 if (needed != NULL)
 339                   needed[nneeded++] = args.aux;
 340
 341                 /* We must handle two situations here: the map is new,
 342                    so we must add it in all three lists.  If the map
 343                    is already known, we have two further possibilities:
 344                    - if the object is before the current map in the
 345                    search list, we do nothing.  It is already found
 346                    early
 347                    - if the object is after the current one, we must
 348                    move it just before the current map to make sure
 349                    the symbols are found early enough
 350                 */
 351                 if (args.aux->l_reserved)
 352                   {
 353                     /* The object is already somewhere in the list.
 354                        Locate it first.  */
 355                     struct list *late;
 356
 357                     /* This object is already in the search list we
 358                        are building.  Don't add a duplicate pointer.
 359                        Release the reference just added by
 360                        _dl_map_object.  */
 361                     --args.aux->l_opencount;
 362
 363                     for (late = newp; late->unique; late = late->unique)
 364                       if (late->unique->map == args.aux)
 365                         break;
 366
 367                     if (late->unique)
 368                       {
 369                         /* The object is somewhere behind the current
 370                            position in the search path.  We have to
 371                            move it to this earlier position.  */
 372                         orig->unique = newp;
 373
 374                         /* Now remove the later entry from the unique list
 375                            and adjust the tail pointer.  */
 376                         if (utail == late->unique)
 377                           utail = late;
 378                         late->unique = late->unique->unique;
 379
 380                         /* We must move the object earlier in the chain.  */
 381                         if (args.aux->l_prev)
 382                           args.aux->l_prev->l_next = args.aux->l_next;
 383                         if (args.aux->l_next)
 384                           args.aux->l_next->l_prev = args.aux->l_prev;
 385
 386                         args.aux->l_prev = newp->map->l_prev;
 387                         newp->map->l_prev = args.aux;
 388                         if (args.aux->l_prev != NULL)
 389                           args.aux->l_prev->l_next = args.aux;
 390                         args.aux->l_next = newp->map;
 391                       }
 392                     else
 393                       {
 394                         /* The object must be somewhere earlier in the
 395                            list.  That's good, we only have to insert
 396                            an entry for the duplicate list.  */
 397                         orig->unique = NULL;    /* Never used.  */
 398
 399                         /* Now we have a problem.  The element
 400                            pointing to ORIG in the unique list must
 401                            point to NEWP now.  This is the only place
 402                            where we need this backreference and this
 403                            situation is really not that frequent.  So
 404                            we don't use a double-linked list but
 405                            instead search for the preceding element.  */
 406                         late = known;
 407                         while (late->unique != orig)
 408                           late = late->unique;
 409                         late->unique = newp;
 410                       }
 411                   }
 412                 else
 413                   {
 414                     /* This is easy.  We just add the symbol right here.  */
 415                     orig->unique = newp;
 416                     ++nlist;
 417                     /* Set the mark bit that says it's already in the list.  */
 418                     args.aux->l_reserved = 1;
 419
 420                     /* The only problem is that in the double linked
 421                        list of all objects we don't have this new
 422                        object at the correct place.  Correct this here.  */
 423                     if (args.aux->l_prev)
 424                       args.aux->l_prev->l_next = args.aux->l_next;
 425                     if (args.aux->l_next)
 426                       args.aux->l_next->l_prev = args.aux->l_prev;
 427
 428                     args.aux->l_prev = newp->map->l_prev;
 429                     newp->map->l_prev = args.aux;
 430                     if (args.aux->l_prev != NULL)
 431                       args.aux->l_prev->l_next = args.aux;
 432                     args.aux->l_next = newp->map;
 433                   }
 434
 435                 /* Move the tail pointers if necessary.  */
 436                 if (orig == utail)
 437                   utail = newp;
 438                 if (orig == dtail)
 439                   dtail = newp;
 440
 441                 /* Move on the insert point.  */
 442                 orig = newp;
 443
 444                 /* We always add an entry to the duplicate list.  */
 445                 ++nduplist;
 446               }
 447         }
 448
 449       /* Terminate the list of dependencies and store the array address.  */
 450       if (needed != NULL)
 451         {
 452           needed[nneeded++] = NULL;
 453
 454           l->l_initfini = malloc (nneeded * sizeof needed[0]);
 455           if (l->l_initfini == NULL)
 456             _dl_signal_error (ENOMEM, map->l_name,
 457                               N_("cannot allocate dependency list"));
 458           memcpy (l->l_initfini, needed, nneeded * sizeof needed[0]);
 459         }
 460
 461       /* If we have no auxiliary objects just go on to the next map.  */
 462       if (runp->done)
 463         do
 464           runp = runp->unique;
 465         while (runp != NULL && runp->done);
 466     }
 467
 468   /* Store the search list we built in the object.  It will be used for
 469      searches in the scope of this object.  */
 470   map->l_searchlist.r_list = malloc ((2 * nlist + 1
 471                                       + (nlist == nduplist ? 0 : nduplist))
 472                                      * sizeof (struct link_map *));
 473   if (map->l_searchlist.r_list == NULL)
 474     _dl_signal_error (ENOMEM, map->l_name,
 475                       N_("cannot allocate symbol search list"));
 476   map->l_searchlist.r_nlist = nlist;
 477
 478   for (nlist = 0, runp = known; runp; runp = runp->unique)
 479     {
 480       if (trace_mode && runp->map->l_opencount == 0)
 481         /* This can happen when we trace the loading.  */
 482         --map->l_searchlist.r_nlist;
 483       else
 484         map->l_searchlist.r_list[nlist++] = runp->map;
 485
 486       /* Now clear all the mark bits we set in the objects on the search list
 487          to avoid duplicates, so the next call starts fresh.  */
 488       runp->map->l_reserved = 0;
 489     }
 490
 491   map->l_searchlist.r_nduplist = nduplist;
 492   if (nlist == nduplist)
 493     map->l_searchlist.r_duplist = map->l_searchlist.r_list;
 494   else
 495     {
 496       unsigned int cnt;
 497
 498       map->l_searchlist.r_duplist = map->l_searchlist.r_list + nlist;
 499
 500       for (cnt = 0, runp = known; runp; runp = runp->dup)
 501         if (trace_mode && runp->map->l_opencount == 0)
 502           /* This can happen when we trace the loading.  */
 503           --map->l_searchlist.r_nduplist;
 504         else
 505           map->l_searchlist.r_duplist[cnt++] = runp->map;
 506     }
 507
 508   /* Now determine the order in which the initialization has to happen.  */
 509   map->l_initfini =
 510     (struct link_map **) memcpy (map->l_searchlist.r_duplist + nduplist,
 511                                  map->l_searchlist.r_list,
 512                                  nlist * sizeof (struct link_map *));
 513   /* We can skip looking for the binary itself which is at the front
 514      of the search list.  Look through the list backward so that circular
 515      dependencies are not changing the order.  */
 516   for (i = 1; i < nlist; ++i)
 517     {
 518       struct link_map *l = map->l_searchlist.r_list[i];
 519       unsigned int j;
 520       unsigned int k;
 521
 522       /* Find the place in the initfini list where the map is currently
 523          located.  */
 524       for (j = 1; map->l_initfini[j] != l; ++j)
 525         ;
 526
 527       /* Find all object for which the current one is a dependency and
 528          move the found object (if necessary) in front.  */
 529       for (k = j + 1; k < nlist; ++k)
 530         {
 531           struct link_map **runp;
 532
 533           runp = map->l_initfini[k]->l_initfini;
 534           if (runp != NULL)
 535             {
 536               while (*runp != NULL)
 537                 if (*runp == l)
 538                   {
 539                     struct link_map *here = map->l_initfini[k];
 540
 541                     /* Move it now.  */
 542                     memmove (&map->l_initfini[j] + 1,
 543                              &map->l_initfini[j],
 544                              (k - j) * sizeof (struct link_map *));
 545                     map->l_initfini[j] = here;
 546
 547                     break;
 548                   }
 549                 else
 550                   ++runp;
 551             }
 552         }
 553     }
 554   /* Terminate the list of dependencies.  */
 555   map->l_initfini[nlist] = NULL;
 556 }