1/* Handle loading and unloading shared objects for internal libc purposes.
2 Copyright (C) 1999-2020 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 <https://www.gnu.org/licenses/>. */
19
20#include <dlfcn.h>
21#include <stdlib.h>
22#include <ldsodefs.h>
23#include <dl-hash.h>
24
25extern int __libc_argc attribute_hidden;
26extern char **__libc_argv attribute_hidden;
27
28extern char **__environ;
29
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
39static int
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
82struct 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
91static void
92do_dlopen (void *ptr)
93{
94 struct do_dlopen_args *args = (struct do_dlopen_args *) ptr;
95 /* Open and relocate the shared object. */
96 args->map = GLRO(dl_open) (args->name, args->mode, args->caller_dlopen,
97 __LM_ID_CALLER, __libc_argc, __libc_argv,
98 __environ);
99}
100
101static void
102do_dlsym (void *ptr)
103{
104 struct do_dlsym_args *args = (struct do_dlsym_args *) ptr;
105 args->ref = NULL;
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);
109}
110
111static void
112do_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
123static void
124do_dlclose (void *ptr)
125{
126 GLRO(dl_close) ((struct link_map *) ptr);
127}
128
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. */
132struct 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);
137 void *(*dlvsym) (void *map, const char *name, const char *version);
138};
139
140#ifdef SHARED
141extern struct dl_open_hook *_dl_open_hook;
142libc_hidden_proto (_dl_open_hook);
143struct dl_open_hook *_dl_open_hook __attribute__ ((nocommon));
144libc_hidden_data_def (_dl_open_hook);
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. */
149extern struct dl_open_hook *_dl_open_hook2;
150libc_hidden_proto (_dl_open_hook2);
151struct dl_open_hook *_dl_open_hook2 __attribute__ ((nocommon));
152libc_hidden_data_def (_dl_open_hook2);
153
154#else
155static void
156do_dlsym_private (void *ptr)
157{
158 lookup_t l;
159 struct r_found_version vers;
160 vers.name = "GLIBC_PRIVATE";
161 vers.hidden = 1;
162 /* vers.hash = _dl_elf_hash (vers.name); */
163 vers.hash = 0x0963cf85;
164 vers.filename = NULL;
165
166 struct do_dlsym_args *args = (struct do_dlsym_args *) ptr;
167 args->ref = NULL;
168 l = GLRO(dl_lookup_symbol_x) (args->name, args->map, &args->ref,
169 args->map->l_scope, &vers, 0, 0, NULL);
170 args->loadbase = l;
171}
172
173static struct dl_open_hook _dl_open_hook =
174 {
175 .dlopen_mode = __libc_dlopen_mode,
176 .dlsym = __libc_dlsym,
177 .dlclose = __libc_dlclose,
178 .dlvsym = __libc_dlvsym,
179 };
180#endif
181
182/* ... and these functions call dlerror_run. */
183
184void *
185__libc_dlopen_mode (const char *name, int mode)
186{
187 struct do_dlopen_args args;
188 args.name = name;
189 args.mode = mode;
190 args.caller_dlopen = RETURN_ADDRESS (0);
191
192#ifdef SHARED
193 if (!rtld_active ())
194 return _dl_open_hook->dlopen_mode (name, mode);
195 return (dlerror_run (do_dlopen, &args) ? NULL : (void *) args.map);
196#else
197 if (dlerror_run (do_dlopen, &args))
198 return NULL;
199
200 __libc_register_dl_open_hook (args.map);
201 __libc_register_dlfcn_hook (args.map);
202 return (void *) args.map;
203#endif
204}
205libc_hidden_def (__libc_dlopen_mode)
206
207#ifndef SHARED
208void *
209__libc_dlsym_private (struct link_map *map, const char *name)
210{
211 struct do_dlsym_args sargs;
212 sargs.map = map;
213 sargs.name = name;
214
215 if (! dlerror_run (do_dlsym_private, &sargs))
216 return DL_SYMBOL_ADDRESS (sargs.loadbase, sargs.ref);
217 return NULL;
218}
219
220void
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;
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;
233}
234#endif
235
236void *
237__libc_dlsym (void *map, const char *name)
238{
239 struct do_dlsym_args args;
240 args.map = map;
241 args.name = name;
242
243#ifdef SHARED
244 if (!rtld_active ())
245 return _dl_open_hook->dlsym (map, name);
246#endif
247 return (dlerror_run (do_dlsym, &args) ? NULL
248 : (void *) (DL_SYMBOL_ADDRESS (args.loadbase, args.ref)));
249}
250libc_hidden_def (__libc_dlsym)
251
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. */
255void *
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}
283libc_hidden_def (__libc_dlvsym)
284
285int
286__libc_dlclose (void *map)
287{
288#ifdef SHARED
289 if (!rtld_active ())
290 return _dl_open_hook->dlclose (map);
291#endif
292 return dlerror_run (do_dlclose, map);
293}
294libc_hidden_def (__libc_dlclose)
295
296
297static bool __libc_freeres_fn_section
298free_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
325libc_freeres_fn (free_mem)
326{
327 struct link_map *l;
328 struct r_search_path_elem *d;
329
330 /* Remove all search directories. */
331 d = GL(dl_all_dirs);
332 while (d != GLRO(dl_init_all_dirs))
333 {
334 struct r_search_path_elem *old = d;
335 d = d->next;
336 free (old);
337 }
338
339 for (Lmid_t ns = 0; ns < GL(dl_nns); ++ns)
340 {
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
347 /* Remove all additional names added to the objects. */
348 while (lnp != NULL)
349 {
350 struct libname_list *old = lnp;
351 lnp = lnp->next;
352 if (! old->dont_free)
353 free (old);
354 }
355
356 /* Free the initfini dependency list. */
357 if (l->l_free_initfini)
358 free (l->l_initfini);
359 l->l_initfini = NULL;
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);
380 }
381 }
382
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. */
385#ifdef SHARED
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
391#endif
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);
396
397 void *scope_free_list = GL(dl_scope_free_list);
398 GL(dl_scope_free_list) = NULL;
399 free (scope_free_list);
400}
401