1 /* Load a shared object at runtime, relocate it, and run its initializer.
2 Copyright (C) 1996-2004, 2005, 2006, 2007 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
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.
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.
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, write to the Free
17 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
28 #include <sys/mman.h> /* Check whether MAP_COPY is defined. */
29 #include <sys/param.h>
30 #include <bits/libc-lock.h>
34 #include <sysdep-cancel.h>
40 extern ElfW(Addr) _dl_sysdep_start (void **start_argptr,
41 void (*dl_main) (const ElfW(Phdr) *phdr,
43 ElfW(Addr) *user_entry));
44 weak_extern (BP_SYM (_dl_sysdep_start))
46 extern int __libc_multiple_libcs; /* Defined in init-first.c. */
48 /* Undefine the following for debugging. */
49 /* #define SCOPE_DEBUG 1 */
51 static void show_scope (struct link_map *new);
54 /* We must be carefull not to leave us in an inconsistent state. Thus we
55 catch any error and re-raise it after cleaning up. */
61 /* This is the caller of the dlopen() function. */
62 const void *caller_dlopen;
63 /* This is the caller if _dl_open(). */
64 const void *caller_dl_open;
68 /* Original parameters to the program and the current environment. */
76 add_to_global (struct link_map *new)
78 struct link_map **new_global;
79 unsigned int to_add = 0;
82 /* Count the objects we have to put in the global scope. */
83 for (cnt = 0; cnt < new->l_searchlist.r_nlist; ++cnt)
84 if (new->l_searchlist.r_list[cnt]->l_global == 0)
87 /* The symbols of the new objects and its dependencies are to be
88 introduced into the global scope that will be used to resolve
89 references from other dynamically-loaded objects.
91 The global scope is the searchlist in the main link map. We
92 extend this list if necessary. There is one problem though:
93 since this structure was allocated very early (before the libc
94 is loaded) the memory it uses is allocated by the malloc()-stub
95 in the ld.so. When we come here these functions are not used
96 anymore. Instead the malloc() implementation of the libc is
97 used. But this means the block from the main map cannot be used
98 in an realloc() call. Therefore we allocate a completely new
99 array the first time we have to add something to the locale scope. */
101 struct link_namespaces *ns = &GL(dl_ns)[new->l_ns];
102 if (ns->_ns_global_scope_alloc == 0)
104 /* This is the first dynamic object given global scope. */
105 ns->_ns_global_scope_alloc
106 = ns->_ns_main_searchlist->r_nlist + to_add + 8;
107 new_global = (struct link_map **)
108 malloc (ns->_ns_global_scope_alloc * sizeof (struct link_map *));
109 if (new_global == NULL)
111 ns->_ns_global_scope_alloc = 0;
113 _dl_signal_error (ENOMEM, new->l_libname->name, NULL,
114 N_("cannot extend global scope"));
118 /* Copy over the old entries. */
119 ns->_ns_main_searchlist->r_list
120 = memcpy (new_global, ns->_ns_main_searchlist->r_list,
121 (ns->_ns_main_searchlist->r_nlist
122 * sizeof (struct link_map *)));
124 else if (ns->_ns_main_searchlist->r_nlist + to_add
125 > ns->_ns_global_scope_alloc)
127 /* We have to extend the existing array of link maps in the
129 struct link_map **old_global
130 = GL(dl_ns)[new->l_ns]._ns_main_searchlist->r_list;
131 size_t new_nalloc = ((ns->_ns_global_scope_alloc + to_add) * 2);
133 new_global = (struct link_map **)
134 malloc (new_nalloc * sizeof (struct link_map *));
135 if (new_global == NULL)
138 memcpy (new_global, old_global,
139 ns->_ns_global_scope_alloc * sizeof (struct link_map *));
141 ns->_ns_global_scope_alloc = new_nalloc;
142 ns->_ns_main_searchlist->r_list = new_global;
144 if (!RTLD_SINGLE_THREAD_P)
145 THREAD_GSCOPE_WAIT ();
150 /* Now add the new entries. */
151 unsigned int new_nlist = ns->_ns_main_searchlist->r_nlist;
152 for (cnt = 0; cnt < new->l_searchlist.r_nlist; ++cnt)
154 struct link_map *map = new->l_searchlist.r_list[cnt];
156 if (map->l_global == 0)
159 ns->_ns_main_searchlist->r_list[new_nlist++] = map;
162 atomic_write_barrier ();
163 ns->_ns_main_searchlist->r_nlist = new_nlist;
170 dl_open_worker (void *a)
172 struct dl_open_args *args = a;
173 const char *file = args->file;
174 int mode = args->mode;
175 struct link_map *new;
178 bool any_tls = false;
179 struct link_map *call_map = NULL;
181 /* Check whether _dl_open() has been called from a valid DSO. */
182 if (__check_caller (args->caller_dl_open,
183 allow_libc|allow_libdl|allow_ldso) != 0)
184 _dl_signal_error (0, "dlopen", NULL, N_("invalid caller"));
186 /* Determine the caller's map if necessary. This is needed in case
187 we have a DST, when we don't know the namespace ID we have to put
188 the new object in, or when the file name has no path in which
189 case we need to look along the RUNPATH/RPATH of the caller. */
190 const char *dst = strchr (file, '$');
191 if (dst != NULL || args->nsid == __LM_ID_CALLER
192 || strchr (file, '/') == NULL)
194 const void *caller_dlopen = args->caller_dlopen;
196 /* We have to find out from which object the caller is calling.
197 By default we assume this is the main application. */
198 call_map = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
201 for (Lmid_t ns = 0; ns < DL_NNS; ++ns)
202 for (l = GL(dl_ns)[ns]._ns_loaded; l != NULL; l = l->l_next)
203 if (caller_dlopen >= (const void *) l->l_map_start
204 && caller_dlopen < (const void *) l->l_map_end
206 || _dl_addr_inside_object (l, (ElfW(Addr)) caller_dlopen)))
208 assert (ns == l->l_ns);
214 if (args->nsid == __LM_ID_CALLER)
217 /* In statically linked apps there might be no loaded object. */
218 if (call_map == NULL)
219 args->nsid = LM_ID_BASE;
222 args->nsid = call_map->l_ns;
226 assert (_dl_debug_initialize (0, args->nsid)->r_state == RT_CONSISTENT);
228 /* Maybe we have to expand a DST. */
229 if (__builtin_expect (dst != NULL, 0))
231 size_t len = strlen (file);
235 /* Determine how much space we need. We have to allocate the
237 required = DL_DST_REQUIRED (call_map, file, len, _dl_dst_count (dst, 0));
239 /* Get space for the new file name. */
240 new_file = (char *) alloca (required + 1);
242 /* Generate the new file name. */
243 _dl_dst_substitute (call_map, file, new_file, 0);
245 /* If the substitution failed don't try to load. */
246 if (*new_file == '\0')
247 _dl_signal_error (0, "dlopen", NULL,
248 N_("empty dynamic string token substitution"));
250 /* Now we have a new file name. */
253 /* It does not matter whether call_map is set even if we
254 computed it only because of the DST. Since the path contains
255 a slash the value is not used. See dl-load.c. */
258 /* Load the named object. */
259 args->map = new = _dl_map_object (call_map, file, 0, lt_loaded, 0,
260 mode | __RTLD_CALLMAP, args->nsid);
262 /* If the pointer returned is NULL this means the RTLD_NOLOAD flag is
263 set and the object is not already loaded. */
266 assert (mode & RTLD_NOLOAD);
270 if (__builtin_expect (mode & __RTLD_SPROF, 0))
271 /* This happens only if we load a DSO for 'sprof'. */
274 /* This object is directly loaded. */
275 ++new->l_direct_opencount;
277 /* It was already open. */
278 if (__builtin_expect (new->l_searchlist.r_list != NULL, 0))
280 /* Let the user know about the opencount. */
281 if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
282 _dl_debug_printf ("opening file=%s [%lu]; direct_opencount=%u\n\n",
283 new->l_name, new->l_ns, new->l_direct_opencount);
285 /* If the user requested the object to be in the global namespace
286 but it is not so far, add it now. */
287 if ((mode & RTLD_GLOBAL) && new->l_global == 0)
288 (void) add_to_global (new);
290 assert (_dl_debug_initialize (0, args->nsid)->r_state == RT_CONSISTENT);
295 /* Load that object's dependencies. */
296 _dl_map_object_deps (new, NULL, 0, 0,
297 mode & (__RTLD_DLOPEN | RTLD_DEEPBIND | __RTLD_AUDIT));
299 /* So far, so good. Now check the versions. */
300 for (i = 0; i < new->l_searchlist.r_nlist; ++i)
301 if (new->l_searchlist.r_list[i]->l_real->l_versions == NULL)
302 (void) _dl_check_map_versions (new->l_searchlist.r_list[i]->l_real,
310 /* Auditing checkpoint: we have added all objects. */
311 if (__builtin_expect (GLRO(dl_naudit) > 0, 0))
313 struct link_map *head = GL(dl_ns)[new->l_ns]._ns_loaded;
314 /* Do not call the functions for any auditing object. */
315 if (head->l_auditing == 0)
317 struct audit_ifaces *afct = GLRO(dl_audit);
318 for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
320 if (afct->activity != NULL)
321 afct->activity (&head->l_audit[cnt].cookie, LA_ACT_CONSISTENT);
329 /* Notify the debugger all new objects are now ready to go. */
330 struct r_debug *r = _dl_debug_initialize (0, args->nsid);
331 r->r_state = RT_CONSISTENT;
334 /* Only do lazy relocation if `LD_BIND_NOW' is not set. */
335 lazy = (mode & RTLD_BINDING_MASK) == RTLD_LAZY && GLRO(dl_lazy);
337 /* Relocate the objects loaded. We do this in reverse order so that copy
338 relocs of earlier objects overwrite the data written by later objects. */
340 struct link_map *l = new;
345 if (! l->l_real->l_relocated)
348 if (__builtin_expect (GLRO(dl_profile) != NULL, 0))
350 /* If this here is the shared object which we want to profile
351 make sure the profile is started. We can find out whether
352 this is necessary or not by observing the `_dl_profile_map'
353 variable. If was NULL but is not NULL afterwars we must
354 start the profiling. */
355 struct link_map *old_profile_map = GL(dl_profile_map);
357 _dl_relocate_object (l, l->l_scope, 1, 1);
359 if (old_profile_map == NULL && GL(dl_profile_map) != NULL)
361 /* We must prepare the profiling. */
362 _dl_start_profile ();
364 /* Prevent unloading the object. */
365 GL(dl_profile_map)->l_flags_1 |= DF_1_NODELETE;
370 _dl_relocate_object (l, l->l_scope, lazy, 0);
378 /* If the file is not loaded now as a dependency, add the search
379 list of the newly loaded object to the scope. */
380 for (i = 0; i < new->l_searchlist.r_nlist; ++i)
382 struct link_map *imap = new->l_searchlist.r_list[i];
384 /* If the initializer has been called already, the object has
385 not been loaded here and now. */
386 if (imap->l_init_called && imap->l_type == lt_loaded)
388 struct r_scope_elem **runp = imap->l_scope;
391 while (*runp != NULL)
393 if (*runp == &new->l_searchlist)
400 /* Avoid duplicates. */
403 if (__builtin_expect (cnt + 1 >= imap->l_scope_max, 0))
405 /* The 'r_scope' array is too small. Allocate a new one
408 struct r_scope_elem **newp;
410 #define SCOPE_ELEMS(imap) \
411 (sizeof (imap->l_scope_mem) / sizeof (imap->l_scope_mem[0]))
413 if (imap->l_scope != imap->l_scope_mem
414 && imap->l_scope_max < SCOPE_ELEMS (imap))
416 new_size = SCOPE_ELEMS (imap);
417 newp = imap->l_scope_mem;
421 new_size = imap->l_scope_max * 2;
422 newp = (struct r_scope_elem **)
423 malloc (new_size * sizeof (struct r_scope_elem *));
425 _dl_signal_error (ENOMEM, "dlopen", NULL,
426 N_("cannot create scope list"));
429 memcpy (newp, imap->l_scope, cnt * sizeof (imap->l_scope[0]));
430 struct r_scope_elem **old = imap->l_scope;
432 if (RTLD_SINGLE_THREAD_P)
433 imap->l_scope = newp;
436 __rtld_mrlock_change (imap->l_scope_lock);
437 imap->l_scope = newp;
438 __rtld_mrlock_done (imap->l_scope_lock);
441 if (old != imap->l_scope_mem)
444 imap->l_scope_max = new_size;
447 /* First terminate the extended list. Otherwise a thread
448 might use the new last element and then use the garbage
450 imap->l_scope[cnt + 1] = NULL;
451 atomic_write_barrier ();
452 imap->l_scope[cnt] = &new->l_searchlist;
454 /* Only add TLS memory if this object is loaded now and
455 therefore is not yet initialized. */
456 else if (! imap->l_init_called
457 /* Only if the module defines thread local data. */
458 && __builtin_expect (imap->l_tls_blocksize > 0, 0))
460 /* Now that we know the object is loaded successfully add
461 modules containing TLS data to the slot info table. We
462 might have to increase its size. */
463 _dl_add_to_slotinfo (imap);
465 if (imap->l_need_tls_init)
467 imap->l_need_tls_init = 0;
469 /* Update the slot information data for at least the
470 generation of the DSO we are allocating data for. */
471 _dl_update_slotinfo (imap->l_tls_modid);
474 GL(dl_init_static_tls) (imap);
475 assert (imap->l_need_tls_init == 0);
478 /* We have to bump the generation counter. */
483 /* Bump the generation number if necessary. */
484 if (any_tls && __builtin_expect (++GL(dl_tls_generation) == 0, 0))
485 _dl_fatal_printf (N_("\
486 TLS generation counter wrapped! Please report this."));
488 /* Run the initializer functions of new objects. */
489 _dl_init (new, args->argc, args->argv, args->env);
491 /* Now we can make the new map available in the global scope. */
492 if (mode & RTLD_GLOBAL)
493 /* Move the object in the global namespace. */
494 if (add_to_global (new) != 0)
498 /* Mark the object as not deletable if the RTLD_NODELETE flags was
500 if (__builtin_expect (mode & RTLD_NODELETE, 0))
501 new->l_flags_1 |= DF_1_NODELETE;
504 /* We must be the static _dl_open in libc.a. A static program that
505 has loaded a dynamic object now has competition. */
506 __libc_multiple_libcs = 1;
509 /* Let the user know about the opencount. */
510 if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
511 _dl_debug_printf ("opening file=%s [%lu]; direct_opencount=%u\n\n",
512 new->l_name, new->l_ns, new->l_direct_opencount);
517 _dl_open (const char *file, int mode, const void *caller_dlopen, Lmid_t nsid,
518 int argc, char *argv[], char *env[])
520 if ((mode & RTLD_BINDING_MASK) == 0)
521 /* One of the flags must be set. */
522 _dl_signal_error (EINVAL, file, NULL, N_("invalid mode for dlopen()"));
524 /* Make sure we are alone. */
525 __rtld_lock_lock_recursive (GL(dl_load_lock));
527 if (nsid == LM_ID_NEWLM)
529 /* Find a new namespace. */
530 for (nsid = 1; nsid < DL_NNS; ++nsid)
531 if (GL(dl_ns)[nsid]._ns_loaded == NULL)
536 /* No more namespace available. */
537 __rtld_lock_unlock_recursive (GL(dl_load_lock));
539 _dl_signal_error (EINVAL, file, NULL, N_("\
540 no more namespaces available for dlmopen()"));
543 _dl_debug_initialize (0, nsid)->r_state = RT_CONSISTENT;
545 /* Never allow loading a DSO in a namespace which is empty. Such
546 direct placements is only causing problems. Also don't allow
547 loading into a namespace used for auditing. */
548 else if (nsid != LM_ID_BASE && nsid != __LM_ID_CALLER
549 && (GL(dl_ns)[nsid]._ns_nloaded == 0
550 || GL(dl_ns)[nsid]._ns_loaded->l_auditing))
551 _dl_signal_error (EINVAL, file, NULL,
552 N_("invalid target namespace in dlmopen()"));
554 struct dl_open_args args;
557 args.caller_dlopen = caller_dlopen;
558 args.caller_dl_open = RETURN_ADDRESS (0);
566 const char *errstring;
568 int errcode = _dl_catch_error (&objname, &errstring, &malloced,
569 dl_open_worker, &args);
572 /* We must munmap() the cache file. */
576 /* See if an error occurred during loading. */
577 if (__builtin_expect (errstring != NULL, 0))
579 /* Remove the object from memory. It may be in an inconsistent
580 state if relocation failed, for example. */
583 /* Maybe some of the modules which were loaded use TLS.
584 Since it will be removed in the following _dl_close call
585 we have to mark the dtv array as having gaps to fill the
586 holes. This is a pessimistic assumption which won't hurt
587 if not true. There is no need to do this when we are
588 loading the auditing DSOs since TLS has not yet been set
590 if ((mode & __RTLD_AUDIT) == 0)
591 GL(dl_tls_dtv_gaps) = true;
593 _dl_close_worker (args.map);
596 assert (_dl_debug_initialize (0, args.nsid)->r_state == RT_CONSISTENT);
598 /* Release the lock. */
599 __rtld_lock_unlock_recursive (GL(dl_load_lock));
601 /* Make a local copy of the error string so that we can release the
602 memory allocated for it. */
603 size_t len_errstring = strlen (errstring) + 1;
604 char *local_errstring;
605 if (objname == errstring + len_errstring)
607 size_t total_len = len_errstring + strlen (objname) + 1;
608 local_errstring = alloca (total_len);
609 memcpy (local_errstring, errstring, total_len);
610 objname = local_errstring + len_errstring;
614 local_errstring = alloca (len_errstring);
615 memcpy (local_errstring, errstring, len_errstring);
619 free ((char *) errstring);
621 /* Reraise the error. */
622 _dl_signal_error (errcode, objname, NULL, local_errstring);
625 assert (_dl_debug_initialize (0, args.nsid)->r_state == RT_CONSISTENT);
627 /* Release the lock. */
628 __rtld_lock_unlock_recursive (GL(dl_load_lock));
631 DL_STATIC_INIT (args.map);
642 show_scope (struct link_map *new)
646 for (scope_cnt = 0; new->l_scope[scope_cnt] != NULL; ++scope_cnt)
651 numbuf[0] = '0' + scope_cnt;
653 _dl_printf ("scope %s:", numbuf);
655 for (cnt = 0; cnt < new->l_scope[scope_cnt]->r_nlist; ++cnt)
656 if (*new->l_scope[scope_cnt]->r_list[cnt]->l_name)
657 _dl_printf (" %s", new->l_scope[scope_cnt]->r_list[cnt]->l_name);
659 _dl_printf (" <main>");
667 /* Return non-zero if ADDR lies within one of L's segments. */
670 _dl_addr_inside_object (struct link_map *l, const ElfW(Addr) addr)
673 const ElfW(Addr) reladdr = addr - l->l_addr;
676 if (l->l_phdr[n].p_type == PT_LOAD
677 && reladdr - l->l_phdr[n].p_vaddr >= 0
678 && reladdr - l->l_phdr[n].p_vaddr < l->l_phdr[n].p_memsz)