1/* Look up a symbol in the loaded objects.
2 Copyright (C) 1995-2018 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, see
17 <http://www.gnu.org/licenses/>. */
18
19#include <alloca.h>
20#include <libintl.h>
21#include <stdlib.h>
22#include <string.h>
23#include <unistd.h>
24#include <ldsodefs.h>
25#include <dl-hash.h>
26#include <dl-machine.h>
27#include <sysdep-cancel.h>
28#include <libc-lock.h>
29#include <tls.h>
30#include <atomic.h>
31
32#include <assert.h>
33
34/* Return nonzero if check_match should consider SYM to fail to match a
35 symbol reference for some machine-specific reason. */
36#ifndef ELF_MACHINE_SYM_NO_MATCH
37# define ELF_MACHINE_SYM_NO_MATCH(sym) 0
38#endif
39
40#define VERSTAG(tag) (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (tag))
41
42
43struct sym_val
44 {
45 const ElfW(Sym) *s;
46 struct link_map *m;
47 };
48
49
50/* Statistics function. */
51#ifdef SHARED
52# define bump_num_relocations() ++GL(dl_num_relocations)
53#else
54# define bump_num_relocations() ((void) 0)
55#endif
56
57/* Utility function for do_lookup_x. The caller is called with undef_name,
58 ref, version, flags and type_class, and those are passed as the first
59 five arguments. The caller then computes sym, symidx, strtab, and map
60 and passes them as the next four arguments. Lastly the caller passes in
61 versioned_sym and num_versions which are modified by check_match during
62 the checking process. */
63static const ElfW(Sym) *
64check_match (const char *const undef_name,
65 const ElfW(Sym) *const ref,
66 const struct r_found_version *const version,
67 const int flags,
68 const int type_class,
69 const ElfW(Sym) *const sym,
70 const Elf_Symndx symidx,
71 const char *const strtab,
72 const struct link_map *const map,
73 const ElfW(Sym) **const versioned_sym,
74 int *const num_versions)
75{
76 unsigned int stt = ELFW(ST_TYPE) (sym->st_info);
77 assert (ELF_RTYPE_CLASS_PLT == 1);
78 if (__glibc_unlikely ((sym->st_value == 0 /* No value. */
79 && stt != STT_TLS)
80 || ELF_MACHINE_SYM_NO_MATCH (sym)
81 || (type_class & (sym->st_shndx == SHN_UNDEF))))
82 return NULL;
83
84 /* Ignore all but STT_NOTYPE, STT_OBJECT, STT_FUNC,
85 STT_COMMON, STT_TLS, and STT_GNU_IFUNC since these are no
86 code/data definitions. */
87#define ALLOWED_STT \
88 ((1 << STT_NOTYPE) | (1 << STT_OBJECT) | (1 << STT_FUNC) \
89 | (1 << STT_COMMON) | (1 << STT_TLS) | (1 << STT_GNU_IFUNC))
90 if (__glibc_unlikely (((1 << stt) & ALLOWED_STT) == 0))
91 return NULL;
92
93 if (sym != ref && strcmp (strtab + sym->st_name, undef_name))
94 /* Not the symbol we are looking for. */
95 return NULL;
96
97 const ElfW(Half) *verstab = map->l_versyms;
98 if (version != NULL)
99 {
100 if (__glibc_unlikely (verstab == NULL))
101 {
102 /* We need a versioned symbol but haven't found any. If
103 this is the object which is referenced in the verneed
104 entry it is a bug in the library since a symbol must
105 not simply disappear.
106
107 It would also be a bug in the object since it means that
108 the list of required versions is incomplete and so the
109 tests in dl-version.c haven't found a problem.*/
110 assert (version->filename == NULL
111 || ! _dl_name_match_p (version->filename, map));
112
113 /* Otherwise we accept the symbol. */
114 }
115 else
116 {
117 /* We can match the version information or use the
118 default one if it is not hidden. */
119 ElfW(Half) ndx = verstab[symidx] & 0x7fff;
120 if ((map->l_versions[ndx].hash != version->hash
121 || strcmp (map->l_versions[ndx].name, version->name))
122 && (version->hidden || map->l_versions[ndx].hash
123 || (verstab[symidx] & 0x8000)))
124 /* It's not the version we want. */
125 return NULL;
126 }
127 }
128 else
129 {
130 /* No specific version is selected. There are two ways we
131 can got here:
132
133 - a binary which does not include versioning information
134 is loaded
135
136 - dlsym() instead of dlvsym() is used to get a symbol which
137 might exist in more than one form
138
139 If the library does not provide symbol version information
140 there is no problem at all: we simply use the symbol if it
141 is defined.
142
143 These two lookups need to be handled differently if the
144 library defines versions. In the case of the old
145 unversioned application the oldest (default) version
146 should be used. In case of a dlsym() call the latest and
147 public interface should be returned. */
148 if (verstab != NULL)
149 {
150 if ((verstab[symidx] & 0x7fff)
151 >= ((flags & DL_LOOKUP_RETURN_NEWEST) ? 2 : 3))
152 {
153 /* Don't accept hidden symbols. */
154 if ((verstab[symidx] & 0x8000) == 0
155 && (*num_versions)++ == 0)
156 /* No version so far. */
157 *versioned_sym = sym;
158
159 return NULL;
160 }
161 }
162 }
163
164 /* There cannot be another entry for this symbol so stop here. */
165 return sym;
166}
167
168/* Utility function for do_lookup_unique. Add a symbol to TABLE. */
169static void
170enter_unique_sym (struct unique_sym *table, size_t size,
171 unsigned int hash, const char *name,
172 const ElfW(Sym) *sym, const struct link_map *map)
173{
174 size_t idx = hash % size;
175 size_t hash2 = 1 + hash % (size - 2);
176 while (table[idx].name != NULL)
177 {
178 idx += hash2;
179 if (idx >= size)
180 idx -= size;
181 }
182
183 table[idx].hashval = hash;
184 table[idx].name = name;
185 table[idx].sym = sym;
186 table[idx].map = map;
187}
188
189/* Utility function for do_lookup_x. Lookup an STB_GNU_UNIQUE symbol
190 in the unique symbol table, creating a new entry if necessary.
191 Return the matching symbol in RESULT. */
192static void
193do_lookup_unique (const char *undef_name, uint_fast32_t new_hash,
194 const struct link_map *map, struct sym_val *result,
195 int type_class, const ElfW(Sym) *sym, const char *strtab,
196 const ElfW(Sym) *ref, const struct link_map *undef_map)
197{
198 /* We have to determine whether we already found a symbol with this
199 name before. If not then we have to add it to the search table.
200 If we already found a definition we have to use it. */
201
202 struct unique_sym_table *tab
203 = &GL(dl_ns)[map->l_ns]._ns_unique_sym_table;
204
205 __rtld_lock_lock_recursive (tab->lock);
206
207 struct unique_sym *entries = tab->entries;
208 size_t size = tab->size;
209 if (entries != NULL)
210 {
211 size_t idx = new_hash % size;
212 size_t hash2 = 1 + new_hash % (size - 2);
213 while (1)
214 {
215 if (entries[idx].hashval == new_hash
216 && strcmp (entries[idx].name, undef_name) == 0)
217 {
218 if ((type_class & ELF_RTYPE_CLASS_COPY) != 0)
219 {
220 /* We possibly have to initialize the central
221 copy from the copy addressed through the
222 relocation. */
223 result->s = sym;
224 result->m = (struct link_map *) map;
225 }
226 else
227 {
228 result->s = entries[idx].sym;
229 result->m = (struct link_map *) entries[idx].map;
230 }
231 __rtld_lock_unlock_recursive (tab->lock);
232 return;
233 }
234
235 if (entries[idx].name == NULL)
236 break;
237
238 idx += hash2;
239 if (idx >= size)
240 idx -= size;
241 }
242
243 if (size * 3 <= tab->n_elements * 4)
244 {
245 /* Expand the table. */
246#ifdef RTLD_CHECK_FOREIGN_CALL
247 /* This must not happen during runtime relocations. */
248 assert (!RTLD_CHECK_FOREIGN_CALL);
249#endif
250 size_t newsize = _dl_higher_prime_number (size + 1);
251 struct unique_sym *newentries
252 = calloc (sizeof (struct unique_sym), newsize);
253 if (newentries == NULL)
254 {
255 nomem:
256 __rtld_lock_unlock_recursive (tab->lock);
257 _dl_fatal_printf ("out of memory\n");
258 }
259
260 for (idx = 0; idx < size; ++idx)
261 if (entries[idx].name != NULL)
262 enter_unique_sym (newentries, newsize, entries[idx].hashval,
263 entries[idx].name, entries[idx].sym,
264 entries[idx].map);
265
266 tab->free (entries);
267 tab->size = newsize;
268 size = newsize;
269 entries = tab->entries = newentries;
270 tab->free = free;
271 }
272 }
273 else
274 {
275#ifdef RTLD_CHECK_FOREIGN_CALL
276 /* This must not happen during runtime relocations. */
277 assert (!RTLD_CHECK_FOREIGN_CALL);
278#endif
279
280#ifdef SHARED
281 /* If tab->entries is NULL, but tab->size is not, it means
282 this is the second, conflict finding, lookup for
283 LD_TRACE_PRELINKING in _dl_debug_bindings. Don't
284 allocate anything and don't enter anything into the
285 hash table. */
286 if (__glibc_unlikely (tab->size))
287 {
288 assert (GLRO(dl_debug_mask) & DL_DEBUG_PRELINK);
289 goto success;
290 }
291#endif
292
293#define INITIAL_NUNIQUE_SYM_TABLE 31
294 size = INITIAL_NUNIQUE_SYM_TABLE;
295 entries = calloc (sizeof (struct unique_sym), size);
296 if (entries == NULL)
297 goto nomem;
298
299 tab->entries = entries;
300 tab->size = size;
301 tab->free = free;
302 }
303
304 if ((type_class & ELF_RTYPE_CLASS_COPY) != 0)
305 enter_unique_sym (entries, size, new_hash, strtab + sym->st_name, ref,
306 undef_map);
307 else
308 {
309 enter_unique_sym (entries, size,
310 new_hash, strtab + sym->st_name, sym, map);
311
312 if (map->l_type == lt_loaded)
313 /* Make sure we don't unload this object by
314 setting the appropriate flag. */
315 ((struct link_map *) map)->l_flags_1 |= DF_1_NODELETE;
316 }
317 ++tab->n_elements;
318
319#ifdef SHARED
320 success:
321#endif
322 __rtld_lock_unlock_recursive (tab->lock);
323
324 result->s = sym;
325 result->m = (struct link_map *) map;
326}
327
328/* Inner part of the lookup functions. We return a value > 0 if we
329 found the symbol, the value 0 if nothing is found and < 0 if
330 something bad happened. */
331static int
332__attribute_noinline__
333do_lookup_x (const char *undef_name, uint_fast32_t new_hash,
334 unsigned long int *old_hash, const ElfW(Sym) *ref,
335 struct sym_val *result, struct r_scope_elem *scope, size_t i,
336 const struct r_found_version *const version, int flags,
337 struct link_map *skip, int type_class, struct link_map *undef_map)
338{
339 size_t n = scope->r_nlist;
340 /* Make sure we read the value before proceeding. Otherwise we
341 might use r_list pointing to the initial scope and r_nlist being
342 the value after a resize. That is the only path in dl-open.c not
343 protected by GSCOPE. A read barrier here might be to expensive. */
344 __asm volatile ("" : "+r" (n), "+m" (scope->r_list));
345 struct link_map **list = scope->r_list;
346
347 do
348 {
349 const struct link_map *map = list[i]->l_real;
350
351 /* Here come the extra test needed for `_dl_lookup_symbol_skip'. */
352 if (map == skip)
353 continue;
354
355 /* Don't search the executable when resolving a copy reloc. */
356 if ((type_class & ELF_RTYPE_CLASS_COPY) && map->l_type == lt_executable)
357 continue;
358
359 /* Do not look into objects which are going to be removed. */
360 if (map->l_removed)
361 continue;
362
363 /* Print some debugging info if wanted. */
364 if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_SYMBOLS))
365 _dl_debug_printf ("symbol=%s; lookup in file=%s [%lu]\n",
366 undef_name, DSO_FILENAME (map->l_name),
367 map->l_ns);
368
369 /* If the hash table is empty there is nothing to do here. */
370 if (map->l_nbuckets == 0)
371 continue;
372
373 Elf_Symndx symidx;
374 int num_versions = 0;
375 const ElfW(Sym) *versioned_sym = NULL;
376
377 /* The tables for this map. */
378 const ElfW(Sym) *symtab = (const void *) D_PTR (map, l_info[DT_SYMTAB]);
379 const char *strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
380
381 const ElfW(Sym) *sym;
382 const ElfW(Addr) *bitmask = map->l_gnu_bitmask;
383 if (__glibc_likely (bitmask != NULL))
384 {
385 ElfW(Addr) bitmask_word
386 = bitmask[(new_hash / __ELF_NATIVE_CLASS)
387 & map->l_gnu_bitmask_idxbits];
388
389 unsigned int hashbit1 = new_hash & (__ELF_NATIVE_CLASS - 1);
390 unsigned int hashbit2 = ((new_hash >> map->l_gnu_shift)
391 & (__ELF_NATIVE_CLASS - 1));
392
393 if (__glibc_unlikely ((bitmask_word >> hashbit1)
394 & (bitmask_word >> hashbit2) & 1))
395 {
396 Elf32_Word bucket = map->l_gnu_buckets[new_hash
397 % map->l_nbuckets];
398 if (bucket != 0)
399 {
400 const Elf32_Word *hasharr = &map->l_gnu_chain_zero[bucket];
401
402 do
403 if (((*hasharr ^ new_hash) >> 1) == 0)
404 {
405 symidx = hasharr - map->l_gnu_chain_zero;
406 sym = check_match (undef_name, ref, version, flags,
407 type_class, &symtab[symidx], symidx,
408 strtab, map, &versioned_sym,
409 &num_versions);
410 if (sym != NULL)
411 goto found_it;
412 }
413 while ((*hasharr++ & 1u) == 0);
414 }
415 }
416 /* No symbol found. */
417 symidx = SHN_UNDEF;
418 }
419 else
420 {
421 if (*old_hash == 0xffffffff)
422 *old_hash = _dl_elf_hash (undef_name);
423
424 /* Use the old SysV-style hash table. Search the appropriate
425 hash bucket in this object's symbol table for a definition
426 for the same symbol name. */
427 for (symidx = map->l_buckets[*old_hash % map->l_nbuckets];
428 symidx != STN_UNDEF;
429 symidx = map->l_chain[symidx])
430 {
431 sym = check_match (undef_name, ref, version, flags,
432 type_class, &symtab[symidx], symidx,
433 strtab, map, &versioned_sym,
434 &num_versions);
435 if (sym != NULL)
436 goto found_it;
437 }
438 }
439
440 /* If we have seen exactly one versioned symbol while we are
441 looking for an unversioned symbol and the version is not the
442 default version we still accept this symbol since there are
443 no possible ambiguities. */
444 sym = num_versions == 1 ? versioned_sym : NULL;
445
446 if (sym != NULL)
447 {
448 found_it:
449 /* When UNDEF_MAP is NULL, which indicates we are called from
450 do_lookup_x on relocation against protected data, we skip
451 the data definion in the executable from copy reloc. */
452 if (ELF_RTYPE_CLASS_EXTERN_PROTECTED_DATA
453 && undef_map == NULL
454 && map->l_type == lt_executable
455 && type_class == ELF_RTYPE_CLASS_EXTERN_PROTECTED_DATA)
456 {
457 const ElfW(Sym) *s;
458 unsigned int i;
459
460#if ! ELF_MACHINE_NO_RELA
461 if (map->l_info[DT_RELA] != NULL
462 && map->l_info[DT_RELASZ] != NULL
463 && map->l_info[DT_RELASZ]->d_un.d_val != 0)
464 {
465 const ElfW(Rela) *rela
466 = (const ElfW(Rela) *) D_PTR (map, l_info[DT_RELA]);
467 unsigned int rela_count
468 = map->l_info[DT_RELASZ]->d_un.d_val / sizeof (*rela);
469
470 for (i = 0; i < rela_count; i++, rela++)
471 if (elf_machine_type_class (ELFW(R_TYPE) (rela->r_info))
472 == ELF_RTYPE_CLASS_COPY)
473 {
474 s = &symtab[ELFW(R_SYM) (rela->r_info)];
475 if (!strcmp (strtab + s->st_name, undef_name))
476 goto skip;
477 }
478 }
479#endif
480#if ! ELF_MACHINE_NO_REL
481 if (map->l_info[DT_REL] != NULL
482 && map->l_info[DT_RELSZ] != NULL
483 && map->l_info[DT_RELSZ]->d_un.d_val != 0)
484 {
485 const ElfW(Rel) *rel
486 = (const ElfW(Rel) *) D_PTR (map, l_info[DT_REL]);
487 unsigned int rel_count
488 = map->l_info[DT_RELSZ]->d_un.d_val / sizeof (*rel);
489
490 for (i = 0; i < rel_count; i++, rel++)
491 if (elf_machine_type_class (ELFW(R_TYPE) (rel->r_info))
492 == ELF_RTYPE_CLASS_COPY)
493 {
494 s = &symtab[ELFW(R_SYM) (rel->r_info)];
495 if (!strcmp (strtab + s->st_name, undef_name))
496 goto skip;
497 }
498 }
499#endif
500 }
501
502 /* Hidden and internal symbols are local, ignore them. */
503 if (__glibc_unlikely (dl_symbol_visibility_binds_local_p (sym)))
504 goto skip;
505
506 switch (ELFW(ST_BIND) (sym->st_info))
507 {
508 case STB_WEAK:
509 /* Weak definition. Use this value if we don't find another. */
510 if (__glibc_unlikely (GLRO(dl_dynamic_weak)))
511 {
512 if (! result->s)
513 {
514 result->s = sym;
515 result->m = (struct link_map *) map;
516 }
517 break;
518 }
519 /* FALLTHROUGH */
520 case STB_GLOBAL:
521 /* Global definition. Just what we need. */
522 result->s = sym;
523 result->m = (struct link_map *) map;
524 return 1;
525
526 case STB_GNU_UNIQUE:;
527 do_lookup_unique (undef_name, new_hash, map, result, type_class,
528 sym, strtab, ref, undef_map);
529 return 1;
530
531 default:
532 /* Local symbols are ignored. */
533 break;
534 }
535 }
536
537skip:
538 /* If this current map is the one mentioned in the verneed entry
539 and we have not found a weak entry, it is a bug. */
540 if (symidx == STN_UNDEF && version != NULL && version->filename != NULL
541 && __glibc_unlikely (_dl_name_match_p (version->filename, map)))
542 return -1;
543 }
544 while (++i < n);
545
546 /* We have not found anything until now. */
547 return 0;
548}
549
550
551static uint_fast32_t
552dl_new_hash (const char *s)
553{
554 uint_fast32_t h = 5381;
555 for (unsigned char c = *s; c != '\0'; c = *++s)
556 h = h * 33 + c;
557 return h & 0xffffffff;
558}
559
560
561/* Add extra dependency on MAP to UNDEF_MAP. */
562static int
563add_dependency (struct link_map *undef_map, struct link_map *map, int flags)
564{
565 struct link_map *runp;
566 unsigned int i;
567 int result = 0;
568
569 /* Avoid self-references and references to objects which cannot be
570 unloaded anyway. */
571 if (undef_map == map)
572 return 0;
573
574 /* Avoid references to objects which cannot be unloaded anyway. */
575 assert (map->l_type == lt_loaded);
576 if ((map->l_flags_1 & DF_1_NODELETE) != 0)
577 return 0;
578
579 struct link_map_reldeps *l_reldeps
580 = atomic_forced_read (undef_map->l_reldeps);
581
582 /* Make sure l_reldeps is read before l_initfini. */
583 atomic_read_barrier ();
584
585 /* Determine whether UNDEF_MAP already has a reference to MAP. First
586 look in the normal dependencies. */
587 struct link_map **l_initfini = atomic_forced_read (undef_map->l_initfini);
588 if (l_initfini != NULL)
589 {
590 for (i = 0; l_initfini[i] != NULL; ++i)
591 if (l_initfini[i] == map)
592 return 0;
593 }
594
595 /* No normal dependency. See whether we already had to add it
596 to the special list of dynamic dependencies. */
597 unsigned int l_reldepsact = 0;
598 if (l_reldeps != NULL)
599 {
600 struct link_map **list = &l_reldeps->list[0];
601 l_reldepsact = l_reldeps->act;
602 for (i = 0; i < l_reldepsact; ++i)
603 if (list[i] == map)
604 return 0;
605 }
606
607 /* Save serial number of the target MAP. */
608 unsigned long long serial = map->l_serial;
609
610 /* Make sure nobody can unload the object while we are at it. */
611 if (__glibc_unlikely (flags & DL_LOOKUP_GSCOPE_LOCK))
612 {
613 /* We can't just call __rtld_lock_lock_recursive (GL(dl_load_lock))
614 here, that can result in ABBA deadlock. */
615 THREAD_GSCOPE_RESET_FLAG ();
616 __rtld_lock_lock_recursive (GL(dl_load_lock));
617 /* While MAP value won't change, after THREAD_GSCOPE_RESET_FLAG ()
618 it can e.g. point to unallocated memory. So avoid the optimizer
619 treating the above read from MAP->l_serial as ensurance it
620 can safely dereference it. */
621 map = atomic_forced_read (map);
622
623 /* From this point on it is unsafe to dereference MAP, until it
624 has been found in one of the lists. */
625
626 /* Redo the l_initfini check in case undef_map's l_initfini
627 changed in the mean time. */
628 if (undef_map->l_initfini != l_initfini
629 && undef_map->l_initfini != NULL)
630 {
631 l_initfini = undef_map->l_initfini;
632 for (i = 0; l_initfini[i] != NULL; ++i)
633 if (l_initfini[i] == map)
634 goto out_check;
635 }
636
637 /* Redo the l_reldeps check if undef_map's l_reldeps changed in
638 the mean time. */
639 if (undef_map->l_reldeps != NULL)
640 {
641 if (undef_map->l_reldeps != l_reldeps)
642 {
643 struct link_map **list = &undef_map->l_reldeps->list[0];
644 l_reldepsact = undef_map->l_reldeps->act;
645 for (i = 0; i < l_reldepsact; ++i)
646 if (list[i] == map)
647 goto out_check;
648 }
649 else if (undef_map->l_reldeps->act > l_reldepsact)
650 {
651 struct link_map **list
652 = &undef_map->l_reldeps->list[0];
653 i = l_reldepsact;
654 l_reldepsact = undef_map->l_reldeps->act;
655 for (; i < l_reldepsact; ++i)
656 if (list[i] == map)
657 goto out_check;
658 }
659 }
660 }
661 else
662 __rtld_lock_lock_recursive (GL(dl_load_lock));
663
664 /* The object is not yet in the dependency list. Before we add
665 it make sure just one more time the object we are about to
666 reference is still available. There is a brief period in
667 which the object could have been removed since we found the
668 definition. */
669 runp = GL(dl_ns)[undef_map->l_ns]._ns_loaded;
670 while (runp != NULL && runp != map)
671 runp = runp->l_next;
672
673 if (runp != NULL)
674 {
675 /* The object is still available. */
676
677 /* MAP could have been dlclosed, freed and then some other dlopened
678 library could have the same link_map pointer. */
679 if (map->l_serial != serial)
680 goto out_check;
681
682 /* Redo the NODELETE check, as when dl_load_lock wasn't held
683 yet this could have changed. */
684 if ((map->l_flags_1 & DF_1_NODELETE) != 0)
685 goto out;
686
687 /* If the object with the undefined reference cannot be removed ever
688 just make sure the same is true for the object which contains the
689 definition. */
690 if (undef_map->l_type != lt_loaded
691 || (undef_map->l_flags_1 & DF_1_NODELETE) != 0)
692 {
693 map->l_flags_1 |= DF_1_NODELETE;
694 goto out;
695 }
696
697 /* Add the reference now. */
698 if (__glibc_unlikely (l_reldepsact >= undef_map->l_reldepsmax))
699 {
700 /* Allocate more memory for the dependency list. Since this
701 can never happen during the startup phase we can use
702 `realloc'. */
703 struct link_map_reldeps *newp;
704 unsigned int max
705 = undef_map->l_reldepsmax ? undef_map->l_reldepsmax * 2 : 10;
706
707#ifdef RTLD_PREPARE_FOREIGN_CALL
708 RTLD_PREPARE_FOREIGN_CALL;
709#endif
710
711 newp = malloc (sizeof (*newp) + max * sizeof (struct link_map *));
712 if (newp == NULL)
713 {
714 /* If we didn't manage to allocate memory for the list this is
715 no fatal problem. We simply make sure the referenced object
716 cannot be unloaded. This is semantically the correct
717 behavior. */
718 map->l_flags_1 |= DF_1_NODELETE;
719 goto out;
720 }
721 else
722 {
723 if (l_reldepsact)
724 memcpy (&newp->list[0], &undef_map->l_reldeps->list[0],
725 l_reldepsact * sizeof (struct link_map *));
726 newp->list[l_reldepsact] = map;
727 newp->act = l_reldepsact + 1;
728 atomic_write_barrier ();
729 void *old = undef_map->l_reldeps;
730 undef_map->l_reldeps = newp;
731 undef_map->l_reldepsmax = max;
732 if (old)
733 _dl_scope_free (old);
734 }
735 }
736 else
737 {
738 undef_map->l_reldeps->list[l_reldepsact] = map;
739 atomic_write_barrier ();
740 undef_map->l_reldeps->act = l_reldepsact + 1;
741 }
742
743 /* Display information if we are debugging. */
744 if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_FILES))
745 _dl_debug_printf ("\
746\nfile=%s [%lu]; needed by %s [%lu] (relocation dependency)\n\n",
747 DSO_FILENAME (map->l_name),
748 map->l_ns,
749 DSO_FILENAME (undef_map->l_name),
750 undef_map->l_ns);
751 }
752 else
753 /* Whoa, that was bad luck. We have to search again. */
754 result = -1;
755
756 out:
757 /* Release the lock. */
758 __rtld_lock_unlock_recursive (GL(dl_load_lock));
759
760 if (__glibc_unlikely (flags & DL_LOOKUP_GSCOPE_LOCK))
761 THREAD_GSCOPE_SET_FLAG ();
762
763 return result;
764
765 out_check:
766 if (map->l_serial != serial)
767 result = -1;
768 goto out;
769}
770
771static void
772_dl_debug_bindings (const char *undef_name, struct link_map *undef_map,
773 const ElfW(Sym) **ref, struct sym_val *value,
774 const struct r_found_version *version, int type_class,
775 int protected);
776
777
778/* Search loaded objects' symbol tables for a definition of the symbol
779 UNDEF_NAME, perhaps with a requested version for the symbol.
780
781 We must never have calls to the audit functions inside this function
782 or in any function which gets called. If this would happen the audit
783 code might create a thread which can throw off all the scope locking. */
784lookup_t
785_dl_lookup_symbol_x (const char *undef_name, struct link_map *undef_map,
786 const ElfW(Sym) **ref,
787 struct r_scope_elem *symbol_scope[],
788 const struct r_found_version *version,
789 int type_class, int flags, struct link_map *skip_map)
790{
791 const uint_fast32_t new_hash = dl_new_hash (undef_name);
792 unsigned long int old_hash = 0xffffffff;
793 struct sym_val current_value = { NULL, NULL };
794 struct r_scope_elem **scope = symbol_scope;
795
796 bump_num_relocations ();
797
798 /* No other flag than DL_LOOKUP_ADD_DEPENDENCY or DL_LOOKUP_GSCOPE_LOCK
799 is allowed if we look up a versioned symbol. */
800 assert (version == NULL
801 || (flags & ~(DL_LOOKUP_ADD_DEPENDENCY | DL_LOOKUP_GSCOPE_LOCK))
802 == 0);
803
804 size_t i = 0;
805 if (__glibc_unlikely (skip_map != NULL))
806 /* Search the relevant loaded objects for a definition. */
807 while ((*scope)->r_list[i] != skip_map)
808 ++i;
809
810 /* Search the relevant loaded objects for a definition. */
811 for (size_t start = i; *scope != NULL; start = 0, ++scope)
812 {
813 int res = do_lookup_x (undef_name, new_hash, &old_hash, *ref,
814 &current_value, *scope, start, version, flags,
815 skip_map, type_class, undef_map);
816 if (res > 0)
817 break;
818
819 if (__glibc_unlikely (res < 0) && skip_map == NULL)
820 {
821 /* Oh, oh. The file named in the relocation entry does not
822 contain the needed symbol. This code is never reached
823 for unversioned lookups. */
824 assert (version != NULL);
825 const char *reference_name = undef_map ? undef_map->l_name : "";
826 struct dl_exception exception;
827 /* XXX We cannot translate the message. */
828 _dl_exception_create_format
829 (&exception, DSO_FILENAME (reference_name),
830 "symbol %s version %s not defined in file %s"
831 " with link time reference%s",
832 undef_name, version->name, version->filename,
833 res == -2 ? " (no version symbols)" : "");
834 _dl_signal_cexception (0, &exception, N_("relocation error"));
835 _dl_exception_free (&exception);
836 *ref = NULL;
837 return 0;
838 }
839 }
840
841 if (__glibc_unlikely (current_value.s == NULL))
842 {
843 if ((*ref == NULL || ELFW(ST_BIND) ((*ref)->st_info) != STB_WEAK)
844 && !(GLRO(dl_debug_mask) & DL_DEBUG_UNUSED))
845 {
846 /* We could find no value for a strong reference. */
847 const char *reference_name = undef_map ? undef_map->l_name : "";
848 const char *versionstr = version ? ", version " : "";
849 const char *versionname = (version && version->name
850 ? version->name : "");
851 struct dl_exception exception;
852 /* XXX We cannot translate the message. */
853 _dl_exception_create_format
854 (&exception, DSO_FILENAME (reference_name),
855 "undefined symbol: %s%s%s",
856 undef_name, versionstr, versionname);
857 _dl_signal_cexception (0, &exception, N_("symbol lookup error"));
858 _dl_exception_free (&exception);
859 }
860 *ref = NULL;
861 return 0;
862 }
863
864 int protected = (*ref
865 && ELFW(ST_VISIBILITY) ((*ref)->st_other) == STV_PROTECTED);
866 if (__glibc_unlikely (protected != 0))
867 {
868 /* It is very tricky. We need to figure out what value to
869 return for the protected symbol. */
870 if (type_class == ELF_RTYPE_CLASS_PLT)
871 {
872 if (current_value.s != NULL && current_value.m != undef_map)
873 {
874 current_value.s = *ref;
875 current_value.m = undef_map;
876 }
877 }
878 else
879 {
880 struct sym_val protected_value = { NULL, NULL };
881
882 for (scope = symbol_scope; *scope != NULL; i = 0, ++scope)
883 if (do_lookup_x (undef_name, new_hash, &old_hash, *ref,
884 &protected_value, *scope, i, version, flags,
885 skip_map,
886 (ELF_RTYPE_CLASS_EXTERN_PROTECTED_DATA
887 && ELFW(ST_TYPE) ((*ref)->st_info) == STT_OBJECT
888 && type_class == ELF_RTYPE_CLASS_EXTERN_PROTECTED_DATA)
889 ? ELF_RTYPE_CLASS_EXTERN_PROTECTED_DATA
890 : ELF_RTYPE_CLASS_PLT, NULL) != 0)
891 break;
892
893 if (protected_value.s != NULL && protected_value.m != undef_map)
894 {
895 current_value.s = *ref;
896 current_value.m = undef_map;
897 }
898 }
899 }
900
901 /* We have to check whether this would bind UNDEF_MAP to an object
902 in the global scope which was dynamically loaded. In this case
903 we have to prevent the latter from being unloaded unless the
904 UNDEF_MAP object is also unloaded. */
905 if (__glibc_unlikely (current_value.m->l_type == lt_loaded)
906 /* Don't do this for explicit lookups as opposed to implicit
907 runtime lookups. */
908 && (flags & DL_LOOKUP_ADD_DEPENDENCY) != 0
909 /* Add UNDEF_MAP to the dependencies. */
910 && add_dependency (undef_map, current_value.m, flags) < 0)
911 /* Something went wrong. Perhaps the object we tried to reference
912 was just removed. Try finding another definition. */
913 return _dl_lookup_symbol_x (undef_name, undef_map, ref,
914 (flags & DL_LOOKUP_GSCOPE_LOCK)
915 ? undef_map->l_scope : symbol_scope,
916 version, type_class, flags, skip_map);
917
918 /* The object is used. */
919 if (__glibc_unlikely (current_value.m->l_used == 0))
920 current_value.m->l_used = 1;
921
922 if (__glibc_unlikely (GLRO(dl_debug_mask)
923 & (DL_DEBUG_BINDINGS|DL_DEBUG_PRELINK)))
924 _dl_debug_bindings (undef_name, undef_map, ref,
925 &current_value, version, type_class, protected);
926
927 *ref = current_value.s;
928 return LOOKUP_VALUE (current_value.m);
929}
930
931
932/* Cache the location of MAP's hash table. */
933
934void
935_dl_setup_hash (struct link_map *map)
936{
937 Elf_Symndx *hash;
938
939 if (__glibc_likely (map->l_info[DT_ADDRTAGIDX (DT_GNU_HASH) + DT_NUM
940 + DT_THISPROCNUM + DT_VERSIONTAGNUM
941 + DT_EXTRANUM + DT_VALNUM] != NULL))
942 {
943 Elf32_Word *hash32
944 = (void *) D_PTR (map, l_info[DT_ADDRTAGIDX (DT_GNU_HASH) + DT_NUM
945 + DT_THISPROCNUM + DT_VERSIONTAGNUM
946 + DT_EXTRANUM + DT_VALNUM]);
947 map->l_nbuckets = *hash32++;
948 Elf32_Word symbias = *hash32++;
949 Elf32_Word bitmask_nwords = *hash32++;
950 /* Must be a power of two. */
951 assert ((bitmask_nwords & (bitmask_nwords - 1)) == 0);
952 map->l_gnu_bitmask_idxbits = bitmask_nwords - 1;
953 map->l_gnu_shift = *hash32++;
954
955 map->l_gnu_bitmask = (ElfW(Addr) *) hash32;
956 hash32 += __ELF_NATIVE_CLASS / 32 * bitmask_nwords;
957
958 map->l_gnu_buckets = hash32;
959 hash32 += map->l_nbuckets;
960 map->l_gnu_chain_zero = hash32 - symbias;
961 return;
962 }
963
964 if (!map->l_info[DT_HASH])
965 return;
966 hash = (void *) D_PTR (map, l_info[DT_HASH]);
967
968 map->l_nbuckets = *hash++;
969 /* Skip nchain. */
970 hash++;
971 map->l_buckets = hash;
972 hash += map->l_nbuckets;
973 map->l_chain = hash;
974}
975
976
977static void
978_dl_debug_bindings (const char *undef_name, struct link_map *undef_map,
979 const ElfW(Sym) **ref, struct sym_val *value,
980 const struct r_found_version *version, int type_class,
981 int protected)
982{
983 const char *reference_name = undef_map->l_name;
984
985 if (GLRO(dl_debug_mask) & DL_DEBUG_BINDINGS)
986 {
987 _dl_debug_printf ("binding file %s [%lu] to %s [%lu]: %s symbol `%s'",
988 DSO_FILENAME (reference_name),
989 undef_map->l_ns,
990 DSO_FILENAME (value->m->l_name),
991 value->m->l_ns,
992 protected ? "protected" : "normal", undef_name);
993 if (version)
994 _dl_debug_printf_c (" [%s]\n", version->name);
995 else
996 _dl_debug_printf_c ("\n");
997 }
998#ifdef SHARED
999 if (GLRO(dl_debug_mask) & DL_DEBUG_PRELINK)
1000 {
1001/* ELF_RTYPE_CLASS_XXX must match RTYPE_CLASS_XXX used by prelink with
1002 LD_TRACE_PRELINKING. */
1003#define RTYPE_CLASS_VALID 8
1004#define RTYPE_CLASS_PLT (8|1)
1005#define RTYPE_CLASS_COPY (8|2)
1006#define RTYPE_CLASS_TLS (8|4)
1007#if ELF_RTYPE_CLASS_PLT != 0 && ELF_RTYPE_CLASS_PLT != 1
1008# error ELF_RTYPE_CLASS_PLT must be 0 or 1!
1009#endif
1010#if ELF_RTYPE_CLASS_COPY != 0 && ELF_RTYPE_CLASS_COPY != 2
1011# error ELF_RTYPE_CLASS_COPY must be 0 or 2!
1012#endif
1013 int conflict = 0;
1014 struct sym_val val = { NULL, NULL };
1015
1016 if ((GLRO(dl_trace_prelink_map) == NULL
1017 || GLRO(dl_trace_prelink_map) == GL(dl_ns)[LM_ID_BASE]._ns_loaded)
1018 && undef_map != GL(dl_ns)[LM_ID_BASE]._ns_loaded)
1019 {
1020 const uint_fast32_t new_hash = dl_new_hash (undef_name);
1021 unsigned long int old_hash = 0xffffffff;
1022 struct unique_sym *saved_entries
1023 = GL(dl_ns)[LM_ID_BASE]._ns_unique_sym_table.entries;
1024
1025 GL(dl_ns)[LM_ID_BASE]._ns_unique_sym_table.entries = NULL;
1026 do_lookup_x (undef_name, new_hash, &old_hash, *ref, &val,
1027 undef_map->l_local_scope[0], 0, version, 0, NULL,
1028 type_class, undef_map);
1029 if (val.s != value->s || val.m != value->m)
1030 conflict = 1;
1031 else if (__glibc_unlikely (undef_map->l_symbolic_in_local_scope)
1032 && val.s
1033 && __glibc_unlikely (ELFW(ST_BIND) (val.s->st_info)
1034 == STB_GNU_UNIQUE))
1035 {
1036 /* If it is STB_GNU_UNIQUE and undef_map's l_local_scope
1037 contains any DT_SYMBOLIC libraries, unfortunately there
1038 can be conflicts even if the above is equal. As symbol
1039 resolution goes from the last library to the first and
1040 if a STB_GNU_UNIQUE symbol is found in some late DT_SYMBOLIC
1041 library, it would be the one that is looked up. */
1042 struct sym_val val2 = { NULL, NULL };
1043 size_t n;
1044 struct r_scope_elem *scope = undef_map->l_local_scope[0];
1045
1046 for (n = 0; n < scope->r_nlist; n++)
1047 if (scope->r_list[n] == val.m)
1048 break;
1049
1050 for (n++; n < scope->r_nlist; n++)
1051 if (scope->r_list[n]->l_info[DT_SYMBOLIC] != NULL
1052 && do_lookup_x (undef_name, new_hash, &old_hash, *ref,
1053 &val2,
1054 &scope->r_list[n]->l_symbolic_searchlist,
1055 0, version, 0, NULL, type_class,
1056 undef_map) > 0)
1057 {
1058 conflict = 1;
1059 val = val2;
1060 break;
1061 }
1062 }
1063 GL(dl_ns)[LM_ID_BASE]._ns_unique_sym_table.entries = saved_entries;
1064 }
1065
1066 if (value->s)
1067 {
1068 /* Keep only ELF_RTYPE_CLASS_PLT and ELF_RTYPE_CLASS_COPY
1069 bits since since prelink only uses them. */
1070 type_class &= ELF_RTYPE_CLASS_PLT | ELF_RTYPE_CLASS_COPY;
1071 if (__glibc_unlikely (ELFW(ST_TYPE) (value->s->st_info)
1072 == STT_TLS))
1073 /* Clear the RTYPE_CLASS_VALID bit in RTYPE_CLASS_TLS. */
1074 type_class = RTYPE_CLASS_TLS & ~RTYPE_CLASS_VALID;
1075 else if (__glibc_unlikely (ELFW(ST_TYPE) (value->s->st_info)
1076 == STT_GNU_IFUNC))
1077 /* Set the RTYPE_CLASS_VALID bit. */
1078 type_class |= RTYPE_CLASS_VALID;
1079 }
1080
1081 if (conflict
1082 || GLRO(dl_trace_prelink_map) == undef_map
1083 || GLRO(dl_trace_prelink_map) == NULL
1084 || type_class >= 4)
1085 {
1086 _dl_printf ("%s 0x%0*Zx 0x%0*Zx -> 0x%0*Zx 0x%0*Zx ",
1087 conflict ? "conflict" : "lookup",
1088 (int) sizeof (ElfW(Addr)) * 2,
1089 (size_t) undef_map->l_map_start,
1090 (int) sizeof (ElfW(Addr)) * 2,
1091 (size_t) (((ElfW(Addr)) *ref) - undef_map->l_map_start),
1092 (int) sizeof (ElfW(Addr)) * 2,
1093 (size_t) (value->s ? value->m->l_map_start : 0),
1094 (int) sizeof (ElfW(Addr)) * 2,
1095 (size_t) (value->s ? value->s->st_value : 0));
1096
1097 if (conflict)
1098 _dl_printf ("x 0x%0*Zx 0x%0*Zx ",
1099 (int) sizeof (ElfW(Addr)) * 2,
1100 (size_t) (val.s ? val.m->l_map_start : 0),
1101 (int) sizeof (ElfW(Addr)) * 2,
1102 (size_t) (val.s ? val.s->st_value : 0));
1103
1104 _dl_printf ("/%x %s\n", type_class, undef_name);
1105 }
1106 }
1107#endif
1108}
1109