1 | /* Handle loading and unloading shared objects for internal libc purposes. |
2 | Copyright (C) 1999-2016 Free Software Foundation, Inc. |
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 |
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. |
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 |
14 | Lesser General Public License for more details. |
15 | |
16 | You should have received a copy of the GNU Lesser General Public |
17 | License along with the GNU C Library; if not, see |
18 | <http://www.gnu.org/licenses/>. */ |
19 | |
20 | #include <dlfcn.h> |
21 | #include <stdlib.h> |
22 | #include <ldsodefs.h> |
23 | |
24 | extern int __libc_argc attribute_hidden; |
25 | extern char **__libc_argv attribute_hidden; |
26 | |
27 | extern char **__environ; |
28 | |
29 | /* The purpose of this file is to provide wrappers around the dynamic |
30 | linker error mechanism (similar to dlopen() et al in libdl) which |
31 | are usable from within libc. Generally we want to throw away the |
32 | string that dlerror() would return and just pass back a null pointer |
33 | for errors. This also lets the rest of libc not know about the error |
34 | handling mechanism. |
35 | |
36 | Much of this code came from gconv_dl.c with slight modifications. */ |
37 | |
38 | static int |
39 | internal_function |
40 | dlerror_run (void (*operate) (void *), void *args) |
41 | { |
42 | const char *objname; |
43 | const char *last_errstring = NULL; |
44 | bool malloced; |
45 | |
46 | int result = (GLRO(dl_catch_error) (&objname, &last_errstring, &malloced, |
47 | operate, args) |
48 | ?: last_errstring != NULL); |
49 | |
50 | if (result && malloced) |
51 | free ((char *) last_errstring); |
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; |
62 | /* Opening mode. */ |
63 | int mode; |
64 | /* This is the caller of the dlopen() function. */ |
65 | const void *caller_dlopen; |
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. */ |
78 | lookup_t loadbase; |
79 | const ElfW(Sym) *ref; |
80 | }; |
81 | |
82 | static void |
83 | do_dlopen (void *ptr) |
84 | { |
85 | struct do_dlopen_args *args = (struct do_dlopen_args *) ptr; |
86 | /* Open and relocate the shared object. */ |
87 | args->map = GLRO(dl_open) (args->name, args->mode, args->caller_dlopen, |
88 | __LM_ID_CALLER, __libc_argc, __libc_argv, |
89 | __environ); |
90 | } |
91 | |
92 | static void |
93 | do_dlsym (void *ptr) |
94 | { |
95 | struct do_dlsym_args *args = (struct do_dlsym_args *) ptr; |
96 | args->ref = NULL; |
97 | args->loadbase = GLRO(dl_lookup_symbol_x) (args->name, args->map, &args->ref, |
98 | args->map->l_local_scope, NULL, 0, |
99 | DL_LOOKUP_RETURN_NEWEST, NULL); |
100 | } |
101 | |
102 | static void |
103 | do_dlclose (void *ptr) |
104 | { |
105 | GLRO(dl_close) ((struct link_map *) ptr); |
106 | } |
107 | |
108 | /* This code is to support __libc_dlopen from __libc_dlopen'ed shared |
109 | libraries. We need to ensure the statically linked __libc_dlopen |
110 | etc. functions are used instead of the dynamically loaded. */ |
111 | struct dl_open_hook |
112 | { |
113 | void *(*dlopen_mode) (const char *name, int mode); |
114 | void *(*dlsym) (void *map, const char *name); |
115 | int (*dlclose) (void *map); |
116 | }; |
117 | |
118 | #ifdef SHARED |
119 | extern struct dl_open_hook *_dl_open_hook; |
120 | libc_hidden_proto (_dl_open_hook); |
121 | struct dl_open_hook *_dl_open_hook __attribute__ ((nocommon)); |
122 | libc_hidden_data_def (_dl_open_hook); |
123 | #else |
124 | static void |
125 | do_dlsym_private (void *ptr) |
126 | { |
127 | lookup_t l; |
128 | struct r_found_version vers; |
129 | vers.name = "GLIBC_PRIVATE" ; |
130 | vers.hidden = 1; |
131 | /* vers.hash = _dl_elf_hash (vers.name); */ |
132 | vers.hash = 0x0963cf85; |
133 | vers.filename = NULL; |
134 | |
135 | struct do_dlsym_args *args = (struct do_dlsym_args *) ptr; |
136 | args->ref = NULL; |
137 | l = GLRO(dl_lookup_symbol_x) (args->name, args->map, &args->ref, |
138 | args->map->l_scope, &vers, 0, 0, NULL); |
139 | args->loadbase = l; |
140 | } |
141 | |
142 | static struct dl_open_hook _dl_open_hook = |
143 | { |
144 | .dlopen_mode = __libc_dlopen_mode, |
145 | .dlsym = __libc_dlsym, |
146 | .dlclose = __libc_dlclose |
147 | }; |
148 | #endif |
149 | |
150 | /* ... and these functions call dlerror_run. */ |
151 | |
152 | void * |
153 | __libc_dlopen_mode (const char *name, int mode) |
154 | { |
155 | struct do_dlopen_args args; |
156 | args.name = name; |
157 | args.mode = mode; |
158 | args.caller_dlopen = RETURN_ADDRESS (0); |
159 | |
160 | #ifdef SHARED |
161 | if (__glibc_unlikely (_dl_open_hook != NULL)) |
162 | return _dl_open_hook->dlopen_mode (name, mode); |
163 | return (dlerror_run (do_dlopen, &args) ? NULL : (void *) args.map); |
164 | #else |
165 | if (dlerror_run (do_dlopen, &args)) |
166 | return NULL; |
167 | |
168 | __libc_register_dl_open_hook (args.map); |
169 | __libc_register_dlfcn_hook (args.map); |
170 | return (void *) args.map; |
171 | #endif |
172 | } |
173 | libc_hidden_def (__libc_dlopen_mode) |
174 | |
175 | #ifndef SHARED |
176 | void * |
177 | __libc_dlsym_private (struct link_map *map, const char *name) |
178 | { |
179 | struct do_dlsym_args sargs; |
180 | sargs.map = map; |
181 | sargs.name = name; |
182 | |
183 | if (! dlerror_run (do_dlsym_private, &sargs)) |
184 | return DL_SYMBOL_ADDRESS (sargs.loadbase, sargs.ref); |
185 | return NULL; |
186 | } |
187 | |
188 | void |
189 | __libc_register_dl_open_hook (struct link_map *map) |
190 | { |
191 | struct dl_open_hook **hook; |
192 | |
193 | hook = (struct dl_open_hook **) __libc_dlsym_private (map, "_dl_open_hook" ); |
194 | if (hook != NULL) |
195 | *hook = &_dl_open_hook; |
196 | } |
197 | #endif |
198 | |
199 | void * |
200 | __libc_dlsym (void *map, const char *name) |
201 | { |
202 | struct do_dlsym_args args; |
203 | args.map = map; |
204 | args.name = name; |
205 | |
206 | #ifdef SHARED |
207 | if (__glibc_unlikely (_dl_open_hook != NULL)) |
208 | return _dl_open_hook->dlsym (map, name); |
209 | #endif |
210 | return (dlerror_run (do_dlsym, &args) ? NULL |
211 | : (void *) (DL_SYMBOL_ADDRESS (args.loadbase, args.ref))); |
212 | } |
213 | libc_hidden_def (__libc_dlsym) |
214 | |
215 | int |
216 | __libc_dlclose (void *map) |
217 | { |
218 | #ifdef SHARED |
219 | if (__glibc_unlikely (_dl_open_hook != NULL)) |
220 | return _dl_open_hook->dlclose (map); |
221 | #endif |
222 | return dlerror_run (do_dlclose, map); |
223 | } |
224 | libc_hidden_def (__libc_dlclose) |
225 | |
226 | |
227 | static bool __libc_freeres_fn_section |
228 | free_slotinfo (struct dtv_slotinfo_list **elemp) |
229 | { |
230 | size_t cnt; |
231 | |
232 | if (*elemp == NULL) |
233 | /* Nothing here, all is removed (or there never was anything). */ |
234 | return true; |
235 | |
236 | if (!free_slotinfo (&(*elemp)->next)) |
237 | /* We cannot free the entry. */ |
238 | return false; |
239 | |
240 | /* That cleared our next pointer for us. */ |
241 | |
242 | for (cnt = 0; cnt < (*elemp)->len; ++cnt) |
243 | if ((*elemp)->slotinfo[cnt].map != NULL) |
244 | /* Still used. */ |
245 | return false; |
246 | |
247 | /* We can remove the list element. */ |
248 | free (*elemp); |
249 | *elemp = NULL; |
250 | |
251 | return true; |
252 | } |
253 | |
254 | |
255 | libc_freeres_fn (free_mem) |
256 | { |
257 | struct link_map *l; |
258 | struct r_search_path_elem *d; |
259 | |
260 | /* Remove all search directories. */ |
261 | d = GL(dl_all_dirs); |
262 | while (d != GLRO(dl_init_all_dirs)) |
263 | { |
264 | struct r_search_path_elem *old = d; |
265 | d = d->next; |
266 | free (old); |
267 | } |
268 | |
269 | for (Lmid_t ns = 0; ns < GL(dl_nns); ++ns) |
270 | { |
271 | for (l = GL(dl_ns)[ns]._ns_loaded; l != NULL; l = l->l_next) |
272 | { |
273 | struct libname_list *lnp = l->l_libname->next; |
274 | |
275 | l->l_libname->next = NULL; |
276 | |
277 | /* Remove all additional names added to the objects. */ |
278 | while (lnp != NULL) |
279 | { |
280 | struct libname_list *old = lnp; |
281 | lnp = lnp->next; |
282 | if (! old->dont_free) |
283 | free (old); |
284 | } |
285 | |
286 | /* Free the initfini dependency list. */ |
287 | if (l->l_free_initfini) |
288 | free (l->l_initfini); |
289 | l->l_initfini = NULL; |
290 | } |
291 | |
292 | if (__builtin_expect (GL(dl_ns)[ns]._ns_global_scope_alloc, 0) != 0 |
293 | && (GL(dl_ns)[ns]._ns_main_searchlist->r_nlist |
294 | // XXX Check whether we need NS-specific initial_searchlist |
295 | == GLRO(dl_initial_searchlist).r_nlist)) |
296 | { |
297 | /* All object dynamically loaded by the program are unloaded. Free |
298 | the memory allocated for the global scope variable. */ |
299 | struct link_map **old = GL(dl_ns)[ns]._ns_main_searchlist->r_list; |
300 | |
301 | /* Put the old map in. */ |
302 | GL(dl_ns)[ns]._ns_main_searchlist->r_list |
303 | // XXX Check whether we need NS-specific initial_searchlist |
304 | = GLRO(dl_initial_searchlist).r_list; |
305 | /* Signal that the original map is used. */ |
306 | GL(dl_ns)[ns]._ns_global_scope_alloc = 0; |
307 | |
308 | /* Now free the old map. */ |
309 | free (old); |
310 | } |
311 | } |
312 | |
313 | /* Free the memory allocated for the dtv slotinfo array. We can do |
314 | this only if all modules which used this memory are unloaded. */ |
315 | #ifdef SHARED |
316 | if (GL(dl_initial_dtv) == NULL) |
317 | /* There was no initial TLS setup, it was set up later when |
318 | it used the normal malloc. */ |
319 | free_slotinfo (&GL(dl_tls_dtv_slotinfo_list)); |
320 | else |
321 | #endif |
322 | /* The first element of the list does not have to be deallocated. |
323 | It was allocated in the dynamic linker (i.e., with a different |
324 | malloc), and in the static library it's in .bss space. */ |
325 | free_slotinfo (&GL(dl_tls_dtv_slotinfo_list)->next); |
326 | |
327 | void *scope_free_list = GL(dl_scope_free_list); |
328 | GL(dl_scope_free_list) = NULL; |
329 | free (scope_free_list); |
330 | } |
331 | |