1 /* Load a shared object at runtime, relocate it, and run its initializer.
2 Copyright (C) 1996, 1997, 1998 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 Library General Public License as
7 published by the Free Software Foundation; either version 2 of the
8 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 Library General Public License for more details.
15 You should have received a copy of the GNU Library General Public
16 License along with the GNU C Library; see the file COPYING.LIB. If not,
17 write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA. */
23 #include <bits/libc-lock.h>
24 #include <elf/ldsodefs.h>
27 extern ElfW(Addr) _dl_sysdep_start (void **start_argptr,
28 void (*dl_main) (const ElfW(Phdr) *phdr,
30 ElfW(Addr) *user_entry));
31 weak_extern (_dl_sysdep_start)
33 extern int __libc_multiple_libcs; /* Defined in init-first.c. */
35 extern int __libc_argc;
36 extern char **__libc_argv;
38 extern char **__environ;
40 static size_t _dl_global_scope_alloc;
43 /* During the program run we must not modify the global data of
44 loaded shared object simultanously in two threads. Therefore we
45 protect `_dl_open' and `_dl_close' in dl-close.c.
47 This must be a recursive lock since the initializer function of
48 the loaded object might as well require a call to this function.
49 At this time it is not anymore a problem to modify the tables. */
50 __libc_lock_define_initialized_recursive (, _dl_load_lock)
55 _dl_open (const char *file, int mode)
57 struct link_map *new, *l;
61 /* Make sure we are alone. */
62 __libc_lock_lock (_dl_load_lock);
64 /* Load the named object. */
65 new = _dl_map_object (NULL, file, 0, lt_loaded, 0);
66 if (new->l_searchlist)
68 /* It was already open. */
69 __libc_lock_unlock (_dl_load_lock);
73 /* Load that object's dependencies. */
74 _dl_map_object_deps (new, NULL, 0, 0);
76 /* So far, so good. Now check the versions. */
77 (void) _dl_check_all_versions (new, 0);
79 /* Relocate the objects loaded. We do this in reverse order so that copy
80 relocs of earlier objects overwrite the data written by later objects. */
89 /* We use an indirect call call for _dl_relocate_object because
90 we must avoid using the PLT in the call. If our PLT entry for
91 _dl_relocate_object hasn't been used yet, then the dynamic
92 linker fixup routine will clobber _dl_global_scope during its
93 work. We must be sure that nothing will require a PLT fixup
94 between when _dl_object_relocation_scope returns and when we
95 enter the dynamic linker's code (_dl_relocate_object). */
96 __typeof (_dl_relocate_object) *reloc = &_dl_relocate_object;
98 /* GCC is very clever. If we wouldn't add some magic it would
99 simply optimize away our nice little variable `reloc' and we
100 would result in a not working binary. So let's swing the
102 asm ("" : "=r" (reloc) : "0" (reloc));
104 (*reloc) (l, _dl_object_relocation_scope (l),
105 ((mode & RTLD_BINDING_MASK) == RTLD_LAZY
106 || _dl_profile != NULL), _dl_profile != NULL);
107 *_dl_global_scope_end = NULL;
115 new->l_global = (mode & RTLD_GLOBAL) ? 1 : 0;
118 /* The symbols of the new object and its dependencies are to be
119 introduced into the global scope that will be used to resolve
120 references from other dynamically-loaded objects. */
122 if (_dl_global_scope_alloc == 0)
124 /* This is the first dynamic object given global scope. */
125 _dl_global_scope_alloc = 8;
126 _dl_global_scope = malloc (_dl_global_scope_alloc
127 * sizeof (struct link_map *));
128 if (! _dl_global_scope)
130 _dl_global_scope = _dl_default_scope;
133 _dl_signal_error (ENOMEM, file, "cannot extend global scope");
135 _dl_global_scope[2] = _dl_default_scope[2];
136 _dl_global_scope[3] = new;
137 _dl_global_scope[4] = NULL;
138 _dl_global_scope[5] = NULL;
139 _dl_global_scope_end = &_dl_global_scope [4];
143 if (_dl_global_scope_alloc <
144 (size_t) (_dl_global_scope_end - _dl_global_scope + 2))
146 /* Must extend the list. */
147 struct link_map **new = realloc (_dl_global_scope,
148 _dl_global_scope_alloc * 2
149 * sizeof (struct link_map *));
152 _dl_global_scope_end = new + (_dl_global_scope_end -
154 _dl_global_scope = new;
155 _dl_global_scope_alloc *= 2;
158 /* Append the new object and re-terminate the list. */
159 *_dl_global_scope_end++ = new;
160 /* We keep the list double-terminated so the last element
161 can be filled in for symbol lookups. */
162 _dl_global_scope_end[0] = NULL;
163 _dl_global_scope_end[1] = NULL;
168 /* Notify the debugger we have added some objects. We need to call
169 _dl_debug_initialize in a static program in case dynamic linking has
170 not been used before. */
171 r = _dl_debug_initialize (0);
175 /* Run the initializer functions of new objects. */
176 while (init = _dl_init_next (new))
177 (*(void (*) (int, char **, char **)) init) (__libc_argc, __libc_argv,
180 if (_dl_sysdep_start == NULL)
181 /* We must be the static _dl_open in libc.a. A static program that
182 has loaded a dynamic object now has competition. */
183 __libc_multiple_libcs = 1;
185 /* Release the lock. */
186 __libc_lock_unlock (_dl_load_lock);