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 | |
43 | struct 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. */ |
63 | static const ElfW(Sym) * |
64 | check_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. */ |
169 | static void |
170 | enter_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. */ |
192 | static void |
193 | do_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. */ |
331 | static int |
332 | __attribute_noinline__ |
333 | do_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 | |
537 | skip: |
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 | |
551 | static uint_fast32_t |
552 | dl_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. */ |
562 | static int |
563 | add_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 | |
771 | static 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. */ |
784 | lookup_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 | ¤t_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 | ¤t_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 | |
934 | void |
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 | |
977 | static 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 | |