]>
Commit | Line | Data |
---|---|---|
dde6fc78 | 1 | /* Manage function descriptors. Generic version. |
b168057a | 2 | Copyright (C) 1999-2015 Free Software Foundation, Inc. |
dde6fc78 CD |
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 <libintl.h> | |
21 | #include <unistd.h> | |
22 | #include <string.h> | |
23 | #include <sys/param.h> | |
24 | #include <sys/mman.h> | |
25 | #include <link.h> | |
26 | #include <ldsodefs.h> | |
27 | #include <elf/dynamic-link.h> | |
28 | #include <dl-fptr.h> | |
fcccd512 | 29 | #include <dl-unmap-segments.h> |
dde6fc78 CD |
30 | #include <atomic.h> |
31 | ||
32 | #ifndef ELF_MACHINE_BOOT_FPTR_TABLE_LEN | |
33 | /* ELF_MACHINE_BOOT_FPTR_TABLE_LEN should be greater than the number of | |
34 | dynamic symbols in ld.so. */ | |
35 | # define ELF_MACHINE_BOOT_FPTR_TABLE_LEN 256 | |
36 | #endif | |
37 | ||
38 | #ifndef ELF_MACHINE_LOAD_ADDRESS | |
39 | # error "ELF_MACHINE_LOAD_ADDRESS is not defined." | |
40 | #endif | |
41 | ||
42 | #ifndef COMPARE_AND_SWAP | |
43 | # define COMPARE_AND_SWAP(ptr, old, new) \ | |
44 | (catomic_compare_and_exchange_bool_acq (ptr, new, old) == 0) | |
45 | #endif | |
46 | ||
47 | ElfW(Addr) _dl_boot_fptr_table [ELF_MACHINE_BOOT_FPTR_TABLE_LEN]; | |
48 | ||
49 | static struct local | |
50 | { | |
51 | struct fdesc_table *root; | |
52 | struct fdesc *free_list; | |
53 | unsigned int npages; /* # of pages to allocate */ | |
54 | /* the next to members MUST be consecutive! */ | |
55 | struct fdesc_table boot_table; | |
56 | struct fdesc boot_fdescs[1024]; | |
57 | } | |
58 | local = | |
59 | { | |
60 | #ifdef SHARED | |
61 | /* Address of .boot_table is not known until runtime. */ | |
62 | .root = 0, | |
63 | #else | |
64 | .root = &local.boot_table, | |
65 | #endif | |
66 | .npages = 2, | |
67 | .boot_table = | |
68 | { | |
69 | .len = sizeof (local.boot_fdescs) / sizeof (local.boot_fdescs[0]), | |
70 | .first_unused = 0 | |
71 | } | |
72 | }; | |
73 | ||
74 | /* Create a new fdesc table and return a pointer to the first fdesc | |
75 | entry. The fdesc lock must have been acquired already. */ | |
76 | ||
77 | static struct fdesc_table * | |
78 | new_fdesc_table (struct local *l, size_t *size) | |
79 | { | |
80 | size_t old_npages = l->npages; | |
81 | size_t new_npages = old_npages + old_npages; | |
82 | struct fdesc_table *new_table; | |
83 | ||
84 | /* If someone has just created a new table, we return NULL to tell | |
85 | the caller to use the new table. */ | |
86 | if (! COMPARE_AND_SWAP (&l->npages, old_npages, new_npages)) | |
87 | return (struct fdesc_table *) NULL; | |
88 | ||
89 | *size = old_npages * GLRO(dl_pagesize); | |
90 | new_table = __mmap (NULL, *size, | |
91 | PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0); | |
92 | if (new_table == MAP_FAILED) | |
93 | _dl_signal_error (errno, NULL, NULL, | |
94 | N_("cannot map pages for fdesc table")); | |
95 | ||
96 | new_table->len | |
97 | = (*size - sizeof (*new_table)) / sizeof (struct fdesc); | |
98 | new_table->first_unused = 1; | |
99 | return new_table; | |
100 | } | |
101 | ||
102 | /* Must call _dl_fptr_init before using any other function. */ | |
5556231d | 103 | void |
dde6fc78 CD |
104 | _dl_fptr_init (void) |
105 | { | |
106 | struct local *l; | |
107 | ||
108 | ELF_MACHINE_LOAD_ADDRESS (l, local); | |
109 | l->root = &l->boot_table; | |
110 | } | |
111 | ||
112 | static ElfW(Addr) | |
113 | make_fdesc (ElfW(Addr) ip, ElfW(Addr) gp) | |
114 | { | |
115 | struct fdesc *fdesc = NULL; | |
116 | struct fdesc_table *root; | |
117 | unsigned int old; | |
118 | struct local *l; | |
119 | ||
120 | ELF_MACHINE_LOAD_ADDRESS (l, local); | |
121 | ||
122 | retry: | |
123 | root = l->root; | |
124 | while (1) | |
125 | { | |
126 | old = root->first_unused; | |
127 | if (old >= root->len) | |
128 | break; | |
129 | else if (COMPARE_AND_SWAP (&root->first_unused, old, old + 1)) | |
130 | { | |
131 | fdesc = &root->fdesc[old]; | |
132 | goto install; | |
133 | } | |
134 | } | |
135 | ||
136 | if (l->free_list) | |
137 | { | |
138 | /* Get it from free-list. */ | |
139 | do | |
140 | { | |
141 | fdesc = l->free_list; | |
142 | if (fdesc == NULL) | |
143 | goto retry; | |
144 | } | |
145 | while (! COMPARE_AND_SWAP ((ElfW(Addr) *) &l->free_list, | |
146 | (ElfW(Addr)) fdesc, fdesc->ip)); | |
147 | } | |
148 | else | |
149 | { | |
150 | /* Create a new fdesc table. */ | |
151 | size_t size; | |
152 | struct fdesc_table *new_table = new_fdesc_table (l, &size); | |
153 | ||
154 | if (new_table == NULL) | |
155 | goto retry; | |
156 | ||
157 | new_table->next = root; | |
158 | if (! COMPARE_AND_SWAP ((ElfW(Addr) *) &l->root, | |
159 | (ElfW(Addr)) root, | |
160 | (ElfW(Addr)) new_table)) | |
161 | { | |
162 | /* Someone has just installed a new table. Return NULL to | |
163 | tell the caller to use the new table. */ | |
164 | __munmap (new_table, size); | |
165 | goto retry; | |
166 | } | |
167 | ||
168 | /* Note that the first entry was reserved while allocating the | |
169 | memory for the new page. */ | |
170 | fdesc = &new_table->fdesc[0]; | |
171 | } | |
172 | ||
173 | install: | |
174 | fdesc->ip = ip; | |
175 | fdesc->gp = gp; | |
176 | ||
177 | return (ElfW(Addr)) fdesc; | |
178 | } | |
179 | ||
180 | ||
181 | static inline ElfW(Addr) * __attribute__ ((always_inline)) | |
182 | make_fptr_table (struct link_map *map) | |
183 | { | |
184 | const ElfW(Sym) *symtab | |
185 | = (const void *) D_PTR (map, l_info[DT_SYMTAB]); | |
186 | const char *strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]); | |
187 | ElfW(Addr) *fptr_table; | |
188 | size_t size; | |
189 | size_t len; | |
190 | ||
191 | /* XXX Apparently the only way to find out the size of the dynamic | |
192 | symbol section is to assume that the string table follows right | |
193 | afterwards... */ | |
194 | len = ((strtab - (char *) symtab) | |
195 | / map->l_info[DT_SYMENT]->d_un.d_val); | |
196 | size = ((len * sizeof (fptr_table[0]) + GLRO(dl_pagesize) - 1) | |
197 | & -GLRO(dl_pagesize)); | |
198 | /* XXX We don't support here in the moment systems without MAP_ANON. | |
199 | There probably are none for IA-64. In case this is proven wrong | |
200 | we will have to open /dev/null here and use the file descriptor | |
201 | instead of the hard-coded -1. */ | |
202 | fptr_table = __mmap (NULL, size, | |
203 | PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, | |
204 | -1, 0); | |
205 | if (fptr_table == MAP_FAILED) | |
206 | _dl_signal_error (errno, NULL, NULL, | |
207 | N_("cannot map pages for fptr table")); | |
208 | ||
209 | if (COMPARE_AND_SWAP ((ElfW(Addr) *) &map->l_mach.fptr_table, | |
210 | (ElfW(Addr)) NULL, (ElfW(Addr)) fptr_table)) | |
211 | map->l_mach.fptr_table_len = len; | |
212 | else | |
213 | __munmap (fptr_table, len * sizeof (fptr_table[0])); | |
214 | ||
215 | return map->l_mach.fptr_table; | |
216 | } | |
217 | ||
218 | ||
219 | ElfW(Addr) | |
220 | _dl_make_fptr (struct link_map *map, const ElfW(Sym) *sym, | |
221 | ElfW(Addr) ip) | |
222 | { | |
223 | ElfW(Addr) *ftab = map->l_mach.fptr_table; | |
224 | const ElfW(Sym) *symtab; | |
225 | Elf_Symndx symidx; | |
226 | struct local *l; | |
227 | ||
228 | if (__builtin_expect (ftab == NULL, 0)) | |
229 | ftab = make_fptr_table (map); | |
230 | ||
231 | symtab = (const void *) D_PTR (map, l_info[DT_SYMTAB]); | |
232 | symidx = sym - symtab; | |
233 | ||
234 | if (symidx >= map->l_mach.fptr_table_len) | |
235 | _dl_signal_error (0, NULL, NULL, | |
236 | N_("internal error: symidx out of range of fptr table")); | |
237 | ||
238 | while (ftab[symidx] == 0) | |
239 | { | |
240 | /* GOT has already been relocated in elf_get_dynamic_info - | |
241 | don't try to relocate it again. */ | |
242 | ElfW(Addr) fdesc | |
243 | = make_fdesc (ip, map->l_info[DT_PLTGOT]->d_un.d_ptr); | |
244 | ||
245 | if (__builtin_expect (COMPARE_AND_SWAP (&ftab[symidx], (ElfW(Addr)) NULL, | |
246 | fdesc), 1)) | |
247 | { | |
248 | /* Noone has updated the entry and the new function | |
249 | descriptor has been installed. */ | |
250 | #if 0 | |
251 | const char *strtab | |
252 | = (const void *) D_PTR (map, l_info[DT_STRTAB]); | |
253 | ||
254 | ELF_MACHINE_LOAD_ADDRESS (l, local); | |
255 | if (l->root != &l->boot_table | |
256 | || l->boot_table.first_unused > 20) | |
257 | _dl_debug_printf ("created fdesc symbol `%s' at %lx\n", | |
258 | strtab + sym->st_name, ftab[symidx]); | |
259 | #endif | |
260 | break; | |
261 | } | |
262 | else | |
263 | { | |
264 | /* We created a duplicated function descriptor. We put it on | |
265 | free-list. */ | |
266 | struct fdesc *f = (struct fdesc *) fdesc; | |
267 | ||
268 | ELF_MACHINE_LOAD_ADDRESS (l, local); | |
269 | ||
270 | do | |
271 | f->ip = (ElfW(Addr)) l->free_list; | |
272 | while (! COMPARE_AND_SWAP ((ElfW(Addr) *) &l->free_list, | |
273 | f->ip, fdesc)); | |
274 | } | |
275 | } | |
276 | ||
277 | return ftab[symidx]; | |
278 | } | |
279 | ||
280 | ||
281 | void | |
282 | _dl_unmap (struct link_map *map) | |
283 | { | |
284 | ElfW(Addr) *ftab = map->l_mach.fptr_table; | |
285 | struct fdesc *head = NULL, *tail = NULL; | |
286 | size_t i; | |
287 | ||
fcccd512 | 288 | _dl_unmap_segments (map); |
dde6fc78 CD |
289 | |
290 | if (ftab == NULL) | |
291 | return; | |
292 | ||
293 | /* String together the fdesc structures that are being freed. */ | |
294 | for (i = 0; i < map->l_mach.fptr_table_len; ++i) | |
295 | { | |
296 | if (ftab[i]) | |
297 | { | |
298 | *(struct fdesc **) ftab[i] = head; | |
299 | head = (struct fdesc *) ftab[i]; | |
300 | if (tail == NULL) | |
301 | tail = head; | |
302 | } | |
303 | } | |
304 | ||
305 | /* Prepend the new list to the free_list: */ | |
306 | if (tail) | |
307 | do | |
308 | tail->ip = (ElfW(Addr)) local.free_list; | |
309 | while (! COMPARE_AND_SWAP ((ElfW(Addr) *) &local.free_list, | |
310 | tail->ip, (ElfW(Addr)) head)); | |
311 | ||
312 | __munmap (ftab, (map->l_mach.fptr_table_len | |
313 | * sizeof (map->l_mach.fptr_table[0]))); | |
314 | ||
315 | map->l_mach.fptr_table = NULL; | |
316 | } | |
317 | ||
318 | ||
319 | ElfW(Addr) | |
320 | _dl_lookup_address (const void *address) | |
321 | { | |
322 | ElfW(Addr) addr = (ElfW(Addr)) address; | |
323 | struct fdesc_table *t; | |
324 | unsigned long int i; | |
325 | ||
326 | for (t = local.root; t != NULL; t = t->next) | |
327 | { | |
328 | i = (struct fdesc *) addr - &t->fdesc[0]; | |
329 | if (i < t->first_unused && addr == (ElfW(Addr)) &t->fdesc[i]) | |
330 | { | |
331 | addr = t->fdesc[i].ip; | |
332 | break; | |
333 | } | |
334 | } | |
335 | ||
336 | return addr; | |
337 | } |