1 /* Handle loading and unloading shared objects for internal libc purposes.
2 Copyright (C) 1999-2013 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Zack Weinberg <zack@rabi.columbia.edu>, 1999.
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.
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.
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/>. */
24 extern int __libc_argc attribute_hidden;
25 extern char **__libc_argv attribute_hidden;
27 extern char **__environ;
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
36 Much of this code came from gconv_dl.c with slight modifications. */
40 dlerror_run (void (*operate) (void *), void *args)
43 const char *last_errstring = NULL;
46 int result = (GLRO(dl_catch_error) (&objname, &last_errstring, &malloced,
48 ?: last_errstring != NULL);
50 if (result && malloced)
51 free ((char *) last_errstring);
56 /* These functions are called by dlerror_run... */
60 /* Argument to do_dlopen. */
64 /* This is the caller of the dlopen() function. */
65 const void *caller_dlopen;
67 /* Return from do_dlopen. */
73 /* Arguments to do_dlsym. */
77 /* Return values of do_dlsym. */
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,
95 struct do_dlsym_args *args = (struct do_dlsym_args *) ptr;
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);
103 do_dlclose (void *ptr)
105 GLRO(dl_close) ((struct link_map *) ptr);
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. */
113 void *(*dlopen_mode) (const char *name, int mode);
114 void *(*dlsym) (void *map, const char *name);
115 int (*dlclose) (void *map);
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);
125 do_dlsym_private (void *ptr)
128 struct r_found_version vers;
129 vers.name = "GLIBC_PRIVATE";
131 /* vers.hash = _dl_elf_hash (vers.name); */
132 vers.hash = 0x0963cf85;
133 vers.filename = NULL;
135 struct do_dlsym_args *args = (struct do_dlsym_args *) ptr;
137 l = GLRO(dl_lookup_symbol_x) (args->name, args->map, &args->ref,
138 args->map->l_scope, &vers, 0, 0, NULL);
142 static struct dl_open_hook _dl_open_hook =
144 .dlopen_mode = __libc_dlopen_mode,
145 .dlsym = __libc_dlsym,
146 .dlclose = __libc_dlclose
150 /* ... and these functions call dlerror_run. */
153 __libc_dlopen_mode (const char *name, int mode)
155 struct do_dlopen_args args;
158 args.caller_dlopen = RETURN_ADDRESS (0);
161 if (__builtin_expect (_dl_open_hook != NULL, 0))
162 return _dl_open_hook->dlopen_mode (name, mode);
163 return (dlerror_run (do_dlopen, &args) ? NULL : (void *) args.map);
165 if (dlerror_run (do_dlopen, &args))
168 __libc_register_dl_open_hook (args.map);
169 __libc_register_dlfcn_hook (args.map);
170 return (void *) args.map;
173 libc_hidden_def (__libc_dlopen_mode)
177 __libc_dlsym_private (struct link_map *map, const char *name)
179 struct do_dlsym_args sargs;
183 if (! dlerror_run (do_dlsym_private, &sargs))
184 return DL_SYMBOL_ADDRESS (sargs.loadbase, sargs.ref);
189 __libc_register_dl_open_hook (struct link_map *map)
191 struct dl_open_hook **hook;
193 hook = (struct dl_open_hook **) __libc_dlsym_private (map, "_dl_open_hook");
195 *hook = &_dl_open_hook;
200 __libc_dlsym (void *map, const char *name)
202 struct do_dlsym_args args;
207 if (__builtin_expect (_dl_open_hook != NULL, 0))
208 return _dl_open_hook->dlsym (map, name);
210 return (dlerror_run (do_dlsym, &args) ? NULL
211 : (void *) (DL_SYMBOL_ADDRESS (args.loadbase, args.ref)));
213 libc_hidden_def (__libc_dlsym)
216 __libc_dlclose (void *map)
219 if (__builtin_expect (_dl_open_hook != NULL, 0))
220 return _dl_open_hook->dlclose (map);
222 return dlerror_run (do_dlclose, map);
224 libc_hidden_def (__libc_dlclose)
227 static bool __libc_freeres_fn_section
228 free_slotinfo (struct dtv_slotinfo_list **elemp)
233 /* Nothing here, all is removed (or there never was anything). */
236 if (!free_slotinfo (&(*elemp)->next))
237 /* We cannot free the entry. */
240 /* That cleared our next pointer for us. */
242 for (cnt = 0; cnt < (*elemp)->len; ++cnt)
243 if ((*elemp)->slotinfo[cnt].map != NULL)
247 /* We can remove the list element. */
255 libc_freeres_fn (free_mem)
258 struct r_search_path_elem *d;
260 /* Remove all search directories. */
262 while (d != GLRO(dl_init_all_dirs))
264 struct r_search_path_elem *old = d;
269 for (Lmid_t ns = 0; ns < GL(dl_nns); ++ns)
271 for (l = GL(dl_ns)[ns]._ns_loaded; l != NULL; l = l->l_next)
273 struct libname_list *lnp = l->l_libname->next;
275 l->l_libname->next = NULL;
277 /* Remove all additional names added to the objects. */
280 struct libname_list *old = lnp;
282 if (! old->dont_free)
286 /* Free the initfini dependency list. */
287 if (l->l_free_initfini)
288 free (l->l_initfini);
289 l->l_initfini = NULL;
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))
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;
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;
308 /* Now free the old map. */
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. */
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));
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);
327 void *scope_free_list = GL(dl_scope_free_list);
328 GL(dl_scope_free_list) = NULL;
329 free (scope_free_list);