2001-08-22 Roland McGrath <roland@frob.com>
[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,2001 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 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.
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    Lesser General Public License for more details.
14
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
18    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 #include <bp-sym.h>
32
33 #include <dl-dst.h>
34 #include <stdio-common/_itoa.h>
35
36
37 extern ElfW(Addr) _dl_sysdep_start (void **start_argptr,
38                                     void (*dl_main) (const ElfW(Phdr) *phdr,
39                                                      ElfW(Word) phnum,
40                                                      ElfW(Addr) *user_entry));
41 weak_extern (BP_SYM (_dl_sysdep_start))
42
43 /* This function is used to unload the cache file if necessary.  */
44 extern void _dl_unload_cache (void);
45
46 extern int __libc_multiple_libcs;       /* Defined in init-first.c.  */
47
48 extern int __libc_argc;
49 extern char **__libc_argv;
50
51 extern char **__environ;
52
53 extern int _dl_lazy;                    /* Do we do lazy relocations?  */
54
55 /* Undefine the following for debugging.  */
56 /* #define SCOPE_DEBUG 1 */
57 #ifdef SCOPE_DEBUG
58 static void show_scope (struct link_map *new);
59 #endif
60
61 extern size_t _dl_platformlen;
62
63 /* We must be carefull not to leave us in an inconsistent state.  Thus we
64    catch any error and re-raise it after cleaning up.  */
65
66 struct dl_open_args
67 {
68   const char *file;
69   int mode;
70   const void *caller;
71   struct link_map *map;
72 };
73
74
75 static int
76 add_to_global (struct link_map *new)
77 {
78   struct link_map **new_global;
79   unsigned int to_add = 0;
80   unsigned int cnt;
81
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)
85       ++to_add;
86
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.
90
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.  */
100
101   if (_dl_global_scope_alloc == 0)
102     {
103       /* This is the first dynamic object given global scope.  */
104       _dl_global_scope_alloc = _dl_main_searchlist->r_nlist + to_add + 8;
105       new_global = (struct link_map **)
106         malloc (_dl_global_scope_alloc * sizeof (struct link_map *));
107       if (new_global == NULL)
108         {
109           _dl_global_scope_alloc = 0;
110         nomem:
111           _dl_signal_error (ENOMEM, new->l_libname->name,
112                             N_("cannot extend global scope"));
113           return 1;
114         }
115
116       /* Copy over the old entries.  */
117       memcpy (new_global, _dl_main_searchlist->r_list,
118               (_dl_main_searchlist->r_nlist * sizeof (struct link_map *)));
119
120       _dl_main_searchlist->r_list = new_global;
121     }
122   else if (_dl_main_searchlist->r_nlist + to_add > _dl_global_scope_alloc)
123     {
124       /* We have to extend the existing array of link maps in the
125          main map.  */
126       new_global = (struct link_map **)
127         realloc (_dl_main_searchlist->r_list,
128                  ((_dl_global_scope_alloc + to_add + 8)
129                   * sizeof (struct link_map *)));
130       if (new_global == NULL)
131         goto nomem;
132
133       _dl_global_scope_alloc += to_add + 8;
134       _dl_main_searchlist->r_list = new_global;
135     }
136
137   /* Now add the new entries.  */
138   for (cnt = 0; cnt < new->l_searchlist.r_nlist; ++cnt)
139     {
140       struct link_map *map = new->l_searchlist.r_list[cnt];
141
142       if (map->l_global == 0)
143         {
144           map->l_global = 1;
145           _dl_main_searchlist->r_list[_dl_main_searchlist->r_nlist] = map;
146           ++_dl_main_searchlist->r_nlist;
147         }
148     }
149
150   return 0;
151 }
152
153
154 static void
155 dl_open_worker (void *a)
156 {
157   struct dl_open_args *args = a;
158   const char *file = args->file;
159   int mode = args->mode;
160   struct link_map *new, *l;
161   const char *dst;
162   int lazy;
163   unsigned int i;
164
165   /* Maybe we have to expand a DST.  */
166   dst = strchr (file, '$');
167   if (dst != NULL)
168     {
169       const void *caller = args->caller;
170       size_t len = strlen (file);
171       size_t required;
172       struct link_map *call_map;
173       char *new_file;
174
175       /* DSTs must not appear in SUID/SGID programs.  */
176       if (__libc_enable_secure)
177         /* This is an error.  */
178         _dl_signal_error (0, "dlopen",
179                           N_("DST not allowed in SUID/SGID programs"));
180
181       /* We have to find out from which object the caller is calling.  */
182       call_map = NULL;
183       for (l = _dl_loaded; l; l = l->l_next)
184         if (caller >= (const void *) l->l_map_start
185             && caller < (const void *) l->l_map_end)
186           {
187             /* There must be exactly one DSO for the range of the virtual
188                memory.  Otherwise something is really broken.  */
189             call_map = l;
190             break;
191           }
192
193       if (call_map == NULL)
194         /* In this case we assume this is the main application.  */
195         call_map = _dl_loaded;
196
197       /* Determine how much space we need.  We have to allocate the
198          memory locally.  */
199       required = DL_DST_REQUIRED (call_map, file, len, _dl_dst_count (dst, 0));
200
201       /* Get space for the new file name.  */
202       new_file = (char *) alloca (required + 1);
203
204       /* Generate the new file name.  */
205       DL_DST_SUBSTITUTE (call_map, file, new_file, 0);
206
207       /* If the substitution failed don't try to load.  */
208       if (*new_file == '\0')
209         _dl_signal_error (0, "dlopen",
210                           N_("empty dynamic string token substitution"));
211
212       /* Now we have a new file name.  */
213       file = new_file;
214     }
215
216   /* Load the named object.  */
217   args->map = new = _dl_map_object (NULL, file, 0, lt_loaded, 0,
218                                     mode);
219
220   /* If the pointer returned is NULL this means the RTLD_NOLOAD flag is
221      set and the object is not already loaded.  */
222   if (new == NULL)
223     {
224       assert (mode & RTLD_NOLOAD);
225       return;
226     }
227
228   /* It was already open.  */
229   if (new->l_searchlist.r_list != NULL)
230     {
231       /* Let the user know about the opencount.  */
232       if (__builtin_expect (_dl_debug_mask & DL_DEBUG_FILES, 0))
233         _dl_debug_printf ("opening file=%s; opencount == %u\n\n",
234                           new->l_name, new->l_opencount);
235
236       /* If the user requested the object to be in the global namespace
237          but it is not so far, add it now.  */
238       if ((mode & RTLD_GLOBAL) && new->l_global == 0)
239         (void) add_to_global (new);
240
241       /* Increment just the reference counter of the object.  */
242       ++new->l_opencount;
243
244       return;
245     }
246
247   /* Load that object's dependencies.  */
248   _dl_map_object_deps (new, NULL, 0, 0);
249
250   /* So far, so good.  Now check the versions.  */
251   for (i = 0; i < new->l_searchlist.r_nlist; ++i)
252     if (new->l_searchlist.r_list[i]->l_versions == NULL)
253       (void) _dl_check_map_versions (new->l_searchlist.r_list[i], 0, 0);
254
255 #ifdef SCOPE_DEBUG
256   show_scope (new);
257 #endif
258
259   /* Only do lazy relocation if `LD_BIND_NOW' is not set.  */
260   lazy = (mode & RTLD_BINDING_MASK) == RTLD_LAZY && _dl_lazy;
261
262   /* Relocate the objects loaded.  We do this in reverse order so that copy
263      relocs of earlier objects overwrite the data written by later objects.  */
264
265   l = new;
266   while (l->l_next)
267     l = l->l_next;
268   while (1)
269     {
270       if (! l->l_relocated)
271         {
272 #ifdef SHARED
273           if (_dl_profile != NULL)
274             {
275               /* If this here is the shared object which we want to profile
276                  make sure the profile is started.  We can find out whether
277                  this is necessary or not by observing the `_dl_profile_map'
278                  variable.  If was NULL but is not NULL afterwars we must
279                  start the profiling.  */
280               struct link_map *old_profile_map = _dl_profile_map;
281
282               _dl_relocate_object (l, l->l_scope, 1, 1);
283
284               if (old_profile_map == NULL && _dl_profile_map != NULL)
285                 /* We must prepare the profiling.  */
286                 _dl_start_profile (_dl_profile_map, _dl_profile_output);
287             }
288           else
289 #endif
290             _dl_relocate_object (l, l->l_scope, lazy, 0);
291         }
292
293       if (l == new)
294         break;
295       l = l->l_prev;
296     }
297
298   /* Increment the open count for all dependencies.  */
299   for (i = 0; i < new->l_searchlist.r_nlist; ++i)
300     ++new->l_searchlist.r_list[i]->l_opencount;
301
302   /* Run the initializer functions of new objects.  */
303   _dl_init (new, __libc_argc, __libc_argv, __environ);
304
305   /* Now we can make the new map available in the global scope.  */
306   if (mode & RTLD_GLOBAL)
307     /* Move the object in the global namespace.  */
308     if (add_to_global (new) != 0)
309       /* It failed.  */
310       return;
311
312   /* Mark the object as not deletable if the RTLD_NODELETE flags was
313      passed.  */
314   if (__builtin_expect (mode & RTLD_NODELETE, 0))
315     new->l_flags_1 |= DF_1_NODELETE;
316
317   if (_dl_sysdep_start == NULL)
318     /* We must be the static _dl_open in libc.a.  A static program that
319        has loaded a dynamic object now has competition.  */
320     __libc_multiple_libcs = 1;
321
322   /* Let the user know about the opencount.  */
323   if (__builtin_expect (_dl_debug_mask & DL_DEBUG_FILES, 0))
324     _dl_debug_printf ("opening file=%s; opencount == %u\n\n",
325                       new->l_name, new->l_opencount);
326 }
327
328
329 void *
330 internal_function
331 _dl_open (const char *file, int mode, const void *caller)
332 {
333   struct dl_open_args args;
334   const char *objname;
335   const char *errstring;
336   int errcode;
337
338   if ((mode & RTLD_BINDING_MASK) == 0)
339     /* One of the flags must be set.  */
340     _dl_signal_error (EINVAL, file, N_("invalid mode for dlopen()"));
341
342   /* Make sure we are alone.  */
343   __libc_lock_lock_recursive (_dl_load_lock);
344
345   args.file = file;
346   args.mode = mode;
347   args.caller = caller;
348   args.map = NULL;
349   errcode = _dl_catch_error (&objname, &errstring, dl_open_worker, &args);
350
351 #ifndef MAP_COPY
352   /* We must munmap() the cache file.  */
353   _dl_unload_cache ();
354 #endif
355
356   /* Release the lock.  */
357   __libc_lock_unlock_recursive (_dl_load_lock);
358
359   if (errstring)
360     {
361       /* Some error occurred during loading.  */
362       char *local_errstring;
363       size_t len_errstring;
364
365       /* Remove the object from memory.  It may be in an inconsistent
366          state if relocation failed, for example.  */
367       if (args.map)
368         {
369           unsigned int i;
370
371           /* Increment open counters for all objects since this has
372              not happened yet.  */
373           for (i = 0; i < args.map->l_searchlist.r_nlist; ++i)
374             ++args.map->l_searchlist.r_list[i]->l_opencount;
375
376           _dl_close (args.map);
377         }
378
379       /* Make a local copy of the error string so that we can release the
380          memory allocated for it.  */
381       len_errstring = strlen (errstring) + 1;
382       if (objname == errstring + len_errstring)
383         {
384           size_t total_len = len_errstring + strlen (objname) + 1;
385           local_errstring = alloca (total_len);
386           memcpy (local_errstring, errstring, total_len);
387           objname = local_errstring + len_errstring;
388         }
389       else
390         {
391           local_errstring = alloca (len_errstring);
392           memcpy (local_errstring, errstring, len_errstring);
393         }
394
395       if (errstring != _dl_out_of_memory)
396         free ((char *) errstring);
397
398       /* Reraise the error.  */
399       _dl_signal_error (errcode, objname, local_errstring);
400     }
401
402 #ifndef SHARED
403   DL_STATIC_INIT (args.map);
404 #endif
405
406   return args.map;
407 }
408
409
410 #ifdef SCOPE_DEBUG
411 #include <unistd.h>
412
413 static void
414 show_scope (struct link_map *new)
415 {
416   int scope_cnt;
417
418   for (scope_cnt = 0; new->l_scope[scope_cnt] != NULL; ++scope_cnt)
419     {
420       char numbuf[2];
421       unsigned int cnt;
422
423       numbuf[0] = '0' + scope_cnt;
424       numbuf[1] = '\0';
425       _dl_printf ("scope %s:", numbuf);
426
427       for (cnt = 0; cnt < new->l_scope[scope_cnt]->r_nlist; ++cnt)
428         if (*new->l_scope[scope_cnt]->r_list[cnt]->l_name)
429           _dl_printf (" %s", new->l_scope[scope_cnt]->r_list[cnt]->l_name)
430         else
431           _dl_printf (" <main>", NULL);
432
433       _dl_printf ("\n", NULL);
434     }
435 }
436 #endif