]>
Commit | Line | Data |
---|---|---|
c9ff0187 | 1 | /* Manage TLS descriptors. x86_64 version. |
688903eb | 2 | Copyright (C) 2005-2018 Free Software Foundation, Inc. |
c9ff0187 UD |
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 | |
59ba27a6 PE |
16 | License along with the GNU C Library; if not, see |
17 | <http://www.gnu.org/licenses/>. */ | |
c9ff0187 UD |
18 | |
19 | #include <link.h> | |
20 | #include <ldsodefs.h> | |
21 | #include <elf/dynamic-link.h> | |
22 | #include <tls.h> | |
23 | #include <dl-tlsdesc.h> | |
fcccd512 | 24 | #include <dl-unmap-segments.h> |
c9ff0187 UD |
25 | #include <tlsdeschtab.h> |
26 | ||
27 | /* The following 2 functions take a caller argument, that contains the | |
28 | address expected to be in the TLS descriptor. If it's changed, we | |
29 | want to return immediately. */ | |
30 | ||
31 | /* This function is used to lazily resolve TLS_DESC RELA relocations. | |
32 | The argument location is used to hold a pointer to the relocation. */ | |
33 | ||
34 | void | |
35 | attribute_hidden | |
36 | _dl_tlsdesc_resolve_rela_fixup (struct tlsdesc volatile *td, | |
37 | struct link_map *l) | |
38 | { | |
39 | const ElfW(Rela) *reloc = td->arg; | |
40 | ||
41 | if (_dl_tlsdesc_resolve_early_return_p | |
42 | (td, (void*)(D_PTR (l, l_info[ADDRIDX (DT_TLSDESC_PLT)]) + l->l_addr))) | |
43 | return; | |
44 | ||
45 | /* The code below was borrowed from _dl_fixup(). */ | |
46 | const ElfW(Sym) *const symtab | |
47 | = (const void *) D_PTR (l, l_info[DT_SYMTAB]); | |
48 | const char *strtab = (const void *) D_PTR (l, l_info[DT_STRTAB]); | |
49 | const ElfW(Sym) *sym = &symtab[ELFW(R_SYM) (reloc->r_info)]; | |
50 | lookup_t result; | |
51 | ||
52 | /* Look up the target symbol. If the normal lookup rules are not | |
53 | used don't look in the global scope. */ | |
54 | if (ELFW(ST_BIND) (sym->st_info) != STB_LOCAL | |
55 | && __builtin_expect (ELFW(ST_VISIBILITY) (sym->st_other), 0) == 0) | |
56 | { | |
57 | const struct r_found_version *version = NULL; | |
58 | ||
59 | if (l->l_info[VERSYMIDX (DT_VERSYM)] != NULL) | |
60 | { | |
61 | const ElfW(Half) *vernum = | |
62 | (const void *) D_PTR (l, l_info[VERSYMIDX (DT_VERSYM)]); | |
63 | ElfW(Half) ndx = vernum[ELFW(R_SYM) (reloc->r_info)] & 0x7fff; | |
64 | version = &l->l_versions[ndx]; | |
65 | if (version->hash == 0) | |
66 | version = NULL; | |
67 | } | |
68 | ||
69 | result = _dl_lookup_symbol_x (strtab + sym->st_name, l, &sym, | |
70 | l->l_scope, version, ELF_RTYPE_CLASS_PLT, | |
71 | DL_LOOKUP_ADD_DEPENDENCY, NULL); | |
72 | } | |
73 | else | |
74 | { | |
75 | /* We already found the symbol. The module (and therefore its load | |
76 | address) is also known. */ | |
77 | result = l; | |
78 | } | |
79 | ||
80 | if (! sym) | |
81 | { | |
82 | td->arg = (void*)reloc->r_addend; | |
83 | td->entry = _dl_tlsdesc_undefweak; | |
84 | } | |
85 | else | |
86 | { | |
87 | # ifndef SHARED | |
88 | CHECK_STATIC_TLS (l, result); | |
89 | # else | |
90 | if (!TRY_STATIC_TLS (l, result)) | |
91 | { | |
92 | td->arg = _dl_make_tlsdesc_dynamic (result, sym->st_value | |
93 | + reloc->r_addend); | |
94 | td->entry = _dl_tlsdesc_dynamic; | |
95 | } | |
96 | else | |
97 | # endif | |
98 | { | |
99 | td->arg = (void*)(sym->st_value - result->l_tls_offset | |
100 | + reloc->r_addend); | |
101 | td->entry = _dl_tlsdesc_return; | |
102 | } | |
103 | } | |
104 | ||
105 | _dl_tlsdesc_wake_up_held_fixups (); | |
106 | } | |
107 | ||
108 | /* This function is used to avoid busy waiting for other threads to | |
109 | complete the lazy relocation. Once another thread wins the race to | |
110 | relocate a TLS descriptor, it sets the descriptor up such that this | |
111 | function is called to wait until the resolver releases the | |
112 | lock. */ | |
113 | ||
114 | void | |
115 | attribute_hidden | |
116 | _dl_tlsdesc_resolve_hold_fixup (struct tlsdesc volatile *td, | |
117 | void *caller) | |
118 | { | |
119 | /* Maybe we're lucky and can return early. */ | |
120 | if (caller != td->entry) | |
121 | return; | |
122 | ||
123 | /* Locking here will stop execution until the running resolver runs | |
124 | _dl_tlsdesc_wake_up_held_fixups(), releasing the lock. | |
125 | ||
126 | FIXME: We'd be better off waiting on a condition variable, such | |
127 | that we didn't have to hold the lock throughout the relocation | |
128 | processing. */ | |
129 | __rtld_lock_lock_recursive (GL(dl_load_lock)); | |
130 | __rtld_lock_unlock_recursive (GL(dl_load_lock)); | |
131 | } | |
132 | ||
133 | /* Unmap the dynamic object, but also release its TLS descriptor table | |
134 | if there is one. */ | |
135 | ||
136 | void | |
c9ff0187 UD |
137 | _dl_unmap (struct link_map *map) |
138 | { | |
fcccd512 | 139 | _dl_unmap_segments (map); |
c9ff0187 | 140 | |
82374e65 | 141 | #ifdef SHARED |
c9ff0187 UD |
142 | /* _dl_unmap is only called for dlopen()ed libraries, for which |
143 | calling free() is safe, or before we've completed the initial | |
144 | relocation, in which case calling free() is probably pointless, | |
145 | but still safe. */ | |
146 | if (map->l_mach.tlsdesc_table) | |
147 | htab_delete (map->l_mach.tlsdesc_table); | |
148 | #endif | |
149 | } |