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