1 /* Handle loading and unloading shared objects for internal libc purposes.
2 Copyright (C) 1999-2023 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <https://www.gnu.org/licenses/>. */
18
19 #include <dlfcn.h>
20 #include <stdlib.h>
21 #include <ldsodefs.h>
22 #include <dl-hash.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 dlerror_run (void (*operate) (void *), void *args)
40 {
41 const char *objname;
42 const char *last_errstring = NULL;
43 bool malloced;
44
45 int result = (GLRO (dl_catch_error) (&objname, &last_errstring, &malloced,
46 operate, args)
47 ?: last_errstring != NULL);
48
49 if (result && malloced)
50 GLRO (dl_error_free) ((char *) last_errstring);
51
52 return result;
53 }
54
55 /* These functions are called by dlerror_run... */
56
57 struct do_dlopen_args
58 {
59 /* Argument to do_dlopen. */
60 const char *name;
61 /* Opening mode. */
62 int mode;
63 /* This is the caller of the dlopen() function. */
64 const void *caller_dlopen;
65
66 /* Return from do_dlopen. */
67 struct link_map *map;
68 };
69
70 struct do_dlsym_args
71 {
72 /* Arguments to do_dlsym. */
73 struct link_map *map;
74 const char *name;
75
76 /* Return values of do_dlsym. */
77 lookup_t loadbase;
78 const ElfW(Sym) *ref;
79 };
80
81 struct do_dlvsym_args
82 {
83 /* dlvsym is like dlsym. */
84 struct do_dlsym_args dlsym;
85
86 /* But dlvsym needs a version as well. */
87 struct r_found_version version;
88 };
89
90 static void
91 do_dlopen (void *ptr)
92 {
93 struct do_dlopen_args *args = (struct do_dlopen_args *) ptr;
94 /* Open and relocate the shared object. */
95 args->map = GLRO(dl_open) (args->name, args->mode, args->caller_dlopen,
96 __LM_ID_CALLER, __libc_argc, __libc_argv,
97 __environ);
98 }
99
100 static void
101 do_dlsym (void *ptr)
102 {
103 struct do_dlsym_args *args = (struct do_dlsym_args *) ptr;
104 args->ref = NULL;
105 args->loadbase = GLRO(dl_lookup_symbol_x) (args->name, args->map, &args->ref,
106 args->map->l_local_scope, NULL, 0,
107 DL_LOOKUP_RETURN_NEWEST, NULL);
108 }
109
110 static void
111 do_dlvsym (void *ptr)
112 {
113 struct do_dlvsym_args *args = ptr;
114 args->dlsym.ref = NULL;
115 args->dlsym.loadbase
116 = GLRO(dl_lookup_symbol_x) (args->dlsym.name, args->dlsym.map,
117 &args->dlsym.ref,
118 args->dlsym.map->l_local_scope,
119 &args->version, 0, 0, NULL);
120 }
121
122 static void
123 do_dlclose (void *ptr)
124 {
125 GLRO(dl_close) ((struct link_map *) ptr);
126 }
127
128 #ifndef SHARED
129 static void
130 do_dlsym_private (void *ptr)
131 {
132 lookup_t l;
133 struct r_found_version vers;
134 vers.name = "GLIBC_PRIVATE";
135 vers.hidden = 1;
136 /* vers.hash = _dl_elf_hash (vers.name); */
137 vers.hash = 0x0963cf85;
138 vers.filename = NULL;
139
140 struct do_dlsym_args *args = (struct do_dlsym_args *) ptr;
141 args->ref = NULL;
142 l = GLRO(dl_lookup_symbol_x) (args->name, args->map, &args->ref,
143 args->map->l_scope, &vers, 0, 0, NULL);
144 args->loadbase = l;
145 }
146 #endif
147
148 /* ... and these functions call dlerror_run. */
149
150 void *
151 __libc_dlopen_mode (const char *name, int mode)
152 {
153 struct do_dlopen_args args;
154 args.name = name;
155 args.mode = mode;
156 args.caller_dlopen = RETURN_ADDRESS (0);
157
158 #ifdef SHARED
159 if (GLRO (dl_dlfcn_hook) != NULL)
160 return GLRO (dl_dlfcn_hook)->libc_dlopen_mode (name, mode);
161 #endif
162 return dlerror_run (do_dlopen, &args) ? NULL : (void *) args.map;
163 }
164
165 #ifndef SHARED
166 void *
167 __libc_dlsym_private (struct link_map *map, const char *name)
168 {
169 struct do_dlsym_args sargs;
170 sargs.map = map;
171 sargs.name = name;
172
173 if (! dlerror_run (do_dlsym_private, &sargs))
174 return DL_SYMBOL_ADDRESS (sargs.loadbase, sargs.ref);
175 return NULL;
176 }
177 #endif
178
179 void *
180 __libc_dlsym (void *map, const char *name)
181 {
182 struct do_dlsym_args args;
183 args.map = map;
184 args.name = name;
185
186 #ifdef SHARED
187 if (GLRO (dl_dlfcn_hook) != NULL)
188 return GLRO (dl_dlfcn_hook)->libc_dlsym (map, name);
189 #endif
190 return (dlerror_run (do_dlsym, &args) ? NULL
191 : (void *) (DL_SYMBOL_ADDRESS (args.loadbase, args.ref)));
192 }
193
194 /* Replacement for dlvsym. MAP must be a real map. This function
195 returns NULL without setting the dlerror value in case of static
196 dlopen from an old binary. */
197 void *
198 __libc_dlvsym (void *map, const char *name, const char *version)
199 {
200 #ifdef SHARED
201 if (GLRO (dl_dlfcn_hook) != NULL)
202 return GLRO (dl_dlfcn_hook)->libc_dlvsym (map, name, version);
203 #endif
204
205 struct do_dlvsym_args args;
206 args.dlsym.map = map;
207 args.dlsym.name = name;
208
209 /* See _dl_vsym in dl-sym.c. */
210 args.version.name = version;
211 args.version.hidden = 1;
212 args.version.hash = _dl_elf_hash (version);
213 args.version.filename = NULL;
214
215 return (dlerror_run (do_dlvsym, &args) ? NULL
216 : (void *) (DL_SYMBOL_ADDRESS (args.dlsym.loadbase,
217 args.dlsym.ref)));
218 }
219
220 int
221 __libc_dlclose (void *map)
222 {
223 #ifdef SHARED
224 if (GLRO (dl_dlfcn_hook) != NULL)
225 return GLRO (dl_dlfcn_hook)->libc_dlclose (map);
226 #endif
227 return dlerror_run (do_dlclose, map);
228 }
229
230
231 static bool
232 free_slotinfo (struct dtv_slotinfo_list **elemp)
233 {
234 size_t cnt;
235
236 if (*elemp == NULL)
237 /* Nothing here, all is removed (or there never was anything). */
238 return true;
239
240 if (!free_slotinfo (&(*elemp)->next))
241 /* We cannot free the entry. */
242 return false;
243
244 /* That cleared our next pointer for us. */
245
246 for (cnt = 0; cnt < (*elemp)->len; ++cnt)
247 if ((*elemp)->slotinfo[cnt].map != NULL)
248 /* Still used. */
249 return false;
250
251 /* We can remove the list element. */
252 free (*elemp);
253 *elemp = NULL;
254
255 return true;
256 }
257
258
259 void
260 __dl_libc_freemem (void)
261 {
262 struct link_map *l;
263 struct r_search_path_elem *d;
264
265 /* Remove all search directories. */
266 d = GL(dl_all_dirs);
267 while (d != GLRO(dl_init_all_dirs))
268 {
269 struct r_search_path_elem *old = d;
270 d = d->next;
271 free (old);
272 }
273
274 for (Lmid_t ns = 0; ns < GL(dl_nns); ++ns)
275 {
276 for (l = GL(dl_ns)[ns]._ns_loaded; l != NULL; l = l->l_next)
277 {
278 struct libname_list *lnp = l->l_libname->next;
279
280 l->l_libname->next = NULL;
281
282 /* Remove all additional names added to the objects. */
283 while (lnp != NULL)
284 {
285 struct libname_list *old = lnp;
286 lnp = lnp->next;
287 if (! old->dont_free)
288 free (old);
289 }
290
291 /* Free the initfini dependency list. */
292 if (l->l_free_initfini)
293 free (l->l_initfini);
294 l->l_initfini = NULL;
295 }
296
297 if (__builtin_expect (GL(dl_ns)[ns]._ns_global_scope_alloc, 0) != 0
298 && (GL(dl_ns)[ns]._ns_main_searchlist->r_nlist
299 // XXX Check whether we need NS-specific initial_searchlist
300 == GLRO(dl_initial_searchlist).r_nlist))
301 {
302 /* All object dynamically loaded by the program are unloaded. Free
303 the memory allocated for the global scope variable. */
304 struct link_map **old = GL(dl_ns)[ns]._ns_main_searchlist->r_list;
305
306 /* Put the old map in. */
307 GL(dl_ns)[ns]._ns_main_searchlist->r_list
308 // XXX Check whether we need NS-specific initial_searchlist
309 = GLRO(dl_initial_searchlist).r_list;
310 /* Signal that the original map is used. */
311 GL(dl_ns)[ns]._ns_global_scope_alloc = 0;
312
313 /* Now free the old map. */
314 free (old);
315 }
316 }
317
318 /* Free the memory allocated for the dtv slotinfo array. We can do
319 this only if all modules which used this memory are unloaded. */
320 #ifdef SHARED
321 if (GL(dl_initial_dtv) == NULL)
322 /* There was no initial TLS setup, it was set up later when
323 it used the normal malloc. */
324 free_slotinfo (&GL(dl_tls_dtv_slotinfo_list));
325 else
326 #endif
327 /* The first element of the list does not have to be deallocated.
328 It was allocated in the dynamic linker (i.e., with a different
329 malloc), and in the static library it's in .bss space. */
330 free_slotinfo (&GL(dl_tls_dtv_slotinfo_list)->next);
331
332 void *scope_free_list = GL(dl_scope_free_list);
333 GL(dl_scope_free_list) = NULL;
334 free (scope_free_list);
335 }