regexp.h: update Versions to match file usage [BZ #18681]
[glibc.git] / elf / dl-libc.c
blobdf2732425adc5c54a709d19a032e66d73b9b9dba
1 /* Handle loading and unloading shared objects for internal libc purposes.
2 Copyright (C) 1999-2015 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/>. */
20 #include <dlfcn.h>
21 #include <stdlib.h>
22 #include <ldsodefs.h>
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
34 handling mechanism.
36 Much of this code came from gconv_dl.c with slight modifications. */
38 static int
39 internal_function
40 dlerror_run (void (*operate) (void *), void *args)
42 const char *objname;
43 const char *last_errstring = NULL;
44 bool malloced;
46 int result = (GLRO(dl_catch_error) (&objname, &last_errstring, &malloced,
47 operate, args)
48 ?: last_errstring != NULL);
50 if (result && malloced)
51 free ((char *) last_errstring);
53 return result;
56 /* These functions are called by dlerror_run... */
58 struct do_dlopen_args
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;
67 /* Return from do_dlopen. */
68 struct link_map *map;
71 struct do_dlsym_args
73 /* Arguments to do_dlsym. */
74 struct link_map *map;
75 const char *name;
77 /* Return values of do_dlsym. */
78 lookup_t loadbase;
79 const ElfW(Sym) *ref;
82 static void
83 do_dlopen (void *ptr)
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);
92 static void
93 do_dlsym (void *ptr)
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);
102 static void
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. */
111 struct dl_open_hook
113 void *(*dlopen_mode) (const char *name, int mode);
114 void *(*dlsym) (void *map, const char *name);
115 int (*dlclose) (void *map);
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)
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;
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;
142 static struct dl_open_hook _dl_open_hook =
144 .dlopen_mode = __libc_dlopen_mode,
145 .dlsym = __libc_dlsym,
146 .dlclose = __libc_dlclose
148 #endif
150 /* ... and these functions call dlerror_run. */
152 void *
153 __libc_dlopen_mode (const char *name, int mode)
155 struct do_dlopen_args args;
156 args.name = name;
157 args.mode = mode;
158 args.caller_dlopen = RETURN_ADDRESS (0);
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;
168 __libc_register_dl_open_hook (args.map);
169 __libc_register_dlfcn_hook (args.map);
170 return (void *) args.map;
171 #endif
173 libc_hidden_def (__libc_dlopen_mode)
175 #ifndef SHARED
176 void *
177 __libc_dlsym_private (struct link_map *map, const char *name)
179 struct do_dlsym_args sargs;
180 sargs.map = map;
181 sargs.name = name;
183 if (! dlerror_run (do_dlsym_private, &sargs))
184 return DL_SYMBOL_ADDRESS (sargs.loadbase, sargs.ref);
185 return NULL;
188 void
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");
194 if (hook != NULL)
195 *hook = &_dl_open_hook;
197 #endif
199 void *
200 __libc_dlsym (void *map, const char *name)
202 struct do_dlsym_args args;
203 args.map = map;
204 args.name = name;
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)));
213 libc_hidden_def (__libc_dlsym)
216 __libc_dlclose (void *map)
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);
224 libc_hidden_def (__libc_dlclose)
227 static bool __libc_freeres_fn_section
228 free_slotinfo (struct dtv_slotinfo_list **elemp)
230 size_t cnt;
232 if (*elemp == NULL)
233 /* Nothing here, all is removed (or there never was anything). */
234 return true;
236 if (!free_slotinfo (&(*elemp)->next))
237 /* We cannot free the entry. */
238 return false;
240 /* That cleared our next pointer for us. */
242 for (cnt = 0; cnt < (*elemp)->len; ++cnt)
243 if ((*elemp)->slotinfo[cnt].map != NULL)
244 /* Still used. */
245 return false;
247 /* We can remove the list element. */
248 free (*elemp);
249 *elemp = NULL;
251 return true;
255 libc_freeres_fn (free_mem)
257 struct link_map *l;
258 struct r_search_path_elem *d;
260 /* Remove all search directories. */
261 d = GL(dl_all_dirs);
262 while (d != GLRO(dl_init_all_dirs))
264 struct r_search_path_elem *old = d;
265 d = d->next;
266 free (old);
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. */
278 while (lnp != NULL)
280 struct libname_list *old = lnp;
281 lnp = lnp->next;
282 if (! old->dont_free)
283 free (old);
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. */
309 free (old);
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);
327 void *scope_free_list = GL(dl_scope_free_list);
328 GL(dl_scope_free_list) = NULL;
329 free (scope_free_list);