Regenerated
[kopensolaris-gnu/glibc.git] / elf / dl-open.c
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.
4
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.
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    Library General Public License for more details.
14
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.  */
19
20 #include <dlfcn.h>
21 #include <errno.h>
22 #include <stdlib.h>
23 #include <bits/libc-lock.h>
24 #include <elf/ldsodefs.h>
25
26
27 extern ElfW(Addr) _dl_sysdep_start (void **start_argptr,
28                                     void (*dl_main) (const ElfW(Phdr) *phdr,
29                                                      ElfW(Word) phnum,
30                                                      ElfW(Addr) *user_entry));
31 weak_extern (_dl_sysdep_start)
32
33 extern int __libc_multiple_libcs;       /* Defined in init-first.c.  */
34
35 extern int __libc_argc;
36 extern char **__libc_argv;
37
38 extern char **__environ;
39
40 static size_t _dl_global_scope_alloc;
41
42
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.
46
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)
51
52
53 struct link_map *
54 internal_function
55 _dl_open (const char *file, int mode)
56 {
57   struct link_map *new, *l;
58   ElfW(Addr) init;
59   struct r_debug *r;
60
61   /* Make sure we are alone.  */
62   __libc_lock_lock (_dl_load_lock);
63
64   /* Load the named object.  */
65   new = _dl_map_object (NULL, file, 0, lt_loaded, 0);
66   if (new->l_searchlist)
67     {
68       /* It was already open.  */
69       __libc_lock_unlock (_dl_load_lock);
70       return new;
71     }
72
73   /* Load that object's dependencies.  */
74   _dl_map_object_deps (new, NULL, 0, 0);
75
76   /* So far, so good.  Now check the versions.  */
77   (void) _dl_check_all_versions (new, 0);
78
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.  */
81
82   l = new;
83   while (l->l_next)
84     l = l->l_next;
85   while (1)
86     {
87       if (! l->l_relocated)
88         {
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;
97
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
101              magic ward.  */
102           asm ("" : "=r" (reloc) : "0" (reloc));
103
104           (*reloc) (l, _dl_object_relocation_scope (l),
105                     (mode & RTLD_BINDING_MASK) == RTLD_LAZY);
106           *_dl_global_scope_end = NULL;
107         }
108
109       if (l == new)
110         break;
111       l = l->l_prev;
112     }
113
114   new->l_global = (mode & RTLD_GLOBAL) ? 1 : 0;
115   if (new->l_global)
116     {
117       /* The symbols of the new object and its dependencies are to be
118          introduced into the global scope that will be used to resolve
119          references from other dynamically-loaded objects.  */
120
121       if (_dl_global_scope_alloc == 0)
122         {
123           /* This is the first dynamic object given global scope.  */
124           _dl_global_scope_alloc = 8;
125           _dl_global_scope = malloc (_dl_global_scope_alloc
126                                      * sizeof (struct link_map *));
127           if (! _dl_global_scope)
128             {
129               _dl_global_scope = _dl_default_scope;
130             nomem:
131               _dl_close (new);
132               _dl_signal_error (ENOMEM, file, "cannot extend global scope");
133             }
134           _dl_global_scope[2] = _dl_default_scope[2];
135           _dl_global_scope[3] = new;
136           _dl_global_scope[4] = NULL;
137           _dl_global_scope[5] = NULL;
138           _dl_global_scope_end = &_dl_global_scope [4];
139         }
140       else
141         {
142           if (_dl_global_scope_alloc <
143               (size_t) (_dl_global_scope_end - _dl_global_scope + 2))
144             {
145               /* Must extend the list.  */
146               struct link_map **new = realloc (_dl_global_scope,
147                                                _dl_global_scope_alloc * 2
148                                                * sizeof (struct link_map *));
149               if (! new)
150                 goto nomem;
151               _dl_global_scope_end = new + (_dl_global_scope_end -
152                                             _dl_global_scope);
153               _dl_global_scope = new;
154               _dl_global_scope_alloc *= 2;
155             }
156
157           /* Append the new object and re-terminate the list.  */
158           *_dl_global_scope_end++ = new;
159           /* We keep the list double-terminated so the last element
160              can be filled in for symbol lookups.  */
161           _dl_global_scope_end[0] = NULL;
162           _dl_global_scope_end[1] = NULL;
163         }
164     }
165
166
167   /* Notify the debugger we have added some objects.  We need to call
168      _dl_debug_initialize in a static program in case dynamic linking has
169      not been used before.  */
170   r = _dl_debug_initialize (0);
171   r->r_state = RT_ADD;
172   _dl_debug_state ();
173
174   /* Run the initializer functions of new objects.  */
175   while (init = _dl_init_next (new))
176     (*(void (*) (int, char **, char **)) init) (__libc_argc, __libc_argv,
177                                                 __environ);
178
179   if (_dl_sysdep_start == NULL)
180     /* We must be the static _dl_open in libc.a.  A static program that
181        has loaded a dynamic object now has competition.  */
182     __libc_multiple_libcs = 1;
183
184   /* Release the lock.  */
185   __libc_lock_unlock (_dl_load_lock);
186
187   return new;
188 }