94677590fed046960497f8bd007e57078fe6613f
[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, 1999, 2000 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 <assert.h>
21 #include <dlfcn.h>
22 #include <errno.h>
23 #include <libintl.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <unistd.h>
27 #include <sys/mman.h>           /* Check whether MAP_COPY is defined.  */
28 #include <sys/param.h>
29 #include <bits/libc-lock.h>
30 #include <ldsodefs.h>
31
32 #include <dl-dst.h>
33
34
35 extern ElfW(Addr) _dl_sysdep_start (void **start_argptr,
36                                     void (*dl_main) (const ElfW(Phdr) *phdr,
37                                                      ElfW(Word) phnum,
38                                                      ElfW(Addr) *user_entry));
39 weak_extern (_dl_sysdep_start)
40
41 /* This function is used to unload the cache file if necessary.  */
42 extern void _dl_unload_cache (void);
43
44 extern int __libc_multiple_libcs;       /* Defined in init-first.c.  */
45
46 extern int __libc_argc;
47 extern char **__libc_argv;
48
49 extern char **__environ;
50
51 extern int _dl_lazy;                    /* Do we do lazy relocations?  */
52
53 /* Undefine the following for debugging.  */
54 /* #define SCOPE_DEBUG 1 */
55 #ifdef SCOPE_DEBUG
56 static void show_scope (struct link_map *new);
57 #endif
58
59 /* During the program run we must not modify the global data of
60    loaded shared object simultanously in two threads.  Therefore we
61    protect `_dl_open' and `_dl_close' in dl-close.c.
62
63    This must be a recursive lock since the initializer function of
64    the loaded object might as well require a call to this function.
65    At this time it is not anymore a problem to modify the tables.  */
66 __libc_lock_define (extern, _dl_load_lock)
67
68 extern size_t _dl_platformlen;
69
70 /* We must be carefull not to leave us in an inconsistent state.  Thus we
71    catch any error and re-raise it after cleaning up.  */
72
73 struct dl_open_args
74 {
75   const char *file;
76   int mode;
77   const void *caller;
78   struct link_map *map;
79 };
80
81 static void
82 dl_open_worker (void *a)
83 {
84   struct dl_open_args *args = a;
85   const char *file = args->file;
86   int mode = args->mode;
87   struct link_map *new, *l;
88   const char *dst;
89   int lazy;
90
91   /* Maybe we have to expand a DST.  */
92   dst = strchr (file, '$');
93   if (dst != NULL)
94     {
95       const void *caller = args->caller;
96       size_t len = strlen (file);
97       size_t required;
98       struct link_map *call_map;
99       char *new_file;
100
101       /* DSTs must not appear in SUID/SGID programs.  */
102       if (__libc_enable_secure)
103         /* This is an error.  */
104         _dl_signal_error (0, "dlopen",
105                           "DST not allowed in SUID/SGID programs");
106
107       /* We have to find out from which object the caller is calling.
108          Find the highest-addressed object that ADDRESS is not below.  */
109       call_map = NULL;
110       for (l = _dl_loaded; l; l = l->l_next)
111         if (l->l_addr != 0 /* Make sure we do not currently set this map up
112                               in this moment.  */
113             && caller >= (const void *) l->l_addr
114             && (call_map == NULL || call_map->l_addr < l->l_addr))
115           call_map = l;
116
117       if (call_map == NULL)
118         /* In this case we assume this is the main application.  */
119         call_map = _dl_loaded;
120
121       /* Determine how much space we need.  We have to allocate the
122          memory locally.  */
123       required = DL_DST_REQUIRED (call_map, file, len, _dl_dst_count (dst, 0));
124
125       /* Get space for the new file name.  */
126       new_file = (char *) alloca (required + 1);
127
128       /* Generate the new file name.  */
129       DL_DST_SUBSTITUTE (call_map, file, new_file, 0);
130
131       /* If the substitution failed don't try to load.  */
132       if (*new_file == '\0')
133         _dl_signal_error (0, "dlopen",
134                           "empty dynamic string token substitution");
135
136       /* Now we have a new file name.  */
137       file = new_file;
138     }
139
140   /* Load the named object.  */
141   args->map = new = _dl_map_object (NULL, file, 0, lt_loaded, 0);
142   if (new->l_searchlist.r_list)
143     /* It was already open.  */
144     return;
145
146   /* Load that object's dependencies.  */
147   _dl_map_object_deps (new, NULL, 0, 0);
148
149   /* So far, so good.  Now check the versions.  */
150   (void) _dl_check_all_versions (new, 0, 0);
151
152 #ifdef SCOPE_DEBUG
153   show_scope (new);
154 #endif
155
156   /* Only do lazy relocation if `LD_BIND_NOW' is not set.  */
157   lazy = (mode & RTLD_BINDING_MASK) == RTLD_LAZY && _dl_lazy;
158
159   /* Relocate the objects loaded.  We do this in reverse order so that copy
160      relocs of earlier objects overwrite the data written by later objects.  */
161
162   l = new;
163   while (l->l_next)
164     l = l->l_next;
165   while (1)
166     {
167       if (! l->l_relocated)
168         {
169 #ifdef SHARED
170           if (_dl_profile != NULL)
171             {
172               /* If this here is the shared object which we want to profile
173                  make sure the profile is started.  We can find out whether
174                  this is necessary or not by observing the `_dl_profile_map'
175                  variable.  If was NULL but is not NULL afterwars we must
176                  start the profiling.  */
177               struct link_map *old_profile_map = _dl_profile_map;
178
179               _dl_relocate_object (l, l->l_scope, 1, 1);
180
181               if (old_profile_map == NULL && _dl_profile_map != NULL)
182                 /* We must prepare the profiling.  */
183                 _dl_start_profile (_dl_profile_map, _dl_profile_output);
184             }
185           else
186 #endif
187             _dl_relocate_object (l, l->l_scope, lazy, 0);
188         }
189
190       if (l == new)
191         break;
192       l = l->l_prev;
193     }
194
195   /* Run the initializer functions of new objects.  */
196   _dl_init (new, __libc_argc, __libc_argv, __environ);
197
198   /* Now we can make the new map available in the global scope.  */
199   if (mode & RTLD_GLOBAL)
200     {
201       struct link_map **new_global;
202       unsigned int to_add = 0;
203       unsigned int cnt;
204
205       /* Count the objects we have to put in the global scope.  */
206       for (cnt = 0; cnt < new->l_searchlist.r_nlist; ++cnt)
207         if (new->l_searchlist.r_list[cnt]->l_global == 0)
208           ++to_add;
209
210       /* The symbols of the new objects and its dependencies are to be
211          introduced into the global scope that will be used to resolve
212          references from other dynamically-loaded objects.
213
214          The global scope is the searchlist in the main link map.  We
215          extend this list if necessary.  There is one problem though:
216          since this structure was allocated very early (before the libc
217          is loaded) the memory it uses is allocated by the malloc()-stub
218          in the ld.so.  When we come here these functions are not used
219          anymore.  Instead the malloc() implementation of the libc is
220          used.  But this means the block from the main map cannot be used
221          in an realloc() call.  Therefore we allocate a completely new
222          array the first time we have to add something to the locale scope.  */
223
224       if (_dl_global_scope_alloc == 0)
225         {
226           /* This is the first dynamic object given global scope.  */
227           _dl_global_scope_alloc = _dl_main_searchlist->r_nlist + to_add + 8;
228           new_global = (struct link_map **)
229             malloc (_dl_global_scope_alloc * sizeof (struct link_map *));
230           if (new_global == NULL)
231             {
232               _dl_global_scope_alloc = 0;
233             nomem:
234               _dl_signal_error (ENOMEM, new->l_libname->name,
235                                 "cannot extend global scope");
236               return;
237             }
238
239           /* Copy over the old entries.  */
240           memcpy (new_global, _dl_main_searchlist->r_list,
241                   (_dl_main_searchlist->r_nlist * sizeof (struct link_map *)));
242
243           _dl_main_searchlist->r_list = new_global;
244         }
245       else if (_dl_main_searchlist->r_nlist + to_add > _dl_global_scope_alloc)
246         {
247           /* We have to extend the existing array of link maps in the
248              main map.  */
249           new_global = (struct link_map **)
250             realloc (_dl_main_searchlist->r_list,
251                      ((_dl_global_scope_alloc + to_add + 8)
252                       * sizeof (struct link_map *)));
253           if (new_global == NULL)
254             goto nomem;
255
256           _dl_global_scope_alloc += to_add + 8;
257           _dl_main_searchlist->r_list = new_global;
258         }
259
260       /* Now add the new entries.  */
261       for (cnt = 0; cnt < new->l_searchlist.r_nlist; ++cnt)
262         {
263           struct link_map *map = new->l_searchlist.r_list[cnt];
264
265           if (map->l_global == 0)
266             {
267               map->l_global = 1;
268               _dl_main_searchlist->r_list[_dl_main_searchlist->r_nlist] = map;
269               ++_dl_main_searchlist->r_nlist;
270             }
271         }
272
273       /* XXX Do we have to add something to r_dupsearchlist???  --drepper */
274     }
275
276   if (_dl_sysdep_start == NULL)
277     /* We must be the static _dl_open in libc.a.  A static program that
278        has loaded a dynamic object now has competition.  */
279     __libc_multiple_libcs = 1;
280 }
281
282
283 void *
284 internal_function
285 _dl_open (const char *file, int mode, const void *caller)
286 {
287   struct dl_open_args args;
288   char *errstring;
289   int errcode;
290
291   if ((mode & RTLD_BINDING_MASK) == 0)
292     /* One of the flags must be set.  */
293     _dl_signal_error (EINVAL, file, _("invalid mode for dlopen()"));
294
295   /* Make sure we are alone.  */
296   __libc_lock_lock (_dl_load_lock);
297
298   args.file = file;
299   args.mode = mode;
300   args.caller = caller;
301   args.map = NULL;
302   errcode = _dl_catch_error (&errstring, dl_open_worker, &args);
303
304 #ifndef MAP_COPY
305   /* We must munmap() the cache file.  */
306   _dl_unload_cache ();
307 #endif
308
309   /* Release the lock.  */
310   __libc_lock_unlock (_dl_load_lock);
311
312   if (errstring)
313     {
314       /* Some error occurred during loading.  */
315       char *local_errstring;
316
317       /* Remove the object from memory.  It may be in an inconsistent
318          state if relocation failed, for example.  */
319       if (args.map)
320         _dl_close (args.map);
321
322       /* Make a local copy of the error string so that we can release the
323          memory allocated for it.  */
324       local_errstring = strdupa (errstring);
325       free (errstring);
326
327       /* Reraise the error.  */
328       _dl_signal_error (errcode, NULL, local_errstring);
329     }
330
331   return args.map;
332 }
333
334
335 #ifdef SCOPE_DEBUG
336 #include <unistd.h>
337
338 static void
339 show_scope (struct link_map *new)
340 {
341   int scope_cnt;
342
343   for (scope_cnt = 0; new->l_scope[scope_cnt] != NULL; ++scope_cnt)
344     {
345       char numbuf[2];
346       unsigned int cnt;
347
348       numbuf[0] = '0' + scope_cnt;
349       numbuf[1] = '\0';
350       _dl_sysdep_message ("scope ", numbuf, ":", NULL);
351
352       for (cnt = 0; cnt < new->l_scope[scope_cnt]->r_nlist; ++cnt)
353         if (*new->l_scope[scope_cnt]->r_list[cnt]->l_name)
354           _dl_sysdep_message (" ",
355                               new->l_scope[scope_cnt]->r_list[cnt]->l_name,
356                               NULL);
357         else
358           _dl_sysdep_message (" <main>", NULL);
359
360       _dl_sysdep_message ("\n", NULL);
361     }
362 }
363 #endif