elf/dl-lookup.c

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