1/* Handle loading and unloading shared objects for internal libc purposes.
2 Copyright (C) 1999-2017 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
24extern int __libc_argc attribute_hidden;
25extern char **__libc_argv attribute_hidden;
26
27extern 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
38static int
39internal_function
40dlerror_run (void (*operate) (void *), void *args)
41{
42 const char *objname;
43 const char *last_errstring = NULL;
44 bool malloced;
45
46 int result = (_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
58struct 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
71struct 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
82static void
83do_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
92static void
93do_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
102static void
103do_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. */
111struct 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
119extern struct dl_open_hook *_dl_open_hook;
120libc_hidden_proto (_dl_open_hook);
121struct dl_open_hook *_dl_open_hook __attribute__ ((nocommon));
122libc_hidden_data_def (_dl_open_hook);
123#else
124static void
125do_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
142static 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
152void *
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}
173libc_hidden_def (__libc_dlopen_mode)
174
175#ifndef SHARED
176void *
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
188void
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
199void *
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}
213libc_hidden_def (__libc_dlsym)
214
215int
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}
224libc_hidden_def (__libc_dlclose)
225
226
227static bool __libc_freeres_fn_section
228free_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
255libc_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