]>
Commit | Line | Data |
---|---|---|
266180eb | 1 | /* Load a shared object at runtime, relocate it, and run its initializer. |
581c785b | 2 | Copyright (C) 1996-2022 Free Software Foundation, Inc. |
afd4eb37 UD |
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 | |
41bdb6e2 AJ |
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. | |
afd4eb37 UD |
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 | |
41bdb6e2 | 13 | Lesser General Public License for more details. |
afd4eb37 | 14 | |
41bdb6e2 | 15 | You should have received a copy of the GNU Lesser General Public |
59ba27a6 | 16 | License along with the GNU C Library; if not, see |
5a82c748 | 17 | <https://www.gnu.org/licenses/>. */ |
266180eb | 18 | |
dc5efe83 | 19 | #include <assert.h> |
266180eb | 20 | #include <dlfcn.h> |
ba79d61b | 21 | #include <errno.h> |
06535ae9 | 22 | #include <libintl.h> |
b209e34a | 23 | #include <stdio.h> |
a853022c | 24 | #include <stdlib.h> |
7a68c94a | 25 | #include <string.h> |
06535ae9 | 26 | #include <unistd.h> |
08cac4ac | 27 | #include <sys/mman.h> /* Check whether MAP_COPY is defined. */ |
dc5efe83 | 28 | #include <sys/param.h> |
ec999b8e | 29 | #include <libc-lock.h> |
a42195db | 30 | #include <ldsodefs.h> |
609cf614 | 31 | #include <sysdep-cancel.h> |
df94b641 | 32 | #include <tls.h> |
815e6fa3 | 33 | #include <stap-probe.h> |
5908bf46 | 34 | #include <atomic.h> |
54e4b8f2 | 35 | #include <libc-internal.h> |
a509eb11 | 36 | #include <array_length.h> |
ec935dea | 37 | #include <libc-early-init.h> |
78b31cc8 | 38 | #include <gnu/lib-names.h> |
5d28a896 | 39 | #include <dl-find_object.h> |
ba79d61b | 40 | |
dc5efe83 | 41 | #include <dl-dst.h> |
f753fa7d | 42 | #include <dl-prop.h> |
dc5efe83 | 43 | |
39778c6c | 44 | |
05d723ab | 45 | /* We must be careful not to leave us in an inconsistent state. Thus we |
7a68c94a UD |
46 | catch any error and re-raise it after cleaning up. */ |
47 | ||
48 | struct dl_open_args | |
266180eb | 49 | { |
7a68c94a UD |
50 | const char *file; |
51 | int mode; | |
f213ef02 UD |
52 | /* This is the caller of the dlopen() function. */ |
53 | const void *caller_dlopen; | |
7a68c94a | 54 | struct link_map *map; |
c0f62c56 UD |
55 | /* Namespace ID. */ |
56 | Lmid_t nsid; | |
440b7f86 FW |
57 | |
58 | /* Original value of _ns_global_scope_pending_adds. Set by | |
59 | dl_open_worker. Only valid if nsid is a real namespace | |
60 | (non-negative). */ | |
61 | unsigned int original_global_scope_pending_adds; | |
62 | ||
ec935dea FW |
63 | /* Set to true by dl_open_worker if libc.so was already loaded into |
64 | the namespace at the time dl_open_worker was called. This is | |
65 | used to determine whether libc.so early initialization has | |
66 | already been done before, and whether to roll back the cached | |
67 | libc_map value in the namespace in case of a dlopen failure. */ | |
68 | bool libc_already_loaded; | |
69 | ||
83b53232 SN |
70 | /* Set to true if the end of dl_open_worker_begin was reached. */ |
71 | bool worker_continue; | |
72 | ||
9dcafc55 UD |
73 | /* Original parameters to the program and the current environment. */ |
74 | int argc; | |
75 | char **argv; | |
76 | char **env; | |
7a68c94a UD |
77 | }; |
78 | ||
440b7f86 FW |
79 | /* Called in case the global scope cannot be extended. */ |
80 | static void __attribute__ ((noreturn)) | |
81 | add_to_global_resize_failure (struct link_map *new) | |
82 | { | |
83 | _dl_signal_error (ENOMEM, new->l_libname->name, NULL, | |
84 | N_ ("cannot extend global scope")); | |
85 | } | |
d785c366 | 86 | |
440b7f86 FW |
87 | /* Grow the global scope array for the namespace, so that all the new |
88 | global objects can be added later in add_to_global_update, without | |
89 | risk of memory allocation failure. add_to_global_resize raises | |
90 | exceptions for memory allocation errors. */ | |
91 | static void | |
92 | add_to_global_resize (struct link_map *new) | |
d785c366 | 93 | { |
440b7f86 | 94 | struct link_namespaces *ns = &GL (dl_ns)[new->l_ns]; |
d785c366 UD |
95 | |
96 | /* Count the objects we have to put in the global scope. */ | |
440b7f86 FW |
97 | unsigned int to_add = 0; |
98 | for (unsigned int cnt = 0; cnt < new->l_searchlist.r_nlist; ++cnt) | |
d785c366 UD |
99 | if (new->l_searchlist.r_list[cnt]->l_global == 0) |
100 | ++to_add; | |
101 | ||
102 | /* The symbols of the new objects and its dependencies are to be | |
103 | introduced into the global scope that will be used to resolve | |
104 | references from other dynamically-loaded objects. | |
105 | ||
106 | The global scope is the searchlist in the main link map. We | |
107 | extend this list if necessary. There is one problem though: | |
108 | since this structure was allocated very early (before the libc | |
109 | is loaded) the memory it uses is allocated by the malloc()-stub | |
110 | in the ld.so. When we come here these functions are not used | |
111 | anymore. Instead the malloc() implementation of the libc is | |
112 | used. But this means the block from the main map cannot be used | |
113 | in an realloc() call. Therefore we allocate a completely new | |
114 | array the first time we have to add something to the locale scope. */ | |
115 | ||
440b7f86 FW |
116 | if (__builtin_add_overflow (ns->_ns_global_scope_pending_adds, to_add, |
117 | &ns->_ns_global_scope_pending_adds)) | |
118 | add_to_global_resize_failure (new); | |
119 | ||
120 | unsigned int new_size = 0; /* 0 means no new allocation. */ | |
121 | void *old_global = NULL; /* Old allocation if free-able. */ | |
122 | ||
123 | /* Minimum required element count for resizing. Adjusted below for | |
124 | an exponential resizing policy. */ | |
125 | size_t required_new_size; | |
126 | if (__builtin_add_overflow (ns->_ns_main_searchlist->r_nlist, | |
127 | ns->_ns_global_scope_pending_adds, | |
128 | &required_new_size)) | |
129 | add_to_global_resize_failure (new); | |
130 | ||
d65ef3dd | 131 | if (ns->_ns_global_scope_alloc == 0) |
d785c366 | 132 | { |
440b7f86 FW |
133 | if (__builtin_add_overflow (required_new_size, 8, &new_size)) |
134 | add_to_global_resize_failure (new); | |
135 | } | |
136 | else if (required_new_size > ns->_ns_global_scope_alloc) | |
137 | { | |
138 | if (__builtin_mul_overflow (required_new_size, 2, &new_size)) | |
139 | add_to_global_resize_failure (new); | |
d785c366 | 140 | |
440b7f86 FW |
141 | /* The old array was allocated with our malloc, not the minimal |
142 | malloc. */ | |
143 | old_global = ns->_ns_main_searchlist->r_list; | |
d785c366 | 144 | } |
440b7f86 FW |
145 | |
146 | if (new_size > 0) | |
d785c366 | 147 | { |
440b7f86 FW |
148 | size_t allocation_size; |
149 | if (__builtin_mul_overflow (new_size, sizeof (struct link_map *), | |
150 | &allocation_size)) | |
151 | add_to_global_resize_failure (new); | |
152 | struct link_map **new_global = malloc (allocation_size); | |
d785c366 | 153 | if (new_global == NULL) |
440b7f86 | 154 | add_to_global_resize_failure (new); |
d785c366 | 155 | |
440b7f86 FW |
156 | /* Copy over the old entries. */ |
157 | memcpy (new_global, ns->_ns_main_searchlist->r_list, | |
158 | ns->_ns_main_searchlist->r_nlist * sizeof (struct link_map *)); | |
df94b641 | 159 | |
440b7f86 | 160 | ns->_ns_global_scope_alloc = new_size; |
d65ef3dd | 161 | ns->_ns_main_searchlist->r_list = new_global; |
df94b641 UD |
162 | |
163 | if (!RTLD_SINGLE_THREAD_P) | |
164 | THREAD_GSCOPE_WAIT (); | |
165 | ||
166 | free (old_global); | |
d785c366 | 167 | } |
440b7f86 FW |
168 | } |
169 | ||
170 | /* Actually add the new global objects to the global scope. Must be | |
171 | called after add_to_global_resize. This function cannot fail. */ | |
172 | static void | |
173 | add_to_global_update (struct link_map *new) | |
174 | { | |
175 | struct link_namespaces *ns = &GL (dl_ns)[new->l_ns]; | |
d785c366 UD |
176 | |
177 | /* Now add the new entries. */ | |
9b0d1c02 | 178 | unsigned int new_nlist = ns->_ns_main_searchlist->r_nlist; |
440b7f86 | 179 | for (unsigned int cnt = 0; cnt < new->l_searchlist.r_nlist; ++cnt) |
d785c366 UD |
180 | { |
181 | struct link_map *map = new->l_searchlist.r_list[cnt]; | |
182 | ||
183 | if (map->l_global == 0) | |
184 | { | |
185 | map->l_global = 1; | |
440b7f86 FW |
186 | |
187 | /* The array has been resized by add_to_global_resize. */ | |
188 | assert (new_nlist < ns->_ns_global_scope_alloc); | |
189 | ||
9b0d1c02 | 190 | ns->_ns_main_searchlist->r_list[new_nlist++] = map; |
49c74ba9 UD |
191 | |
192 | /* We modify the global scope. Report this. */ | |
a1ffb40e | 193 | if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_SCOPES)) |
49c74ba9 UD |
194 | _dl_debug_printf ("\nadd %s [%lu] to global scope\n", |
195 | map->l_name, map->l_ns); | |
d785c366 UD |
196 | } |
197 | } | |
440b7f86 FW |
198 | |
199 | /* Some of the pending adds have been performed by the loop above. | |
200 | Adjust the counter accordingly. */ | |
201 | unsigned int added = new_nlist - ns->_ns_main_searchlist->r_nlist; | |
202 | assert (added <= ns->_ns_global_scope_pending_adds); | |
203 | ns->_ns_global_scope_pending_adds -= added; | |
204 | ||
d65ef3dd | 205 | atomic_write_barrier (); |
9b0d1c02 | 206 | ns->_ns_main_searchlist->r_nlist = new_nlist; |
d785c366 UD |
207 | } |
208 | ||
382466e0 | 209 | /* Search link maps in all namespaces for the DSO that contains the object at |
be179c8a SP |
210 | address ADDR. Returns the pointer to the link map of the matching DSO, or |
211 | NULL if a match is not found. */ | |
212 | struct link_map * | |
be179c8a SP |
213 | _dl_find_dso_for_object (const ElfW(Addr) addr) |
214 | { | |
215 | struct link_map *l; | |
216 | ||
217 | /* Find the highest-addressed object that ADDR is not below. */ | |
218 | for (Lmid_t ns = 0; ns < GL(dl_nns); ++ns) | |
219 | for (l = GL(dl_ns)[ns]._ns_loaded; l != NULL; l = l->l_next) | |
220 | if (addr >= l->l_map_start && addr < l->l_map_end | |
221 | && (l->l_contiguous | |
222 | || _dl_addr_inside_object (l, (ElfW(Addr)) addr))) | |
223 | { | |
224 | assert (ns == l->l_ns); | |
225 | return l; | |
226 | } | |
227 | return NULL; | |
228 | } | |
229 | rtld_hidden_def (_dl_find_dso_for_object); | |
230 | ||
a509eb11 FW |
231 | /* Return true if NEW is found in the scope for MAP. */ |
232 | static size_t | |
233 | scope_has_map (struct link_map *map, struct link_map *new) | |
234 | { | |
235 | size_t cnt; | |
236 | for (cnt = 0; map->l_scope[cnt] != NULL; ++cnt) | |
237 | if (map->l_scope[cnt] == &new->l_searchlist) | |
238 | return true; | |
239 | return false; | |
240 | } | |
241 | ||
242 | /* Return the length of the scope for MAP. */ | |
243 | static size_t | |
244 | scope_size (struct link_map *map) | |
245 | { | |
246 | size_t cnt; | |
247 | for (cnt = 0; map->l_scope[cnt] != NULL; ) | |
248 | ++cnt; | |
249 | return cnt; | |
250 | } | |
251 | ||
252 | /* Resize the scopes of depended-upon objects, so that the new object | |
253 | can be added later without further allocation of memory. This | |
254 | function can raise an exceptions due to malloc failure. */ | |
255 | static void | |
256 | resize_scopes (struct link_map *new) | |
257 | { | |
258 | /* If the file is not loaded now as a dependency, add the search | |
259 | list of the newly loaded object to the scope. */ | |
260 | for (unsigned int i = 0; i < new->l_searchlist.r_nlist; ++i) | |
261 | { | |
262 | struct link_map *imap = new->l_searchlist.r_list[i]; | |
263 | ||
264 | /* If the initializer has been called already, the object has | |
265 | not been loaded here and now. */ | |
266 | if (imap->l_init_called && imap->l_type == lt_loaded) | |
267 | { | |
268 | if (scope_has_map (imap, new)) | |
269 | /* Avoid duplicates. */ | |
270 | continue; | |
271 | ||
272 | size_t cnt = scope_size (imap); | |
273 | if (__glibc_unlikely (cnt + 1 >= imap->l_scope_max)) | |
274 | { | |
275 | /* The l_scope array is too small. Allocate a new one | |
276 | dynamically. */ | |
277 | size_t new_size; | |
278 | struct r_scope_elem **newp; | |
279 | ||
280 | if (imap->l_scope != imap->l_scope_mem | |
281 | && imap->l_scope_max < array_length (imap->l_scope_mem)) | |
282 | { | |
283 | /* If the current l_scope memory is not pointing to | |
284 | the static memory in the structure, but the | |
285 | static memory in the structure is large enough to | |
286 | use for cnt + 1 scope entries, then switch to | |
287 | using the static memory. */ | |
288 | new_size = array_length (imap->l_scope_mem); | |
289 | newp = imap->l_scope_mem; | |
290 | } | |
291 | else | |
292 | { | |
293 | new_size = imap->l_scope_max * 2; | |
294 | newp = (struct r_scope_elem **) | |
295 | malloc (new_size * sizeof (struct r_scope_elem *)); | |
296 | if (newp == NULL) | |
297 | _dl_signal_error (ENOMEM, "dlopen", NULL, | |
298 | N_("cannot create scope list")); | |
299 | } | |
300 | ||
301 | /* Copy the array and the terminating NULL. */ | |
302 | memcpy (newp, imap->l_scope, | |
303 | (cnt + 1) * sizeof (imap->l_scope[0])); | |
304 | struct r_scope_elem **old = imap->l_scope; | |
305 | ||
306 | imap->l_scope = newp; | |
307 | ||
308 | if (old != imap->l_scope_mem) | |
309 | _dl_scope_free (old); | |
310 | ||
311 | imap->l_scope_max = new_size; | |
312 | } | |
313 | } | |
314 | } | |
315 | } | |
316 | ||
317 | /* Second stage of resize_scopes: Add NEW to the scopes. Also print | |
318 | debugging information about scopes if requested. | |
319 | ||
320 | This function cannot raise an exception because all required memory | |
321 | has been allocated by a previous call to resize_scopes. */ | |
322 | static void | |
323 | update_scopes (struct link_map *new) | |
324 | { | |
325 | for (unsigned int i = 0; i < new->l_searchlist.r_nlist; ++i) | |
326 | { | |
327 | struct link_map *imap = new->l_searchlist.r_list[i]; | |
328 | int from_scope = 0; | |
329 | ||
330 | if (imap->l_init_called && imap->l_type == lt_loaded) | |
331 | { | |
332 | if (scope_has_map (imap, new)) | |
333 | /* Avoid duplicates. */ | |
334 | continue; | |
335 | ||
336 | size_t cnt = scope_size (imap); | |
337 | /* Assert that resize_scopes has sufficiently enlarged the | |
338 | array. */ | |
339 | assert (cnt + 1 < imap->l_scope_max); | |
340 | ||
341 | /* First terminate the extended list. Otherwise a thread | |
342 | might use the new last element and then use the garbage | |
343 | at offset IDX+1. */ | |
344 | imap->l_scope[cnt + 1] = NULL; | |
345 | atomic_write_barrier (); | |
346 | imap->l_scope[cnt] = &new->l_searchlist; | |
347 | ||
348 | from_scope = cnt; | |
349 | } | |
350 | ||
351 | /* Print scope information. */ | |
352 | if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_SCOPES)) | |
353 | _dl_show_scope (imap, from_scope); | |
354 | } | |
355 | } | |
356 | ||
357 | /* Call _dl_add_to_slotinfo with DO_ADD set to false, to allocate | |
358 | space in GL (dl_tls_dtv_slotinfo_list). This can raise an | |
359 | exception. The return value is true if any of the new objects use | |
360 | TLS. */ | |
361 | static bool | |
362 | resize_tls_slotinfo (struct link_map *new) | |
363 | { | |
364 | bool any_tls = false; | |
365 | for (unsigned int i = 0; i < new->l_searchlist.r_nlist; ++i) | |
366 | { | |
367 | struct link_map *imap = new->l_searchlist.r_list[i]; | |
368 | ||
369 | /* Only add TLS memory if this object is loaded now and | |
370 | therefore is not yet initialized. */ | |
371 | if (! imap->l_init_called && imap->l_tls_blocksize > 0) | |
372 | { | |
373 | _dl_add_to_slotinfo (imap, false); | |
374 | any_tls = true; | |
375 | } | |
376 | } | |
377 | return any_tls; | |
378 | } | |
379 | ||
380 | /* Second stage of TLS update, after resize_tls_slotinfo. This | |
381 | function does not raise any exception. It should only be called if | |
382 | resize_tls_slotinfo returned true. */ | |
383 | static void | |
384 | update_tls_slotinfo (struct link_map *new) | |
385 | { | |
386 | unsigned int first_static_tls = new->l_searchlist.r_nlist; | |
387 | for (unsigned int i = 0; i < new->l_searchlist.r_nlist; ++i) | |
388 | { | |
389 | struct link_map *imap = new->l_searchlist.r_list[i]; | |
390 | ||
391 | /* Only add TLS memory if this object is loaded now and | |
392 | therefore is not yet initialized. */ | |
393 | if (! imap->l_init_called && imap->l_tls_blocksize > 0) | |
394 | { | |
395 | _dl_add_to_slotinfo (imap, true); | |
396 | ||
397 | if (imap->l_need_tls_init | |
398 | && first_static_tls == new->l_searchlist.r_nlist) | |
399 | first_static_tls = i; | |
400 | } | |
401 | } | |
402 | ||
f4f8f4d4 SN |
403 | size_t newgen = GL(dl_tls_generation) + 1; |
404 | if (__glibc_unlikely (newgen == 0)) | |
a509eb11 FW |
405 | _dl_fatal_printf (N_("\ |
406 | TLS generation counter wrapped! Please report this.")); | |
f4f8f4d4 SN |
407 | /* Can be read concurrently. */ |
408 | atomic_store_relaxed (&GL(dl_tls_generation), newgen); | |
a509eb11 FW |
409 | |
410 | /* We need a second pass for static tls data, because | |
411 | _dl_update_slotinfo must not be run while calls to | |
412 | _dl_add_to_slotinfo are still pending. */ | |
413 | for (unsigned int i = first_static_tls; i < new->l_searchlist.r_nlist; ++i) | |
414 | { | |
415 | struct link_map *imap = new->l_searchlist.r_list[i]; | |
416 | ||
417 | if (imap->l_need_tls_init | |
418 | && ! imap->l_init_called | |
419 | && imap->l_tls_blocksize > 0) | |
420 | { | |
421 | /* For static TLS we have to allocate the memory here and | |
422 | now, but we can delay updating the DTV. */ | |
423 | imap->l_need_tls_init = 0; | |
424 | #ifdef SHARED | |
425 | /* Update the slot information data for at least the | |
426 | generation of the DSO we are allocating data for. */ | |
427 | ||
428 | /* FIXME: This can terminate the process on memory | |
429 | allocation failure. It is not possible to raise | |
430 | exceptions from this context; to fix this bug, | |
431 | _dl_update_slotinfo would have to be split into two | |
432 | operations, similar to resize_scopes and update_scopes | |
433 | above. This is related to bug 16134. */ | |
434 | _dl_update_slotinfo (imap->l_tls_modid); | |
435 | #endif | |
436 | ||
7cbf1c84 | 437 | dl_init_static_tls (imap); |
a509eb11 FW |
438 | assert (imap->l_need_tls_init == 0); |
439 | } | |
440 | } | |
441 | } | |
442 | ||
f63b7381 FW |
443 | /* Mark the objects as NODELETE if required. This is delayed until |
444 | after dlopen failure is not possible, so that _dl_close can clean | |
445 | up objects if necessary. */ | |
446 | static void | |
365624e2 | 447 | activate_nodelete (struct link_map *new) |
f63b7381 | 448 | { |
365624e2 FW |
449 | /* It is necessary to traverse the entire namespace. References to |
450 | objects in the global scope and unique symbol bindings can force | |
451 | NODELETE status for objects outside the local scope. */ | |
452 | for (struct link_map *l = GL (dl_ns)[new->l_ns]._ns_loaded; l != NULL; | |
453 | l = l->l_next) | |
f8ed116a | 454 | if (l->l_nodelete_pending) |
365624e2 FW |
455 | { |
456 | if (__glibc_unlikely (GLRO (dl_debug_mask) & DL_DEBUG_FILES)) | |
457 | _dl_debug_printf ("activating NODELETE for %s [%lu]\n", | |
458 | l->l_name, l->l_ns); | |
459 | ||
f7649d57 FW |
460 | /* The flag can already be true at this point, e.g. a signal |
461 | handler may have triggered lazy binding and set NODELETE | |
462 | status immediately. */ | |
f8ed116a FW |
463 | l->l_nodelete_active = true; |
464 | ||
465 | /* This is just a debugging aid, to indicate that | |
466 | activate_nodelete has run for this map. */ | |
467 | l->l_nodelete_pending = false; | |
365624e2 | 468 | } |
f63b7381 FW |
469 | } |
470 | ||
79e0cd7b FW |
471 | /* struct dl_init_args and call_dl_init are used to call _dl_init with |
472 | exception handling disabled. */ | |
473 | struct dl_init_args | |
474 | { | |
475 | struct link_map *new; | |
476 | int argc; | |
477 | char **argv; | |
478 | char **env; | |
479 | }; | |
480 | ||
481 | static void | |
482 | call_dl_init (void *closure) | |
483 | { | |
484 | struct dl_init_args *args = closure; | |
485 | _dl_init (args->new, args->argc, args->argv, args->env); | |
486 | } | |
487 | ||
7a68c94a | 488 | static void |
83b53232 | 489 | dl_open_worker_begin (void *a) |
7a68c94a UD |
490 | { |
491 | struct dl_open_args *args = a; | |
492 | const char *file = args->file; | |
493 | int mode = args->mode; | |
c14e9135 | 494 | struct link_map *call_map = NULL; |
dc5efe83 | 495 | |
c14e9135 | 496 | /* Determine the caller's map if necessary. This is needed in case |
c0f62c56 UD |
497 | we have a DST, when we don't know the namespace ID we have to put |
498 | the new object in, or when the file name has no path in which | |
499 | case we need to look along the RUNPATH/RPATH of the caller. */ | |
c14e9135 | 500 | const char *dst = strchr (file, '$'); |
c0f62c56 UD |
501 | if (dst != NULL || args->nsid == __LM_ID_CALLER |
502 | || strchr (file, '/') == NULL) | |
dc5efe83 | 503 | { |
f213ef02 | 504 | const void *caller_dlopen = args->caller_dlopen; |
06535ae9 | 505 | |
c0f62c56 UD |
506 | /* We have to find out from which object the caller is calling. |
507 | By default we assume this is the main application. */ | |
508 | call_map = GL(dl_ns)[LM_ID_BASE]._ns_loaded; | |
dc5efe83 | 509 | |
be179c8a SP |
510 | struct link_map *l = _dl_find_dso_for_object ((ElfW(Addr)) caller_dlopen); |
511 | ||
512 | if (l) | |
328c44c3 | 513 | call_map = l; |
be179c8a | 514 | |
c0f62c56 | 515 | if (args->nsid == __LM_ID_CALLER) |
f91f1c0f | 516 | args->nsid = call_map->l_ns; |
c14e9135 UD |
517 | } |
518 | ||
ec935dea FW |
519 | /* The namespace ID is now known. Keep track of whether libc.so was |
520 | already loaded, to determine whether it is necessary to call the | |
521 | early initialization routine (or clear libc_map on error). */ | |
522 | args->libc_already_loaded = GL(dl_ns)[args->nsid].libc_map != NULL; | |
523 | ||
440b7f86 FW |
524 | /* Retain the old value, so that it can be restored. */ |
525 | args->original_global_scope_pending_adds | |
526 | = GL (dl_ns)[args->nsid]._ns_global_scope_pending_adds; | |
527 | ||
ccdb048d CD |
528 | /* One might be tempted to assert that we are RT_CONSISTENT at this point, but that |
529 | may not be true if this is a recursive call to dlopen. */ | |
530 | _dl_debug_initialize (0, args->nsid); | |
29f97654 | 531 | |
266180eb | 532 | /* Load the named object. */ |
22c83193 | 533 | struct link_map *new; |
8e9f92e9 | 534 | args->map = new = _dl_map_object (call_map, file, lt_loaded, 0, |
9dcafc55 | 535 | mode | __RTLD_CALLMAP, args->nsid); |
bf8b3e74 UD |
536 | |
537 | /* If the pointer returned is NULL this means the RTLD_NOLOAD flag is | |
538 | set and the object is not already loaded. */ | |
539 | if (new == NULL) | |
540 | { | |
541 | assert (mode & RTLD_NOLOAD); | |
542 | return; | |
543 | } | |
544 | ||
a1ffb40e | 545 | if (__glibc_unlikely (mode & __RTLD_SPROF)) |
f7649d57 FW |
546 | /* This happens only if we load a DSO for 'sprof'. */ |
547 | return; | |
9d0881aa | 548 | |
c0f62c56 UD |
549 | /* This object is directly loaded. */ |
550 | ++new->l_direct_opencount; | |
551 | ||
42c4f32a | 552 | /* It was already open. */ |
a1ffb40e | 553 | if (__glibc_unlikely (new->l_searchlist.r_list != NULL)) |
b35e21f4 UD |
554 | { |
555 | /* Let the user know about the opencount. */ | |
a1ffb40e | 556 | if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_FILES)) |
20fe49b9 | 557 | _dl_debug_printf ("opening file=%s [%lu]; direct_opencount=%u\n\n", |
a2f7570b | 558 | new->l_name, new->l_ns, new->l_direct_opencount); |
d785c366 | 559 | |
f63b7381 FW |
560 | /* If the user requested the object to be in the global |
561 | namespace but it is not so far, prepare to add it now. This | |
562 | can raise an exception to do a malloc failure. */ | |
d785c366 | 563 | if ((mode & RTLD_GLOBAL) && new->l_global == 0) |
f63b7381 FW |
564 | add_to_global_resize (new); |
565 | ||
566 | /* Mark the object as not deletable if the RTLD_NODELETE flags | |
567 | was passed. */ | |
568 | if (__glibc_unlikely (mode & RTLD_NODELETE)) | |
440b7f86 | 569 | { |
f63b7381 | 570 | if (__glibc_unlikely (GLRO (dl_debug_mask) & DL_DEBUG_FILES) |
f8ed116a | 571 | && !new->l_nodelete_active) |
f63b7381 FW |
572 | _dl_debug_printf ("marking %s [%lu] as NODELETE\n", |
573 | new->l_name, new->l_ns); | |
f8ed116a | 574 | new->l_nodelete_active = true; |
440b7f86 | 575 | } |
d785c366 | 576 | |
f63b7381 FW |
577 | /* Finalize the addition to the global scope. */ |
578 | if ((mode & RTLD_GLOBAL) && new->l_global == 0) | |
579 | add_to_global_update (new); | |
580 | ||
a93d9e03 | 581 | assert (_dl_debug_update (args->nsid)->r_state == RT_CONSISTENT); |
9dcafc55 | 582 | |
b35e21f4 UD |
583 | return; |
584 | } | |
266180eb | 585 | |
f63b7381 FW |
586 | /* Schedule NODELETE marking for the directly loaded object if |
587 | requested. */ | |
588 | if (__glibc_unlikely (mode & RTLD_NODELETE)) | |
f8ed116a | 589 | new->l_nodelete_pending = true; |
f63b7381 | 590 | |
266180eb | 591 | /* Load that object's dependencies. */ |
9dcafc55 | 592 | _dl_map_object_deps (new, NULL, 0, 0, |
3e539cb4 | 593 | mode & (__RTLD_DLOPEN | RTLD_DEEPBIND | __RTLD_AUDIT)); |
266180eb | 594 | |
c84142e8 | 595 | /* So far, so good. Now check the versions. */ |
22c83193 | 596 | for (unsigned int i = 0; i < new->l_searchlist.r_nlist; ++i) |
c0f62c56 | 597 | if (new->l_searchlist.r_list[i]->l_real->l_versions == NULL) |
78b31cc8 FW |
598 | { |
599 | struct link_map *map = new->l_searchlist.r_list[i]->l_real; | |
600 | _dl_check_map_versions (map, 0, 0); | |
601 | #ifndef SHARED | |
602 | /* During static dlopen, check if ld.so has been loaded. | |
603 | Perform partial initialization in this case. This must | |
604 | come after the symbol versioning initialization in | |
605 | _dl_check_map_versions. */ | |
606 | if (map->l_info[DT_SONAME] != NULL | |
607 | && strcmp (((const char *) D_PTR (map, l_info[DT_STRTAB]) | |
608 | + map->l_info[DT_SONAME]->d_un.d_val), LD_SO) == 0) | |
609 | __rtld_static_init (map); | |
610 | #endif | |
611 | } | |
ba79d61b | 612 | |
9dcafc55 UD |
613 | #ifdef SHARED |
614 | /* Auditing checkpoint: we have added all objects. */ | |
3dac3959 | 615 | _dl_audit_activity_nsid (new->l_ns, LA_ACT_CONSISTENT); |
9dcafc55 UD |
616 | #endif |
617 | ||
618 | /* Notify the debugger all new objects are now ready to go. */ | |
a93d9e03 | 619 | struct r_debug *r = _dl_debug_update (args->nsid); |
9dcafc55 UD |
620 | r->r_state = RT_CONSISTENT; |
621 | _dl_debug_state (); | |
815e6fa3 | 622 | LIBC_PROBE (map_complete, 3, args->nsid, r, new); |
9dcafc55 | 623 | |
e37c2cf2 FW |
624 | _dl_open_check (new); |
625 | ||
174baab3 | 626 | /* Print scope information. */ |
a1ffb40e | 627 | if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_SCOPES)) |
174baab3 UD |
628 | _dl_show_scope (new, 0); |
629 | ||
12b5b6b7 | 630 | /* Only do lazy relocation if `LD_BIND_NOW' is not set. */ |
2ca285b0 UD |
631 | int reloc_mode = mode & __RTLD_AUDIT; |
632 | if (GLRO(dl_lazy)) | |
633 | reloc_mode |= mode & RTLD_LAZY; | |
12b5b6b7 | 634 | |
71bcfa62 DK |
635 | /* Objects must be sorted by dependency for the relocation process. |
636 | This allows IFUNC relocations to work and it also means copy | |
637 | relocation of dependencies are if necessary overwritten. | |
638 | __dl_map_object_deps has already sorted l_initfini for us. */ | |
0a8ce6a0 DK |
639 | unsigned int first = UINT_MAX; |
640 | unsigned int last = 0; | |
eb447b7b DK |
641 | unsigned int j = 0; |
642 | struct link_map *l = new->l_initfini[0]; | |
6ee65ed6 UD |
643 | do |
644 | { | |
645 | if (! l->l_real->l_relocated) | |
0a8ce6a0 DK |
646 | { |
647 | if (first == UINT_MAX) | |
648 | first = j; | |
649 | last = j + 1; | |
650 | } | |
eb447b7b | 651 | l = new->l_initfini[++j]; |
6ee65ed6 UD |
652 | } |
653 | while (l != NULL); | |
ba79d61b | 654 | |
815e6fa3 GB |
655 | int relocation_in_progress = 0; |
656 | ||
f63b7381 FW |
657 | /* Perform relocation. This can trigger lazy binding in IFUNC |
658 | resolvers. For NODELETE mappings, these dependencies are not | |
659 | recorded because the flag has not been applied to the newly | |
660 | loaded objects. This means that upon dlopen failure, these | |
661 | NODELETE objects can be unloaded despite existing references to | |
662 | them. However, such relocation dependencies in IFUNC resolvers | |
663 | are undefined anyway, so this is not a problem. */ | |
664 | ||
0a8ce6a0 | 665 | for (unsigned int i = last; i-- > first; ) |
6ee65ed6 | 666 | { |
0a8ce6a0 DK |
667 | l = new->l_initfini[i]; |
668 | ||
669 | if (l->l_real->l_relocated) | |
670 | continue; | |
6ee65ed6 | 671 | |
815e6fa3 GB |
672 | if (! relocation_in_progress) |
673 | { | |
674 | /* Notify the debugger that relocations are about to happen. */ | |
675 | LIBC_PROBE (reloc_start, 2, args->nsid, r); | |
676 | relocation_in_progress = 1; | |
677 | } | |
678 | ||
6ee65ed6 | 679 | #ifdef SHARED |
a1ffb40e | 680 | if (__glibc_unlikely (GLRO(dl_profile) != NULL)) |
6ee65ed6 UD |
681 | { |
682 | /* If this here is the shared object which we want to profile | |
683 | make sure the profile is started. We can find out whether | |
684 | this is necessary or not by observing the `_dl_profile_map' | |
c0c3f78a | 685 | variable. If it was NULL but is not NULL afterwards we must |
6ee65ed6 UD |
686 | start the profiling. */ |
687 | struct link_map *old_profile_map = GL(dl_profile_map); | |
688 | ||
689 | _dl_relocate_object (l, l->l_scope, reloc_mode | RTLD_LAZY, 1); | |
690 | ||
691 | if (old_profile_map == NULL && GL(dl_profile_map) != NULL) | |
692 | { | |
693 | /* We must prepare the profiling. */ | |
694 | _dl_start_profile (); | |
695 | ||
696 | /* Prevent unloading the object. */ | |
f8ed116a | 697 | GL(dl_profile_map)->l_nodelete_active = true; |
6ee65ed6 UD |
698 | } |
699 | } | |
700 | else | |
701 | #endif | |
702 | _dl_relocate_object (l, l->l_scope, reloc_mode, 0); | |
4d6acc61 | 703 | } |
ba79d61b | 704 | |
a509eb11 FW |
705 | /* This only performs the memory allocations. The actual update of |
706 | the scopes happens below, after failure is impossible. */ | |
707 | resize_scopes (new); | |
20fe49b9 | 708 | |
a509eb11 FW |
709 | /* Increase the size of the GL (dl_tls_dtv_slotinfo_list) data |
710 | structure. */ | |
711 | bool any_tls = resize_tls_slotinfo (new); | |
c0a777e8 | 712 | |
a509eb11 FW |
713 | /* Perform the necessary allocations for adding new global objects |
714 | to the global scope below. */ | |
715 | if (mode & RTLD_GLOBAL) | |
716 | add_to_global_resize (new); | |
73d61e4f | 717 | |
a509eb11 FW |
718 | /* Demarcation point: After this, no recoverable errors are allowed. |
719 | All memory allocations for new objects must have happened | |
720 | before. */ | |
721 | ||
f7649d57 FW |
722 | /* Finalize the NODELETE status first. This comes before |
723 | update_scopes, so that lazy binding will not see pending NODELETE | |
724 | state for newly loaded objects. There is a compiler barrier in | |
725 | update_scopes which ensures that the changes from | |
726 | activate_nodelete are visible before new objects show up in the | |
727 | local scope. */ | |
365624e2 | 728 | activate_nodelete (new); |
f63b7381 | 729 | |
a509eb11 FW |
730 | /* Second stage after resize_scopes: Actually perform the scope |
731 | update. After this, dlsym and lazy binding can bind to new | |
732 | objects. */ | |
733 | update_scopes (new); | |
734 | ||
5d28a896 FW |
735 | if (!_dl_find_object_update (new)) |
736 | _dl_signal_error (ENOMEM, new->l_libname->name, NULL, | |
737 | N_ ("cannot allocate address lookup data")); | |
738 | ||
a509eb11 FW |
739 | /* FIXME: It is unclear whether the order here is correct. |
740 | Shouldn't new objects be made available for binding (and thus | |
741 | execution) only after there TLS data has been set up fully? | |
742 | Fixing bug 16134 will likely make this distinction less | |
743 | important. */ | |
744 | ||
745 | /* Second stage after resize_tls_slotinfo: Update the slotinfo data | |
746 | structures. */ | |
747 | if (any_tls) | |
748 | /* FIXME: This calls _dl_update_slotinfo, which aborts the process | |
749 | on memory allocation failure. See bug 16134. */ | |
750 | update_tls_slotinfo (new); | |
d26dfc60 | 751 | |
815e6fa3 GB |
752 | /* Notify the debugger all new objects have been relocated. */ |
753 | if (relocation_in_progress) | |
754 | LIBC_PROBE (reloc_complete, 3, args->nsid, r, new); | |
755 | ||
ec935dea | 756 | /* If libc.so was not there before, attempt to call its early |
03e187a4 FW |
757 | initialization routine. Indicate to the initialization routine |
758 | whether the libc being initialized is the one in the base | |
759 | namespace. */ | |
ec935dea | 760 | if (!args->libc_already_loaded) |
03e187a4 | 761 | { |
3908fa93 | 762 | /* dlopen cannot be used to load an initial libc by design. */ |
89baed0b FW |
763 | struct link_map *libc_map = GL(dl_ns)[args->nsid].libc_map; |
764 | _dl_call_libc_early_init (libc_map, false); | |
03e187a4 | 765 | } |
ec935dea | 766 | |
83b53232 SN |
767 | args->worker_continue = true; |
768 | } | |
769 | ||
770 | static void | |
771 | dl_open_worker (void *a) | |
772 | { | |
773 | struct dl_open_args *args = a; | |
774 | ||
775 | args->worker_continue = false; | |
776 | ||
777 | { | |
778 | /* Protects global and module specific TLS state. */ | |
779 | __rtld_lock_lock_recursive (GL(dl_load_tls_lock)); | |
780 | ||
781 | struct dl_exception ex; | |
782 | int err = _dl_catch_exception (&ex, dl_open_worker_begin, args); | |
783 | ||
784 | __rtld_lock_unlock_recursive (GL(dl_load_tls_lock)); | |
785 | ||
786 | if (__glibc_unlikely (ex.errstring != NULL)) | |
787 | /* Reraise the error. */ | |
788 | _dl_signal_exception (err, &ex, NULL); | |
789 | } | |
790 | ||
791 | if (!args->worker_continue) | |
792 | return; | |
793 | ||
794 | int mode = args->mode; | |
795 | struct link_map *new = args->map; | |
796 | ||
79e0cd7b FW |
797 | /* Run the initializer functions of new objects. Temporarily |
798 | disable the exception handler, so that lazy binding failures are | |
799 | fatal. */ | |
800 | { | |
801 | struct dl_init_args init_args = | |
802 | { | |
803 | .new = new, | |
804 | .argc = args->argc, | |
805 | .argv = args->argv, | |
806 | .env = args->env | |
807 | }; | |
808 | _dl_catch_exception (NULL, call_dl_init, &init_args); | |
809 | } | |
266180eb | 810 | |
50b65db1 | 811 | /* Now we can make the new map available in the global scope. */ |
d9cb1a7d | 812 | if (mode & RTLD_GLOBAL) |
440b7f86 | 813 | add_to_global_update (new); |
be935610 | 814 | |
b35e21f4 | 815 | /* Let the user know about the opencount. */ |
a1ffb40e | 816 | if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_FILES)) |
20fe49b9 UD |
817 | _dl_debug_printf ("opening file=%s [%lu]; direct_opencount=%u\n\n", |
818 | new->l_name, new->l_ns, new->l_direct_opencount); | |
7a68c94a UD |
819 | } |
820 | ||
94e365c6 | 821 | void * |
9dcafc55 UD |
822 | _dl_open (const char *file, int mode, const void *caller_dlopen, Lmid_t nsid, |
823 | int argc, char *argv[], char *env[]) | |
7a68c94a | 824 | { |
e254df14 UD |
825 | if ((mode & RTLD_BINDING_MASK) == 0) |
826 | /* One of the flags must be set. */ | |
9dcafc55 | 827 | _dl_signal_error (EINVAL, file, NULL, N_("invalid mode for dlopen()")); |
e254df14 | 828 | |
7a68c94a | 829 | /* Make sure we are alone. */ |
d3c9f895 | 830 | __rtld_lock_lock_recursive (GL(dl_load_lock)); |
7a68c94a | 831 | |
a1ffb40e | 832 | if (__glibc_unlikely (nsid == LM_ID_NEWLM)) |
c0f62c56 UD |
833 | { |
834 | /* Find a new namespace. */ | |
5615eaf2 | 835 | for (nsid = 1; DL_NNS > 1 && nsid < GL(dl_nns); ++nsid) |
c0f62c56 UD |
836 | if (GL(dl_ns)[nsid]._ns_loaded == NULL) |
837 | break; | |
838 | ||
a1ffb40e | 839 | if (__glibc_unlikely (nsid == DL_NNS)) |
c0f62c56 UD |
840 | { |
841 | /* No more namespace available. */ | |
842 | __rtld_lock_unlock_recursive (GL(dl_load_lock)); | |
843 | ||
9dcafc55 | 844 | _dl_signal_error (EINVAL, file, NULL, N_("\ |
c0f62c56 UD |
845 | no more namespaces available for dlmopen()")); |
846 | } | |
d0e357ff FW |
847 | |
848 | if (nsid == GL(dl_nns)) | |
849 | ++GL(dl_nns); | |
850 | ||
851 | /* Initialize the new namespace. Most members are | |
852 | zero-initialized, only the lock needs special treatment. */ | |
853 | memset (&GL(dl_ns)[nsid], 0, sizeof (GL(dl_ns)[nsid])); | |
854 | __rtld_lock_initialize (GL(dl_ns)[nsid]._ns_unique_sym_table.lock); | |
22c83193 | 855 | |
a93d9e03 | 856 | _dl_debug_update (nsid)->r_state = RT_CONSISTENT; |
c0f62c56 | 857 | } |
32738a22 | 858 | /* Never allow loading a DSO in a namespace which is empty. Such |
9dcafc55 UD |
859 | direct placements is only causing problems. Also don't allow |
860 | loading into a namespace used for auditing. */ | |
328c44c3 RM |
861 | else if (__glibc_unlikely (nsid != LM_ID_BASE && nsid != __LM_ID_CALLER) |
862 | && (__glibc_unlikely (nsid < 0 || nsid >= GL(dl_nns)) | |
863 | /* This prevents the [NSID] index expressions from being | |
864 | evaluated, so the compiler won't think that we are | |
865 | accessing an invalid index here in the !SHARED case where | |
866 | DL_NNS is 1 and so any NSID != 0 is invalid. */ | |
867 | || DL_NNS == 1 | |
868 | || GL(dl_ns)[nsid]._ns_nloaded == 0 | |
9dcafc55 UD |
869 | || GL(dl_ns)[nsid]._ns_loaded->l_auditing)) |
870 | _dl_signal_error (EINVAL, file, NULL, | |
871 | N_("invalid target namespace in dlmopen()")); | |
c0f62c56 | 872 | |
74780cf6 | 873 | struct dl_open_args args; |
7a68c94a UD |
874 | args.file = file; |
875 | args.mode = mode; | |
f213ef02 | 876 | args.caller_dlopen = caller_dlopen; |
7a68c94a | 877 | args.map = NULL; |
c0f62c56 | 878 | args.nsid = nsid; |
ec935dea FW |
879 | /* args.libc_already_loaded is always assigned by dl_open_worker |
880 | (before any explicit/non-local returns). */ | |
9dcafc55 UD |
881 | args.argc = argc; |
882 | args.argv = argv; | |
883 | args.env = env; | |
74780cf6 | 884 | |
2449ae7b FW |
885 | struct dl_exception exception; |
886 | int errcode = _dl_catch_exception (&exception, dl_open_worker, &args); | |
39778c6c | 887 | |
f57f8055 RM |
888 | #if defined USE_LDCONFIG && !defined MAP_COPY |
889 | /* We must unmap the cache file. */ | |
9dcafc55 | 890 | _dl_unload_cache (); |
08cac4ac UD |
891 | #endif |
892 | ||
440b7f86 FW |
893 | /* Do this for both the error and success cases. The old value has |
894 | only been determined if the namespace ID was assigned (i.e., it | |
895 | is not __LM_ID_CALLER). In the success case, we actually may | |
896 | have consumed more pending adds than planned (because the local | |
897 | scopes overlap in case of a recursive dlopen, the inner dlopen | |
898 | doing some of the globalization work of the outer dlopen), so the | |
899 | old pending adds value is larger than absolutely necessary. | |
900 | Since it is just a conservative upper bound, this is harmless. | |
901 | The top-level dlopen call will restore the field to zero. */ | |
902 | if (args.nsid >= 0) | |
903 | GL (dl_ns)[args.nsid]._ns_global_scope_pending_adds | |
904 | = args.original_global_scope_pending_adds; | |
905 | ||
b2369ca3 | 906 | /* See if an error occurred during loading. */ |
2449ae7b | 907 | if (__glibc_unlikely (exception.errstring != NULL)) |
7a68c94a | 908 | { |
ec935dea FW |
909 | /* Avoid keeping around a dangling reference to the libc.so link |
910 | map in case it has been cached in libc_map. */ | |
911 | if (!args.libc_already_loaded) | |
1e1ecea6 | 912 | GL(dl_ns)[args.nsid].libc_map = NULL; |
ec935dea | 913 | |
7a68c94a UD |
914 | /* Remove the object from memory. It may be in an inconsistent |
915 | state if relocation failed, for example. */ | |
916 | if (args.map) | |
c77a4478 | 917 | { |
02d5e5d9 | 918 | _dl_close_worker (args.map, true); |
f63b7381 | 919 | |
f8ed116a FW |
920 | /* All l_nodelete_pending objects should have been deleted |
921 | at this point, which is why it is not necessary to reset | |
922 | the flag here. */ | |
c77a4478 | 923 | } |
7a68c94a | 924 | |
b2369ca3 UD |
925 | /* Release the lock. */ |
926 | __rtld_lock_unlock_recursive (GL(dl_load_lock)); | |
927 | ||
7a68c94a | 928 | /* Reraise the error. */ |
2449ae7b | 929 | _dl_signal_exception (errcode, &exception, NULL); |
7a68c94a UD |
930 | } |
931 | ||
a93d9e03 | 932 | assert (_dl_debug_update (args.nsid)->r_state == RT_CONSISTENT); |
9dcafc55 | 933 | |
b2369ca3 UD |
934 | /* Release the lock. */ |
935 | __rtld_lock_unlock_recursive (GL(dl_load_lock)); | |
936 | ||
7a68c94a | 937 | return args.map; |
266180eb | 938 | } |
482eec0d UD |
939 | |
940 | ||
73d7af4f | 941 | void |
174baab3 | 942 | _dl_show_scope (struct link_map *l, int from) |
482eec0d | 943 | { |
73d7af4f | 944 | _dl_debug_printf ("object=%s [%lu]\n", |
b9375348 | 945 | DSO_FILENAME (l->l_name), l->l_ns); |
73d7af4f | 946 | if (l->l_scope != NULL) |
174baab3 | 947 | for (int scope_cnt = from; l->l_scope[scope_cnt] != NULL; ++scope_cnt) |
73d7af4f | 948 | { |
f0f47fa0 | 949 | _dl_debug_printf (" scope %u:", scope_cnt); |
73d7af4f | 950 | |
076fe015 | 951 | for (unsigned int cnt = 0; cnt < l->l_scope[scope_cnt]->r_nlist; ++cnt) |
73d7af4f UD |
952 | if (*l->l_scope[scope_cnt]->r_list[cnt]->l_name) |
953 | _dl_debug_printf_c (" %s", | |
954 | l->l_scope[scope_cnt]->r_list[cnt]->l_name); | |
955 | else | |
b9375348 | 956 | _dl_debug_printf_c (" %s", RTLD_PROGNAME); |
482eec0d | 957 | |
73d7af4f UD |
958 | _dl_debug_printf_c ("\n"); |
959 | } | |
001f0a6c UD |
960 | else |
961 | _dl_debug_printf (" no scope\n"); | |
73d7af4f | 962 | _dl_debug_printf ("\n"); |
482eec0d | 963 | } |