[!SHARED]: Remove _dl_tls_static_size definition.
[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-2004, 2005 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 <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <unistd.h>
28 #include <sys/mman.h>           /* Check whether MAP_COPY is defined.  */
29 #include <sys/param.h>
30 #include <bits/libc-lock.h>
31 #include <ldsodefs.h>
32 #include <bp-sym.h>
33 #include <caller.h>
34
35 #include <dl-dst.h>
36
37
38 extern ElfW(Addr) _dl_sysdep_start (void **start_argptr,
39                                     void (*dl_main) (const ElfW(Phdr) *phdr,
40                                                      ElfW(Word) phnum,
41                                                      ElfW(Addr) *user_entry));
42 weak_extern (BP_SYM (_dl_sysdep_start))
43
44 extern int __libc_multiple_libcs;       /* Defined in init-first.c.  */
45
46 /* Undefine the following for debugging.  */
47 /* #define SCOPE_DEBUG 1 */
48 #ifdef SCOPE_DEBUG
49 static void show_scope (struct link_map *new);
50 #endif
51
52 /* We must be carefull not to leave us in an inconsistent state.  Thus we
53    catch any error and re-raise it after cleaning up.  */
54
55 struct dl_open_args
56 {
57   const char *file;
58   int mode;
59   /* This is the caller of the dlopen() function.  */
60   const void *caller_dlopen;
61   /* This is the caller if _dl_open().  */
62   const void *caller_dl_open;
63   struct link_map *map;
64   /* Namespace ID.  */
65   Lmid_t nsid;
66   /* Original parameters to the program and the current environment.  */
67   int argc;
68   char **argv;
69   char **env;
70 };
71
72
73 static int
74 add_to_global (struct link_map *new)
75 {
76   struct link_map **new_global;
77   unsigned int to_add = 0;
78   unsigned int cnt;
79
80   /* Count the objects we have to put in the global scope.  */
81   for (cnt = 0; cnt < new->l_searchlist.r_nlist; ++cnt)
82     if (new->l_searchlist.r_list[cnt]->l_global == 0)
83       ++to_add;
84
85   /* The symbols of the new objects and its dependencies are to be
86      introduced into the global scope that will be used to resolve
87      references from other dynamically-loaded objects.
88
89      The global scope is the searchlist in the main link map.  We
90      extend this list if necessary.  There is one problem though:
91      since this structure was allocated very early (before the libc
92      is loaded) the memory it uses is allocated by the malloc()-stub
93      in the ld.so.  When we come here these functions are not used
94      anymore.  Instead the malloc() implementation of the libc is
95      used.  But this means the block from the main map cannot be used
96      in an realloc() call.  Therefore we allocate a completely new
97      array the first time we have to add something to the locale scope.  */
98
99   if (GL(dl_ns)[new->l_ns]._ns_global_scope_alloc == 0)
100     {
101       /* This is the first dynamic object given global scope.  */
102       GL(dl_ns)[new->l_ns]._ns_global_scope_alloc
103         = GL(dl_ns)[new->l_ns]._ns_main_searchlist->r_nlist + to_add + 8;
104       new_global = (struct link_map **)
105         malloc (GL(dl_ns)[new->l_ns]._ns_global_scope_alloc
106                 * sizeof (struct link_map *));
107       if (new_global == NULL)
108         {
109           GL(dl_ns)[new->l_ns]._ns_global_scope_alloc = 0;
110         nomem:
111           _dl_signal_error (ENOMEM, new->l_libname->name, NULL,
112                             N_("cannot extend global scope"));
113           return 1;
114         }
115
116       /* Copy over the old entries.  */
117       GL(dl_ns)[new->l_ns]._ns_main_searchlist->r_list
118         = memcpy (new_global,
119                   GL(dl_ns)[new->l_ns]._ns_main_searchlist->r_list,
120                   (GL(dl_ns)[new->l_ns]._ns_main_searchlist->r_nlist
121                    * sizeof (struct link_map *)));
122     }
123   else if (GL(dl_ns)[new->l_ns]._ns_main_searchlist->r_nlist + to_add
124            > GL(dl_ns)[new->l_ns]._ns_global_scope_alloc)
125     {
126       /* We have to extend the existing array of link maps in the
127          main map.  */
128       new_global = (struct link_map **)
129         realloc (GL(dl_ns)[new->l_ns]._ns_main_searchlist->r_list,
130                  ((GL(dl_ns)[new->l_ns]._ns_global_scope_alloc + to_add + 8)
131                   * sizeof (struct link_map *)));
132       if (new_global == NULL)
133         goto nomem;
134
135       GL(dl_ns)[new->l_ns]._ns_global_scope_alloc += to_add + 8;
136       GL(dl_ns)[new->l_ns]._ns_main_searchlist->r_list = new_global;
137     }
138
139   /* Now add the new entries.  */
140   for (cnt = 0; cnt < new->l_searchlist.r_nlist; ++cnt)
141     {
142       struct link_map *map = new->l_searchlist.r_list[cnt];
143
144       if (map->l_global == 0)
145         {
146           map->l_global = 1;
147           GL(dl_ns)[new->l_ns]._ns_main_searchlist->r_list[GL(dl_ns)[new->l_ns]._ns_main_searchlist->r_nlist]
148             = map;
149           ++GL(dl_ns)[new->l_ns]._ns_main_searchlist->r_nlist;
150         }
151     }
152
153   return 0;
154 }
155
156
157 static void
158 dl_open_worker (void *a)
159 {
160   struct dl_open_args *args = a;
161   const char *file = args->file;
162   int mode = args->mode;
163   struct link_map *new, *l;
164   int lazy;
165   unsigned int i;
166 #ifdef USE_TLS
167   bool any_tls = false;
168 #endif
169   struct link_map *call_map = NULL;
170
171   /* Check whether _dl_open() has been called from a valid DSO.  */
172   if (__check_caller (args->caller_dl_open,
173                       allow_libc|allow_libdl|allow_ldso) != 0)
174     _dl_signal_error (0, "dlopen", NULL, N_("invalid caller"));
175
176   /* Determine the caller's map if necessary.  This is needed in case
177      we have a DST, when we don't know the namespace ID we have to put
178      the new object in, or when the file name has no path in which
179      case we need to look along the RUNPATH/RPATH of the caller.  */
180   const char *dst = strchr (file, '$');
181   if (dst != NULL || args->nsid == __LM_ID_CALLER
182       || strchr (file, '/') == NULL)
183     {
184       const void *caller_dlopen = args->caller_dlopen;
185
186       /* We have to find out from which object the caller is calling.
187          By default we assume this is the main application.  */
188       call_map = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
189
190       for (Lmid_t ns = 0; ns < DL_NNS; ++ns)
191         for (l = GL(dl_ns)[ns]._ns_loaded; l != NULL; l = l->l_next)
192           if (caller_dlopen >= (const void *) l->l_map_start
193               && caller_dlopen < (const void *) l->l_map_end)
194             {
195               /* There must be exactly one DSO for the range of the virtual
196                  memory.  Otherwise something is really broken.  */
197               assert (ns == l->l_ns);
198               call_map = l;
199               goto found_caller;
200             }
201
202     found_caller:
203       if (args->nsid == __LM_ID_CALLER)
204         {
205 #ifndef SHARED
206           /* In statically linked apps there might be no loaded object.  */
207           if (call_map == NULL)
208             args->nsid = LM_ID_BASE;
209           else
210 #endif
211             args->nsid = call_map->l_ns;
212         }
213     }
214
215   assert (_dl_debug_initialize (0, args->nsid)->r_state == RT_CONSISTENT);
216
217   /* Maybe we have to expand a DST.  */
218   if (__builtin_expect (dst != NULL, 0))
219     {
220       size_t len = strlen (file);
221       size_t required;
222       char *new_file;
223
224       /* DSTs must not appear in SUID/SGID programs.  */
225       if (INTUSE(__libc_enable_secure))
226         /* This is an error.  */
227         _dl_signal_error (0, "dlopen", NULL,
228                           N_("DST not allowed in SUID/SGID programs"));
229
230
231       /* Determine how much space we need.  We have to allocate the
232          memory locally.  */
233       required = DL_DST_REQUIRED (call_map, file, len, _dl_dst_count (dst, 0));
234
235       /* Get space for the new file name.  */
236       new_file = (char *) alloca (required + 1);
237
238       /* Generate the new file name.  */
239       _dl_dst_substitute (call_map, file, new_file, 0);
240
241       /* If the substitution failed don't try to load.  */
242       if (*new_file == '\0')
243         _dl_signal_error (0, "dlopen", NULL,
244                           N_("empty dynamic string token substitution"));
245
246       /* Now we have a new file name.  */
247       file = new_file;
248
249       /* It does not matter whether call_map is set even if we
250          computed it only because of the DST.  Since the path contains
251          a slash the value is not used.  See dl-load.c.  */
252     }
253
254   /* Load the named object.  */
255   args->map = new = _dl_map_object (call_map, file, 0, lt_loaded, 0,
256                                     mode | __RTLD_CALLMAP, args->nsid);
257
258   /* If the pointer returned is NULL this means the RTLD_NOLOAD flag is
259      set and the object is not already loaded.  */
260   if (new == NULL)
261     {
262       assert (mode & RTLD_NOLOAD);
263       return;
264     }
265
266   if (__builtin_expect (mode & __RTLD_SPROF, 0))
267     /* This happens only if we load a DSO for 'sprof'.  */
268     return;
269
270   /* This object is directly loaded.  */
271   ++new->l_direct_opencount;
272
273   /* It was already open.  */
274   if (__builtin_expect (new->l_searchlist.r_list != NULL, 0))
275     {
276       /* Let the user know about the opencount.  */
277       if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
278         _dl_debug_printf ("opening file=%s [%lu]; direct_opencount=%u\n\n",
279                           new->l_name, new->l_ns, new->l_direct_opencount);
280
281       /* If the user requested the object to be in the global namespace
282          but it is not so far, add it now.  */
283       if ((mode & RTLD_GLOBAL) && new->l_global == 0)
284         (void) add_to_global (new);
285
286       assert (_dl_debug_initialize (0, args->nsid)->r_state == RT_CONSISTENT);
287
288       return;
289     }
290
291   /* Load that object's dependencies.  */
292   _dl_map_object_deps (new, NULL, 0, 0,
293                        mode & (__RTLD_DLOPEN | RTLD_DEEPBIND | __RTLD_AUDIT));
294
295   /* So far, so good.  Now check the versions.  */
296   for (i = 0; i < new->l_searchlist.r_nlist; ++i)
297     if (new->l_searchlist.r_list[i]->l_real->l_versions == NULL)
298       (void) _dl_check_map_versions (new->l_searchlist.r_list[i]->l_real,
299                                      0, 0);
300
301 #ifdef SCOPE_DEBUG
302   show_scope (new);
303 #endif
304
305 #ifdef SHARED
306   /* Auditing checkpoint: we have added all objects.  */
307   if (__builtin_expect (GLRO(dl_naudit) > 0, 0))
308     {
309       struct link_map *head = GL(dl_ns)[new->l_ns]._ns_loaded;
310       /* Do not call the functions for any auditing object.  */
311       if (head->l_auditing == 0)
312         {
313           struct audit_ifaces *afct = GLRO(dl_audit);
314           for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
315             {
316               if (afct->activity != NULL)
317                 afct->activity (&head->l_audit[cnt].cookie, LA_ACT_CONSISTENT);
318
319               afct = afct->next;
320             }
321         }
322     }
323 #endif
324
325   /* Notify the debugger all new objects are now ready to go.  */
326   struct r_debug *r = _dl_debug_initialize (0, args->nsid);
327   r->r_state = RT_CONSISTENT;
328   _dl_debug_state ();
329
330   /* Only do lazy relocation if `LD_BIND_NOW' is not set.  */
331   lazy = (mode & RTLD_BINDING_MASK) == RTLD_LAZY && GLRO(dl_lazy);
332
333   /* Relocate the objects loaded.  We do this in reverse order so that copy
334      relocs of earlier objects overwrite the data written by later objects.  */
335
336   l = new;
337   while (l->l_next)
338     l = l->l_next;
339   while (1)
340     {
341       if (! l->l_real->l_relocated)
342         {
343 #ifdef SHARED
344           if (GLRO(dl_profile) != NULL)
345             {
346               /* If this here is the shared object which we want to profile
347                  make sure the profile is started.  We can find out whether
348                  this is necessary or not by observing the `_dl_profile_map'
349                  variable.  If was NULL but is not NULL afterwars we must
350                  start the profiling.  */
351               struct link_map *old_profile_map = GL(dl_profile_map);
352
353               _dl_relocate_object (l, l->l_scope, 1, 1);
354
355               if (old_profile_map == NULL && GL(dl_profile_map) != NULL)
356                 {
357                   /* We must prepare the profiling.  */
358                   _dl_start_profile ();
359
360                   /* Prevent unloading the object.  */
361                   GL(dl_profile_map)->l_flags_1 |= DF_1_NODELETE;
362                 }
363             }
364           else
365 #endif
366             _dl_relocate_object (l, l->l_scope, lazy, 0);
367         }
368
369       if (l == new)
370         break;
371       l = l->l_prev;
372     }
373
374   /* If the file is not loaded now as a dependency, add the search
375      list of the newly loaded object to the scope.  */
376   for (i = 0; i < new->l_searchlist.r_nlist; ++i)
377     {
378       struct link_map *imap = new->l_searchlist.r_list[i];
379
380       /* If the initializer has been called already, the object has
381          not been loaded here and now.  */
382       if (imap->l_init_called && imap->l_type == lt_loaded)
383         {
384           struct r_scope_elem **runp = imap->l_scope;
385           size_t cnt = 0;
386
387           while (*runp != NULL)
388             {
389               ++cnt;
390               ++runp;
391             }
392
393           if (*runp != NULL)
394             /* Avoid duplicates.  */
395             continue;
396
397           if (__builtin_expect (cnt + 1 >= imap->l_scope_max, 0))
398             {
399               /* The 'r_scope' array is too small.  Allocate a new one
400                  dynamically.  */
401               struct r_scope_elem **newp;
402               size_t new_size = imap->l_scope_max * 2;
403
404               if (imap->l_scope == imap->l_scope_mem)
405                 {
406                   newp = (struct r_scope_elem **)
407                     malloc (new_size * sizeof (struct r_scope_elem *));
408                   if (newp == NULL)
409                     _dl_signal_error (ENOMEM, "dlopen", NULL,
410                                       N_("cannot create scope list"));
411                   imap->l_scope = memcpy (newp, imap->l_scope,
412                                           cnt * sizeof (imap->l_scope[0]));
413                 }
414               else
415                 {
416                   newp = (struct r_scope_elem **)
417                     realloc (imap->l_scope,
418                              new_size * sizeof (struct r_scope_elem *));
419                   if (newp == NULL)
420                     _dl_signal_error (ENOMEM, "dlopen", NULL,
421                                       N_("cannot create scope list"));
422                   imap->l_scope = newp;
423                 }
424
425               imap->l_scope_max = new_size;
426             }
427
428           imap->l_scope[cnt++] = &new->l_searchlist;
429           imap->l_scope[cnt] = NULL;
430         }
431 #if USE_TLS
432       /* Only add TLS memory if this object is loaded now and
433          therefore is not yet initialized.  */
434       else if (! imap->l_init_called
435                /* Only if the module defines thread local data.  */
436                && __builtin_expect (imap->l_tls_blocksize > 0, 0))
437         {
438           /* Now that we know the object is loaded successfully add
439              modules containing TLS data to the slot info table.  We
440              might have to increase its size.  */
441           _dl_add_to_slotinfo (imap);
442
443           if (imap->l_need_tls_init)
444             {
445               imap->l_need_tls_init = 0;
446 # ifdef SHARED
447               /* Update the slot information data for at least the
448                  generation of the DSO we are allocating data for.  */
449               _dl_update_slotinfo (imap->l_tls_modid);
450 # endif
451
452               GL(dl_init_static_tls) (imap);
453               assert (imap->l_need_tls_init == 0);
454             }
455
456           /* We have to bump the generation counter.  */
457           any_tls = true;
458         }
459 #endif
460     }
461
462 #if USE_TLS
463   /* Bump the generation number if necessary.  */
464   if (any_tls && __builtin_expect (++GL(dl_tls_generation) == 0, 0))
465     _dl_fatal_printf (N_("\
466 TLS generation counter wrapped!  Please report this."));
467 #endif
468
469   /* Run the initializer functions of new objects.  */
470   _dl_init (new, args->argc, args->argv, args->env);
471
472   /* Now we can make the new map available in the global scope.  */
473   if (mode & RTLD_GLOBAL)
474     /* Move the object in the global namespace.  */
475     if (add_to_global (new) != 0)
476       /* It failed.  */
477       return;
478
479   /* Mark the object as not deletable if the RTLD_NODELETE flags was
480      passed.  */
481   if (__builtin_expect (mode & RTLD_NODELETE, 0))
482     new->l_flags_1 |= DF_1_NODELETE;
483
484 #ifndef SHARED
485   /* We must be the static _dl_open in libc.a.  A static program that
486      has loaded a dynamic object now has competition.  */
487   __libc_multiple_libcs = 1;
488 #endif
489
490   /* Let the user know about the opencount.  */
491   if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
492     _dl_debug_printf ("opening file=%s [%lu]; direct_opencount=%u\n\n",
493                       new->l_name, new->l_ns, new->l_direct_opencount);
494 }
495
496
497 void *
498 _dl_open (const char *file, int mode, const void *caller_dlopen, Lmid_t nsid,
499           int argc, char *argv[], char *env[])
500 {
501   if ((mode & RTLD_BINDING_MASK) == 0)
502     /* One of the flags must be set.  */
503     _dl_signal_error (EINVAL, file, NULL, N_("invalid mode for dlopen()"));
504
505   /* Make sure we are alone.  */
506   __rtld_lock_lock_recursive (GL(dl_load_lock));
507
508   if (nsid == LM_ID_NEWLM)
509     {
510       /* Find a new namespace.  */
511       for (nsid = 1; nsid < DL_NNS; ++nsid)
512         if (GL(dl_ns)[nsid]._ns_loaded == NULL)
513           break;
514
515       if (nsid == DL_NNS)
516         {
517           /* No more namespace available.  */
518           __rtld_lock_unlock_recursive (GL(dl_load_lock));
519
520           _dl_signal_error (EINVAL, file, NULL, N_("\
521 no more namespaces available for dlmopen()"));
522         }
523
524       _dl_debug_initialize (0, nsid)->r_state = RT_CONSISTENT;
525     }
526   /* Never allow loading a DSO in a namespace which is empty.  Such
527      direct placements is only causing problems.  Also don't allow
528      loading into a namespace used for auditing.  */
529   else if (nsid != LM_ID_BASE && nsid != __LM_ID_CALLER
530            && (GL(dl_ns)[nsid]._ns_nloaded == 0
531                || GL(dl_ns)[nsid]._ns_loaded->l_auditing))
532     _dl_signal_error (EINVAL, file, NULL,
533                       N_("invalid target namespace in dlmopen()"));
534
535   struct dl_open_args args;
536   args.file = file;
537   args.mode = mode;
538   args.caller_dlopen = caller_dlopen;
539   args.caller_dl_open = RETURN_ADDRESS (0);
540   args.map = NULL;
541   args.nsid = nsid;
542   args.argc = argc;
543   args.argv = argv;
544   args.env = env;
545
546   const char *objname;
547   const char *errstring;
548   bool malloced;
549   int errcode = _dl_catch_error (&objname, &errstring, &malloced,
550                                  dl_open_worker, &args);
551
552 #ifndef MAP_COPY
553   /* We must munmap() the cache file.  */
554   _dl_unload_cache ();
555 #endif
556
557   /* Release the lock.  */
558   __rtld_lock_unlock_recursive (GL(dl_load_lock));
559
560   if (__builtin_expect (errstring != NULL, 0))
561     {
562       /* Some error occurred during loading.  */
563       char *local_errstring;
564       size_t len_errstring;
565
566       /* Remove the object from memory.  It may be in an inconsistent
567          state if relocation failed, for example.  */
568       if (args.map)
569         {
570 #ifdef USE_TLS
571           /* Maybe some of the modules which were loaded use TLS.
572              Since it will be removed in the following _dl_close call
573              we have to mark the dtv array as having gaps to fill the
574              holes.  This is a pessimistic assumption which won't hurt
575              if not true.  There is no need to do this when we are
576              loading the auditing DSOs since TLS has not yet been set
577              up.  */
578           if ((mode & __RTLD_AUDIT) == 0)
579             GL(dl_tls_dtv_gaps) = true;
580 #endif
581
582           _dl_close (args.map);
583         }
584
585       /* Make a local copy of the error string so that we can release the
586          memory allocated for it.  */
587       len_errstring = strlen (errstring) + 1;
588       if (objname == errstring + len_errstring)
589         {
590           size_t total_len = len_errstring + strlen (objname) + 1;
591           local_errstring = alloca (total_len);
592           memcpy (local_errstring, errstring, total_len);
593           objname = local_errstring + len_errstring;
594         }
595       else
596         {
597           local_errstring = alloca (len_errstring);
598           memcpy (local_errstring, errstring, len_errstring);
599         }
600
601       if (malloced)
602         free ((char *) errstring);
603
604       assert (_dl_debug_initialize (0, args.nsid)->r_state == RT_CONSISTENT);
605
606       /* Reraise the error.  */
607       _dl_signal_error (errcode, objname, NULL, local_errstring);
608     }
609
610   assert (_dl_debug_initialize (0, args.nsid)->r_state == RT_CONSISTENT);
611
612 #ifndef SHARED
613   DL_STATIC_INIT (args.map);
614 #endif
615
616   return args.map;
617 }
618
619
620 #ifdef SCOPE_DEBUG
621 #include <unistd.h>
622
623 static void
624 show_scope (struct link_map *new)
625 {
626   int scope_cnt;
627
628   for (scope_cnt = 0; new->l_scope[scope_cnt] != NULL; ++scope_cnt)
629     {
630       char numbuf[2];
631       unsigned int cnt;
632
633       numbuf[0] = '0' + scope_cnt;
634       numbuf[1] = '\0';
635       _dl_printf ("scope %s:", numbuf);
636
637       for (cnt = 0; cnt < new->l_scope[scope_cnt]->r_nlist; ++cnt)
638         if (*new->l_scope[scope_cnt]->r_list[cnt]->l_name)
639           _dl_printf (" %s", new->l_scope[scope_cnt]->r_list[cnt]->l_name);
640         else
641           _dl_printf (" <main>");
642
643       _dl_printf ("\n");
644     }
645 }
646 #endif