]>
Commit | Line | Data |
---|---|---|
b3fc5f84 | 1 | /* Handle loading and unloading shared objects for internal libc purposes. |
04277e02 | 2 | Copyright (C) 1999-2019 Free Software Foundation, Inc. |
b3fc5f84 UD |
3 | This file is part of the GNU C Library. |
4 | Contributed by Zack Weinberg <zack@rabi.columbia.edu>, 1999. | |
5 | ||
6 | The GNU C Library is free software; you can redistribute it and/or | |
41bdb6e2 AJ |
7 | modify it under the terms of the GNU Lesser General Public |
8 | License as published by the Free Software Foundation; either | |
9 | version 2.1 of the License, or (at your option) any later version. | |
b3fc5f84 UD |
10 | |
11 | The GNU C Library is distributed in the hope that it will be useful, | |
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
41bdb6e2 | 14 | Lesser General Public License for more details. |
b3fc5f84 | 15 | |
41bdb6e2 | 16 | You should have received a copy of the GNU Lesser General Public |
59ba27a6 PE |
17 | License along with the GNU C Library; if not, see |
18 | <http://www.gnu.org/licenses/>. */ | |
b3fc5f84 UD |
19 | |
20 | #include <dlfcn.h> | |
21 | #include <stdlib.h> | |
22 | #include <ldsodefs.h> | |
82eef55f | 23 | #include <dl-hash.h> |
b3fc5f84 | 24 | |
9dcafc55 UD |
25 | extern int __libc_argc attribute_hidden; |
26 | extern char **__libc_argv attribute_hidden; | |
27 | ||
28 | extern char **__environ; | |
29 | ||
b3fc5f84 UD |
30 | /* The purpose of this file is to provide wrappers around the dynamic |
31 | linker error mechanism (similar to dlopen() et al in libdl) which | |
32 | are usable from within libc. Generally we want to throw away the | |
33 | string that dlerror() would return and just pass back a null pointer | |
34 | for errors. This also lets the rest of libc not know about the error | |
35 | handling mechanism. | |
36 | ||
37 | Much of this code came from gconv_dl.c with slight modifications. */ | |
38 | ||
39 | static int | |
b3fc5f84 UD |
40 | dlerror_run (void (*operate) (void *), void *args) |
41 | { | |
8e17ea58 UD |
42 | const char *objname; |
43 | const char *last_errstring = NULL; | |
74780cf6 | 44 | bool malloced; |
b3fc5f84 | 45 | |
9e78f6f6 FW |
46 | int result = (_dl_catch_error (&objname, &last_errstring, &malloced, |
47 | operate, args) | |
fdc86bc9 | 48 | ?: last_errstring != NULL); |
b3fc5f84 | 49 | |
74780cf6 | 50 | if (result && malloced) |
8e17ea58 | 51 | free ((char *) last_errstring); |
b3fc5f84 UD |
52 | |
53 | return result; | |
54 | } | |
55 | ||
56 | /* These functions are called by dlerror_run... */ | |
57 | ||
58 | struct do_dlopen_args | |
59 | { | |
60 | /* Argument to do_dlopen. */ | |
61 | const char *name; | |
3c857306 UD |
62 | /* Opening mode. */ |
63 | int mode; | |
1dc27704 UD |
64 | /* This is the caller of the dlopen() function. */ |
65 | const void *caller_dlopen; | |
b3fc5f84 UD |
66 | |
67 | /* Return from do_dlopen. */ | |
68 | struct link_map *map; | |
69 | }; | |
70 | ||
71 | struct do_dlsym_args | |
72 | { | |
73 | /* Arguments to do_dlsym. */ | |
74 | struct link_map *map; | |
75 | const char *name; | |
76 | ||
77 | /* Return values of do_dlsym. */ | |
c0282c06 | 78 | lookup_t loadbase; |
b3fc5f84 UD |
79 | const ElfW(Sym) *ref; |
80 | }; | |
81 | ||
82eef55f FW |
82 | struct do_dlvsym_args |
83 | { | |
84 | /* dlvsym is like dlsym. */ | |
85 | struct do_dlsym_args dlsym; | |
86 | ||
87 | /* But dlvsym needs a version as well. */ | |
88 | struct r_found_version version; | |
89 | }; | |
90 | ||
b3fc5f84 UD |
91 | static void |
92 | do_dlopen (void *ptr) | |
93 | { | |
94 | struct do_dlopen_args *args = (struct do_dlopen_args *) ptr; | |
95 | /* Open and relocate the shared object. */ | |
1dc27704 UD |
96 | args->map = GLRO(dl_open) (args->name, args->mode, args->caller_dlopen, |
97 | __LM_ID_CALLER, __libc_argc, __libc_argv, | |
98 | __environ); | |
b3fc5f84 UD |
99 | } |
100 | ||
101 | static void | |
102 | do_dlsym (void *ptr) | |
103 | { | |
104 | struct do_dlsym_args *args = (struct do_dlsym_args *) ptr; | |
105 | args->ref = NULL; | |
021723ab UD |
106 | args->loadbase = GLRO(dl_lookup_symbol_x) (args->name, args->map, &args->ref, |
107 | args->map->l_local_scope, NULL, 0, | |
108 | DL_LOOKUP_RETURN_NEWEST, NULL); | |
b3fc5f84 UD |
109 | } |
110 | ||
82eef55f FW |
111 | static void |
112 | do_dlvsym (void *ptr) | |
113 | { | |
114 | struct do_dlvsym_args *args = ptr; | |
115 | args->dlsym.ref = NULL; | |
116 | args->dlsym.loadbase | |
117 | = GLRO(dl_lookup_symbol_x) (args->dlsym.name, args->dlsym.map, | |
118 | &args->dlsym.ref, | |
119 | args->dlsym.map->l_local_scope, | |
120 | &args->version, 0, 0, NULL); | |
121 | } | |
122 | ||
b3fc5f84 UD |
123 | static void |
124 | do_dlclose (void *ptr) | |
125 | { | |
9dcafc55 | 126 | GLRO(dl_close) ((struct link_map *) ptr); |
b3fc5f84 UD |
127 | } |
128 | ||
81b215af UD |
129 | /* This code is to support __libc_dlopen from __libc_dlopen'ed shared |
130 | libraries. We need to ensure the statically linked __libc_dlopen | |
131 | etc. functions are used instead of the dynamically loaded. */ | |
132 | struct dl_open_hook | |
133 | { | |
134 | void *(*dlopen_mode) (const char *name, int mode); | |
135 | void *(*dlsym) (void *map, const char *name); | |
136 | int (*dlclose) (void *map); | |
82eef55f | 137 | void *(*dlvsym) (void *map, const char *name, const char *version); |
81b215af UD |
138 | }; |
139 | ||
140 | #ifdef SHARED | |
141 | extern struct dl_open_hook *_dl_open_hook; | |
142 | libc_hidden_proto (_dl_open_hook); | |
9dcafc55 | 143 | struct dl_open_hook *_dl_open_hook __attribute__ ((nocommon)); |
81b215af | 144 | libc_hidden_data_def (_dl_open_hook); |
82eef55f FW |
145 | |
146 | /* The dlvsym member was added retroactively to struct dl_open_hook. | |
147 | Static applications which have it will set _dl_open_hook2 in | |
148 | addition to _dl_open_hook. */ | |
149 | extern struct dl_open_hook *_dl_open_hook2; | |
150 | libc_hidden_proto (_dl_open_hook2); | |
151 | struct dl_open_hook *_dl_open_hook2 __attribute__ ((nocommon)); | |
152 | libc_hidden_data_def (_dl_open_hook2); | |
153 | ||
81b215af UD |
154 | #else |
155 | static void | |
156 | do_dlsym_private (void *ptr) | |
157 | { | |
158 | lookup_t l; | |
159 | struct r_found_version vers; | |
160 | vers.name = "GLIBC_PRIVATE"; | |
161 | vers.hidden = 1; | |
9dcafc55 | 162 | /* vers.hash = _dl_elf_hash (vers.name); */ |
81b215af | 163 | vers.hash = 0x0963cf85; |
81b215af UD |
164 | vers.filename = NULL; |
165 | ||
166 | struct do_dlsym_args *args = (struct do_dlsym_args *) ptr; | |
167 | args->ref = NULL; | |
021723ab | 168 | l = GLRO(dl_lookup_symbol_x) (args->name, args->map, &args->ref, |
c0a777e8 | 169 | args->map->l_scope, &vers, 0, 0, NULL); |
81b215af UD |
170 | args->loadbase = l; |
171 | } | |
172 | ||
173 | static struct dl_open_hook _dl_open_hook = | |
174 | { | |
175 | .dlopen_mode = __libc_dlopen_mode, | |
176 | .dlsym = __libc_dlsym, | |
82eef55f FW |
177 | .dlclose = __libc_dlclose, |
178 | .dlvsym = __libc_dlvsym, | |
81b215af UD |
179 | }; |
180 | #endif | |
181 | ||
b3fc5f84 UD |
182 | /* ... and these functions call dlerror_run. */ |
183 | ||
184 | void * | |
3c857306 | 185 | __libc_dlopen_mode (const char *name, int mode) |
b3fc5f84 UD |
186 | { |
187 | struct do_dlopen_args args; | |
3c857306 UD |
188 | args.name = name; |
189 | args.mode = mode; | |
1dc27704 | 190 | args.caller_dlopen = RETURN_ADDRESS (0); |
b3fc5f84 | 191 | |
81b215af | 192 | #ifdef SHARED |
8e1472d2 | 193 | if (!rtld_active ()) |
81b215af | 194 | return _dl_open_hook->dlopen_mode (name, mode); |
b3fc5f84 | 195 | return (dlerror_run (do_dlopen, &args) ? NULL : (void *) args.map); |
81b215af UD |
196 | #else |
197 | if (dlerror_run (do_dlopen, &args)) | |
198 | return NULL; | |
199 | ||
790b6c7a UD |
200 | __libc_register_dl_open_hook (args.map); |
201 | __libc_register_dlfcn_hook (args.map); | |
202 | return (void *) args.map; | |
203 | #endif | |
204 | } | |
205 | libc_hidden_def (__libc_dlopen_mode) | |
206 | ||
207 | #ifndef SHARED | |
208 | void * | |
209 | __libc_dlsym_private (struct link_map *map, const char *name) | |
210 | { | |
81b215af | 211 | struct do_dlsym_args sargs; |
790b6c7a UD |
212 | sargs.map = map; |
213 | sargs.name = name; | |
81b215af UD |
214 | |
215 | if (! dlerror_run (do_dlsym_private, &sargs)) | |
790b6c7a UD |
216 | return DL_SYMBOL_ADDRESS (sargs.loadbase, sargs.ref); |
217 | return NULL; | |
218 | } | |
81b215af | 219 | |
790b6c7a UD |
220 | void |
221 | __libc_register_dl_open_hook (struct link_map *map) | |
222 | { | |
223 | struct dl_open_hook **hook; | |
224 | ||
225 | hook = (struct dl_open_hook **) __libc_dlsym_private (map, "_dl_open_hook"); | |
226 | if (hook != NULL) | |
227 | *hook = &_dl_open_hook; | |
82eef55f FW |
228 | |
229 | /* For dlvsym support. */ | |
230 | hook = (struct dl_open_hook **) __libc_dlsym_private (map, "_dl_open_hook2"); | |
231 | if (hook != NULL) | |
232 | *hook = &_dl_open_hook; | |
b3fc5f84 | 233 | } |
790b6c7a | 234 | #endif |
b3fc5f84 UD |
235 | |
236 | void * | |
3c857306 | 237 | __libc_dlsym (void *map, const char *name) |
b3fc5f84 UD |
238 | { |
239 | struct do_dlsym_args args; | |
3c857306 UD |
240 | args.map = map; |
241 | args.name = name; | |
b3fc5f84 | 242 | |
81b215af | 243 | #ifdef SHARED |
8e1472d2 | 244 | if (!rtld_active ()) |
81b215af UD |
245 | return _dl_open_hook->dlsym (map, name); |
246 | #endif | |
b3fc5f84 | 247 | return (dlerror_run (do_dlsym, &args) ? NULL |
b511d8fc | 248 | : (void *) (DL_SYMBOL_ADDRESS (args.loadbase, args.ref))); |
b3fc5f84 | 249 | } |
9d79e037 | 250 | libc_hidden_def (__libc_dlsym) |
b3fc5f84 | 251 | |
82eef55f FW |
252 | /* Replacement for dlvsym. MAP must be a real map. This function |
253 | returns NULL without setting the dlerror value in case of static | |
254 | dlopen from an old binary. */ | |
255 | void * | |
256 | __libc_dlvsym (void *map, const char *name, const char *version) | |
257 | { | |
258 | #ifdef SHARED | |
259 | if (!rtld_active ()) | |
260 | { | |
261 | /* The static application is too old and does not provide the | |
262 | dlvsym hook. */ | |
263 | if (_dl_open_hook2 == NULL) | |
264 | return NULL; | |
265 | return _dl_open_hook2->dlvsym (map, name, version); | |
266 | } | |
267 | #endif | |
268 | ||
269 | struct do_dlvsym_args args; | |
270 | args.dlsym.map = map; | |
271 | args.dlsym.name = name; | |
272 | ||
273 | /* See _dl_vsym in dl-sym.c. */ | |
274 | args.version.name = version; | |
275 | args.version.hidden = 1; | |
276 | args.version.hash = _dl_elf_hash (version); | |
277 | args.version.filename = NULL; | |
278 | ||
279 | return (dlerror_run (do_dlvsym, &args) ? NULL | |
280 | : (void *) (DL_SYMBOL_ADDRESS (args.dlsym.loadbase, | |
281 | args.dlsym.ref))); | |
282 | } | |
283 | libc_hidden_def (__libc_dlvsym) | |
284 | ||
b3fc5f84 | 285 | int |
3c857306 | 286 | __libc_dlclose (void *map) |
b3fc5f84 | 287 | { |
81b215af | 288 | #ifdef SHARED |
8e1472d2 | 289 | if (!rtld_active ()) |
81b215af UD |
290 | return _dl_open_hook->dlclose (map); |
291 | #endif | |
3c857306 | 292 | return dlerror_run (do_dlclose, map); |
b3fc5f84 | 293 | } |
9d79e037 | 294 | libc_hidden_def (__libc_dlclose) |
752a2a50 UD |
295 | |
296 | ||
56801c50 AS |
297 | static bool __libc_freeres_fn_section |
298 | free_slotinfo (struct dtv_slotinfo_list **elemp) | |
299 | { | |
300 | size_t cnt; | |
301 | ||
302 | if (*elemp == NULL) | |
303 | /* Nothing here, all is removed (or there never was anything). */ | |
304 | return true; | |
305 | ||
306 | if (!free_slotinfo (&(*elemp)->next)) | |
307 | /* We cannot free the entry. */ | |
308 | return false; | |
309 | ||
310 | /* That cleared our next pointer for us. */ | |
311 | ||
312 | for (cnt = 0; cnt < (*elemp)->len; ++cnt) | |
313 | if ((*elemp)->slotinfo[cnt].map != NULL) | |
314 | /* Still used. */ | |
315 | return false; | |
316 | ||
317 | /* We can remove the list element. */ | |
318 | free (*elemp); | |
319 | *elemp = NULL; | |
320 | ||
321 | return true; | |
322 | } | |
323 | ||
324 | ||
c877418f | 325 | libc_freeres_fn (free_mem) |
752a2a50 UD |
326 | { |
327 | struct link_map *l; | |
f55727ca UD |
328 | struct r_search_path_elem *d; |
329 | ||
330 | /* Remove all search directories. */ | |
d6b5d570 | 331 | d = GL(dl_all_dirs); |
c31e278f | 332 | while (d != GLRO(dl_init_all_dirs)) |
f55727ca UD |
333 | { |
334 | struct r_search_path_elem *old = d; | |
335 | d = d->next; | |
336 | free (old); | |
337 | } | |
752a2a50 | 338 | |
22c83193 | 339 | for (Lmid_t ns = 0; ns < GL(dl_nns); ++ns) |
56801c50 | 340 | { |
56801c50 AS |
341 | for (l = GL(dl_ns)[ns]._ns_loaded; l != NULL; l = l->l_next) |
342 | { | |
343 | struct libname_list *lnp = l->l_libname->next; | |
344 | ||
345 | l->l_libname->next = NULL; | |
346 | ||
0479b305 | 347 | /* Remove all additional names added to the objects. */ |
56801c50 AS |
348 | while (lnp != NULL) |
349 | { | |
350 | struct libname_list *old = lnp; | |
351 | lnp = lnp->next; | |
352 | if (! old->dont_free) | |
353 | free (old); | |
354 | } | |
0479b305 AS |
355 | |
356 | /* Free the initfini dependency list. */ | |
357 | if (l->l_free_initfini) | |
358 | free (l->l_initfini); | |
4b1a6d8b | 359 | l->l_initfini = NULL; |
56801c50 AS |
360 | } |
361 | ||
362 | if (__builtin_expect (GL(dl_ns)[ns]._ns_global_scope_alloc, 0) != 0 | |
363 | && (GL(dl_ns)[ns]._ns_main_searchlist->r_nlist | |
364 | // XXX Check whether we need NS-specific initial_searchlist | |
365 | == GLRO(dl_initial_searchlist).r_nlist)) | |
366 | { | |
367 | /* All object dynamically loaded by the program are unloaded. Free | |
368 | the memory allocated for the global scope variable. */ | |
369 | struct link_map **old = GL(dl_ns)[ns]._ns_main_searchlist->r_list; | |
370 | ||
371 | /* Put the old map in. */ | |
372 | GL(dl_ns)[ns]._ns_main_searchlist->r_list | |
373 | // XXX Check whether we need NS-specific initial_searchlist | |
374 | = GLRO(dl_initial_searchlist).r_list; | |
375 | /* Signal that the original map is used. */ | |
376 | GL(dl_ns)[ns]._ns_global_scope_alloc = 0; | |
377 | ||
378 | /* Now free the old map. */ | |
379 | free (old); | |
09fad1a6 | 380 | } |
56801c50 AS |
381 | } |
382 | ||
d063d164 UD |
383 | /* Free the memory allocated for the dtv slotinfo array. We can do |
384 | this only if all modules which used this memory are unloaded. */ | |
56801c50 | 385 | #ifdef SHARED |
d063d164 UD |
386 | if (GL(dl_initial_dtv) == NULL) |
387 | /* There was no initial TLS setup, it was set up later when | |
388 | it used the normal malloc. */ | |
389 | free_slotinfo (&GL(dl_tls_dtv_slotinfo_list)); | |
390 | else | |
56801c50 | 391 | #endif |
d063d164 UD |
392 | /* The first element of the list does not have to be deallocated. |
393 | It was allocated in the dynamic linker (i.e., with a different | |
394 | malloc), and in the static library it's in .bss space. */ | |
395 | free_slotinfo (&GL(dl_tls_dtv_slotinfo_list)->next); | |
56801c50 AS |
396 | |
397 | void *scope_free_list = GL(dl_scope_free_list); | |
398 | GL(dl_scope_free_list) = NULL; | |
399 | free (scope_free_list); | |
752a2a50 | 400 | } |