elf/dl-lookup.c

   1 /* Look up a symbol in the loaded objects.
   2    Copyright (C) 1995-2005, 2006 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 Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the 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    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 #include <alloca.h>
  21 #include <libintl.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25 #include <ldsodefs.h>
  26 #include <dl-hash.h>
  27 #include <dl-machine.h>
  28 #include <bits/libc-lock.h>
  29 #include <tls.h>
  30
  31 #include <assert.h>
  32
  33 #define VERSTAG(tag)    (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (tag))
  34
  35 /* We need this string more than once.  */
  36 static const char undefined_msg[] = "undefined symbol: ";
  37
  38
  39 struct sym_val
  40   {
  41     const ElfW(Sym) *s;
  42     struct link_map *m;
  43   };
  44
  45
  46 #define make_string(string, rest...) \
  47   ({                                                                          \
  48     const char *all[] = { string, ## rest };                                  \
  49     size_t len, cnt;                                                          \
  50     char *result, *cp;                                                        \
  51                                                                               \
  52     len = 1;                                                                  \
  53     for (cnt = 0; cnt < sizeof (all) / sizeof (all[0]); ++cnt)                \
  54       len += strlen (all[cnt]);                                               \
  55                                                                               \
  56     cp = result = alloca (len);                                               \
  57     for (cnt = 0; cnt < sizeof (all) / sizeof (all[0]); ++cnt)                \
  58       cp = __stpcpy (cp, all[cnt]);                                           \
  59                                                                               \
  60     result;                                                                   \
  61   })
  62
  63 /* Statistics function.  */
  64 #ifdef SHARED
  65 # define bump_num_relocations() ++GL(dl_num_relocations)
  66 #else
  67 # define bump_num_relocations() ((void) 0)
  68 #endif
  69
  70
  71 /* The actual lookup code.  */
  72 #include "do-lookup.h"
  73
  74
  75 static uint_fast32_t
  76 dl_new_hash (const char *s)
  77 {
  78   uint_fast32_t h = 5381;
  79   for (unsigned char c = *s; c != '\0'; c = *++s)
  80     h = h * 33 + c;
  81   return h & 0xffffffff;
  82 }
  83
  84
  85 /* Add extra dependency on MAP to UNDEF_MAP.  */
  86 static int
  87 internal_function
  88 add_dependency (struct link_map *undef_map, struct link_map *map)
  89 {
  90   struct link_map **list;
  91   struct link_map *runp;
  92   unsigned int act;
  93   unsigned int i;
  94   int result = 0;
  95
  96   /* Avoid self-references and references to objects which cannot be
  97      unloaded anyway.  */
  98   if (undef_map == map)
  99     return 0;
 100
 101   /* Make sure nobody can unload the object while we are at it.  */
 102   __rtld_lock_lock_recursive (GL(dl_load_lock));
 103
 104   /* Avoid references to objects which cannot be unloaded anyway.  */
 105   if (map->l_type != lt_loaded
 106       || (map->l_flags_1 & DF_1_NODELETE) != 0)
 107     goto out;
 108
 109   /* If the object with the undefined reference cannot be removed ever
 110      just make sure the same is true for the object which contains the
 111      definition.  */
 112   if (undef_map->l_type != lt_loaded
 113       || (undef_map->l_flags_1 & DF_1_NODELETE) != 0)
 114     {
 115       map->l_flags_1 |= DF_1_NODELETE;
 116       goto out;
 117     }
 118
 119   /* Determine whether UNDEF_MAP already has a reference to MAP.  First
 120      look in the normal dependencies.  */
 121   if (undef_map->l_initfini != NULL)
 122     {
 123       list = undef_map->l_initfini;
 124
 125       for (i = 0; list[i] != NULL; ++i)
 126         if (list[i] == map)
 127           goto out;
 128     }
 129
 130   /* No normal dependency.  See whether we already had to add it
 131      to the special list of dynamic dependencies.  */
 132   list = undef_map->l_reldeps;
 133   act = undef_map->l_reldepsact;
 134
 135   for (i = 0; i < act; ++i)
 136     if (list[i] == map)
 137       goto out;
 138
 139   /* The object is not yet in the dependency list.  Before we add
 140      it make sure just one more time the object we are about to
 141      reference is still available.  There is a brief period in
 142      which the object could have been removed since we found the
 143      definition.  */
 144   runp = GL(dl_ns)[undef_map->l_ns]._ns_loaded;
 145   while (runp != NULL && runp != map)
 146     runp = runp->l_next;
 147
 148   if (runp != NULL)
 149     {
 150       /* The object is still available.  Add the reference now.  */
 151       if (__builtin_expect (act >= undef_map->l_reldepsmax, 0))
 152         {
 153           /* Allocate more memory for the dependency list.  Since this
 154              can never happen during the startup phase we can use
 155              `realloc'.  */
 156           void *newp;
 157
 158           undef_map->l_reldepsmax += 5;
 159           newp = realloc (undef_map->l_reldeps,
 160                           undef_map->l_reldepsmax
 161                           * sizeof (struct link_map *));
 162
 163           if (__builtin_expect (newp != NULL, 1))
 164             undef_map->l_reldeps = (struct link_map **) newp;
 165           else
 166             /* Correct the addition.  */
 167             undef_map->l_reldepsmax -= 5;
 168         }
 169
 170       /* If we didn't manage to allocate memory for the list this is
 171          no fatal mistake.  We simply increment the use counter of the
 172          referenced object and don't record the dependencies.  This
 173          means this increment can never be reverted and the object
 174          will never be unloaded.  This is semantically the correct
 175          behavior.  */
 176       if (__builtin_expect (act < undef_map->l_reldepsmax, 1))
 177         undef_map->l_reldeps[undef_map->l_reldepsact++] = map;
 178
 179       /* Display information if we are debugging.  */
 180       if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
 181         _dl_debug_printf ("\
 182 \nfile=%s [%lu];  needed by %s [%lu] (relocation dependency)\n\n",
 183                           map->l_name[0] ? map->l_name : rtld_progname,
 184                           map->l_ns,
 185                           undef_map->l_name[0]
 186                           ? undef_map->l_name : rtld_progname,
 187                           undef_map->l_ns);
 188     }
 189   else
 190     /* Whoa, that was bad luck.  We have to search again.  */
 191     result = -1;
 192
 193  out:
 194   /* Release the lock.  */
 195   __rtld_lock_unlock_recursive (GL(dl_load_lock));
 196
 197   return result;
 198 }
 199
 200 static void
 201 internal_function
 202 _dl_debug_bindings (const char *undef_name, struct link_map *undef_map,
 203                     const ElfW(Sym) **ref, struct sym_val *value,
 204                     const struct r_found_version *version, int type_class,
 205                     int protected);
 206
 207
 208 /* Search loaded objects' symbol tables for a definition of the symbol
 209    UNDEF_NAME, perhaps with a requested version for the symbol.
 210
 211    We must never have calls to the audit functions inside this function
 212    or in any function which gets called.  If this would happen the audit
 213    code might create a thread which can throw off all the scope locking.  */
 214 lookup_t
 215 internal_function
 216 _dl_lookup_symbol_x (const char *undef_name, struct link_map *undef_map,
 217                      const ElfW(Sym) **ref,
 218                      struct r_scope_elem *symbol_scope[],
 219                      const struct r_found_version *version,
 220                      int type_class, int flags, struct link_map *skip_map)
 221 {
 222   const uint_fast32_t new_hash = dl_new_hash (undef_name);
 223   unsigned long int old_hash = 0xffffffff;
 224   struct sym_val current_value = { NULL, NULL };
 225   struct r_scope_elem **scope = symbol_scope;
 226
 227   bump_num_relocations ();
 228
 229   /* No other flag than DL_LOOKUP_ADD_DEPENDENCY is allowed if we look
 230      up a versioned symbol.  */
 231   assert (version == NULL || flags == 0 || flags == DL_LOOKUP_ADD_DEPENDENCY);
 232
 233   size_t i = 0;
 234   if (__builtin_expect (skip_map != NULL, 0))
 235     {
 236       /* Search the relevant loaded objects for a definition.  */
 237       while ((*scope)->r_list[i] != skip_map)
 238         ++i;
 239
 240       assert (i < (*scope)->r_nlist);
 241     }
 242
 243   /* Search the relevant loaded objects for a definition.  */
 244   for (size_t start = i; *scope != NULL; start = 0, ++scope)
 245     {
 246       int res = do_lookup_x (undef_name, new_hash, &old_hash, *ref,
 247                              &current_value, *scope, start, version, flags,
 248                              skip_map, type_class);
 249       if (res > 0)
 250         break;
 251
 252       if (__builtin_expect (res, 0) < 0 && skip_map == NULL)
 253         {
 254           /* Oh, oh.  The file named in the relocation entry does not
 255              contain the needed symbol.  This code is never reached
 256              for unversioned lookups.  */
 257           assert (version != NULL);
 258           const char *reference_name = undef_map ? undef_map->l_name : NULL;
 259
 260           /* XXX We cannot translate the message.  */
 261           _dl_signal_cerror (0, (reference_name[0]
 262                                  ? reference_name
 263                                  : (rtld_progname ?: "<main program>")),
 264                              N_("relocation error"),
 265                              make_string ("symbol ", undef_name, ", version ",
 266                                           version->name,
 267                                           " not defined in file ",
 268                                           version->filename,
 269                                           " with link time reference",
 270                                           res == -2
 271                                           ? " (no version symbols)" : ""));
 272           *ref = NULL;
 273           return 0;
 274         }
 275     }
 276
 277   if (__builtin_expect (current_value.s == NULL, 0))
 278     {
 279       if ((*ref == NULL || ELFW(ST_BIND) ((*ref)->st_info) != STB_WEAK)
 280           && skip_map == NULL)
 281         {
 282           /* We could find no value for a strong reference.  */
 283           const char *reference_name = undef_map ? undef_map->l_name : "";
 284           const char *versionstr = version ? ", version " : "";
 285           const char *versionname = (version && version->name
 286                                      ? version->name : "");
 287
 288           /* XXX We cannot translate the message.  */
 289           _dl_signal_cerror (0, (reference_name[0]
 290                                  ? reference_name
 291                                  : (rtld_progname ?: "<main program>")),
 292                              N_("symbol lookup error"),
 293                              make_string (undefined_msg, undef_name,
 294                                           versionstr, versionname));
 295         }
 296       *ref = NULL;
 297       return 0;
 298     }
 299
 300   int protected = (*ref
 301                    && ELFW(ST_VISIBILITY) ((*ref)->st_other) == STV_PROTECTED);
 302   if (__builtin_expect (protected != 0, 0))
 303     {
 304       /* It is very tricky.  We need to figure out what value to
 305          return for the protected symbol.  */
 306       if (type_class == ELF_RTYPE_CLASS_PLT)
 307         {
 308           if (current_value.s != NULL && current_value.m != undef_map)
 309             {
 310               current_value.s = *ref;
 311               current_value.m = undef_map;
 312             }
 313         }
 314       else
 315         {
 316           struct sym_val protected_value = { NULL, NULL };
 317
 318           for (scope = symbol_scope; *scope != NULL; i = 0, ++scope)
 319             if (do_lookup_x (undef_name, new_hash, &old_hash, *ref,
 320                              &protected_value, *scope, i, version, flags,
 321                              skip_map, ELF_RTYPE_CLASS_PLT) != 0)
 322               break;
 323
 324           if (protected_value.s != NULL && protected_value.m != undef_map)
 325             {
 326               current_value.s = *ref;
 327               current_value.m = undef_map;
 328             }
 329         }
 330     }
 331
 332   /* We have to check whether this would bind UNDEF_MAP to an object
 333      in the global scope which was dynamically loaded.  In this case
 334      we have to prevent the latter from being unloaded unless the
 335      UNDEF_MAP object is also unloaded.  */
 336   if (__builtin_expect (current_value.m->l_type == lt_loaded, 0)
 337       /* Don't do this for explicit lookups as opposed to implicit
 338          runtime lookups.  */
 339       && (flags & DL_LOOKUP_ADD_DEPENDENCY) != 0
 340       /* Add UNDEF_MAP to the dependencies.  */
 341       && add_dependency (undef_map, current_value.m) < 0)
 342       /* Something went wrong.  Perhaps the object we tried to reference
 343          was just removed.  Try finding another definition.  */
 344       return _dl_lookup_symbol_x (undef_name, undef_map, ref,
 345                                   symbol_scope, version, type_class,
 346                                   flags, skip_map);
 347
 348   /* The object is used.  */
 349   current_value.m->l_used = 1;
 350
 351   if (__builtin_expect (GLRO(dl_debug_mask)
 352                         & (DL_DEBUG_BINDINGS|DL_DEBUG_PRELINK), 0))
 353     _dl_debug_bindings (undef_name, undef_map, ref,
 354                         &current_value, version, type_class, protected);
 355
 356   *ref = current_value.s;
 357   return LOOKUP_VALUE (current_value.m);
 358 }
 359
 360
 361 /* Cache the location of MAP's hash table.  */
 362
 363 void
 364 internal_function
 365 _dl_setup_hash (struct link_map *map)
 366 {
 367   Elf_Symndx *hash;
 368   Elf_Symndx nchain;
 369
 370   if (__builtin_expect (map->l_info[DT_ADDRTAGIDX (DT_GNU_HASH) + DT_NUM
 371                                     + DT_THISPROCNUM + DT_VERSIONTAGNUM
 372                                     + DT_EXTRANUM + DT_VALNUM] != NULL, 1))
 373     {
 374       Elf32_Word *hash32
 375         = (void *) D_PTR (map, l_info[DT_ADDRTAGIDX (DT_GNU_HASH) + DT_NUM
 376                                       + DT_THISPROCNUM + DT_VERSIONTAGNUM
 377                                       + DT_EXTRANUM + DT_VALNUM]);
 378       map->l_nbuckets = *hash32++;
 379       Elf32_Word symbias = *hash32++;
 380       Elf32_Word bitmask_nwords = *hash32++;
 381       /* Must be a power of two.  */
 382       assert ((bitmask_nwords & (bitmask_nwords - 1)) == 0);
 383       map->l_gnu_bitmask_idxbits = bitmask_nwords - 1;
 384       map->l_gnu_shift = *hash32++;
 385
 386       map->l_gnu_bitmask = (ElfW(Addr) *) hash32;
 387       hash32 += __ELF_NATIVE_CLASS / 32 * bitmask_nwords;
 388
 389       map->l_gnu_buckets = hash32;
 390       hash32 += map->l_nbuckets;
 391       map->l_gnu_chain_zero = hash32 - symbias;
 392       return;
 393     }
 394
 395   if (!map->l_info[DT_HASH])
 396     return;
 397   hash = (void *) D_PTR (map, l_info[DT_HASH]);
 398
 399   map->l_nbuckets = *hash++;
 400   nchain = *hash++;
 401   map->l_buckets = hash;
 402   hash += map->l_nbuckets;
 403   map->l_chain = hash;
 404 }
 405
 406
 407 static void
 408 internal_function
 409 _dl_debug_bindings (const char *undef_name, struct link_map *undef_map,
 410                     const ElfW(Sym) **ref, struct sym_val *value,
 411                     const struct r_found_version *version, int type_class,
 412                     int protected)
 413 {
 414   const char *reference_name = undef_map->l_name;
 415
 416   if (GLRO(dl_debug_mask) & DL_DEBUG_BINDINGS)
 417     {
 418       _dl_debug_printf ("binding file %s [%lu] to %s [%lu]: %s symbol `%s'",
 419                         (reference_name[0]
 420                          ? reference_name
 421                          : (rtld_progname ?: "<main program>")),
 422                         undef_map->l_ns,
 423                         value->m->l_name[0] ? value->m->l_name : rtld_progname,
 424                         value->m->l_ns,
 425                         protected ? "protected" : "normal", undef_name);
 426       if (version)
 427         _dl_debug_printf_c (" [%s]\n", version->name);
 428       else
 429         _dl_debug_printf_c ("\n");
 430     }
 431 #ifdef SHARED
 432   if (GLRO(dl_debug_mask) & DL_DEBUG_PRELINK)
 433     {
 434       int conflict = 0;
 435       struct sym_val val = { NULL, NULL };
 436
 437       if ((GLRO(dl_trace_prelink_map) == NULL
 438            || GLRO(dl_trace_prelink_map) == GL(dl_ns)[LM_ID_BASE]._ns_loaded)
 439           && undef_map != GL(dl_ns)[LM_ID_BASE]._ns_loaded)
 440         {
 441           const uint_fast32_t new_hash = dl_new_hash (undef_name);
 442           unsigned long int old_hash = 0xffffffff;
 443
 444           do_lookup_x (undef_name, new_hash, &old_hash, *ref, &val,
 445                        undef_map->l_local_scope[0], 0, version, 0, NULL,
 446                        type_class);
 447
 448           if (val.s != value->s || val.m != value->m)
 449             conflict = 1;
 450         }
 451
 452       if (value->s
 453           && (__builtin_expect (ELFW(ST_TYPE) (value->s->st_info)
 454                                 == STT_TLS, 0)))
 455         type_class = 4;
 456
 457       if (conflict
 458           || GLRO(dl_trace_prelink_map) == undef_map
 459           || GLRO(dl_trace_prelink_map) == NULL
 460           || type_class == 4)
 461         {
 462           _dl_printf ("%s 0x%0*Zx 0x%0*Zx -> 0x%0*Zx 0x%0*Zx ",
 463                       conflict ? "conflict" : "lookup",
 464                       (int) sizeof (ElfW(Addr)) * 2,
 465                       (size_t) undef_map->l_map_start,
 466                       (int) sizeof (ElfW(Addr)) * 2,
 467                       (size_t) (((ElfW(Addr)) *ref) - undef_map->l_map_start),
 468                       (int) sizeof (ElfW(Addr)) * 2,
 469                       (size_t) (value->s ? value->m->l_map_start : 0),
 470                       (int) sizeof (ElfW(Addr)) * 2,
 471                       (size_t) (value->s ? value->s->st_value : 0));
 472
 473           if (conflict)
 474             _dl_printf ("x 0x%0*Zx 0x%0*Zx ",
 475                         (int) sizeof (ElfW(Addr)) * 2,
 476                         (size_t) (val.s ? val.m->l_map_start : 0),
 477                         (int) sizeof (ElfW(Addr)) * 2,
 478                         (size_t) (val.s ? val.s->st_value : 0));
 479
 480           _dl_printf ("/%x %s\n", type_class, undef_name);
 481         }
 482     }
 483 #endif
 484 }