Use catomic_* operations instead of atomic_*.
[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 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       /* Determine how much space we need.  We have to allocate the
225          memory locally.  */
226       required = DL_DST_REQUIRED (call_map, file, len, _dl_dst_count (dst, 0));
227
228       /* Get space for the new file name.  */
229       new_file = (char *) alloca (required + 1);
230
231       /* Generate the new file name.  */
232       _dl_dst_substitute (call_map, file, new_file, 0);
233
234       /* If the substitution failed don't try to load.  */
235       if (*new_file == '\0')
236         _dl_signal_error (0, "dlopen", NULL,
237                           N_("empty dynamic string token substitution"));
238
239       /* Now we have a new file name.  */
240       file = new_file;
241
242       /* It does not matter whether call_map is set even if we
243          computed it only because of the DST.  Since the path contains
244          a slash the value is not used.  See dl-load.c.  */
245     }
246
247   /* Load the named object.  */
248   args->map = new = _dl_map_object (call_map, file, 0, lt_loaded, 0,
249                                     mode | __RTLD_CALLMAP, args->nsid);
250
251   /* If the pointer returned is NULL this means the RTLD_NOLOAD flag is
252      set and the object is not already loaded.  */
253   if (new == NULL)
254     {
255       assert (mode & RTLD_NOLOAD);
256       return;
257     }
258
259   if (__builtin_expect (mode & __RTLD_SPROF, 0))
260     /* This happens only if we load a DSO for 'sprof'.  */
261     return;
262
263   /* This object is directly loaded.  */
264   ++new->l_direct_opencount;
265
266   /* It was already open.  */
267   if (__builtin_expect (new->l_searchlist.r_list != NULL, 0))
268     {
269       /* Let the user know about the opencount.  */
270       if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
271         _dl_debug_printf ("opening file=%s [%lu]; direct_opencount=%u\n\n",
272                           new->l_name, new->l_ns, new->l_direct_opencount);
273
274       /* If the user requested the object to be in the global namespace
275          but it is not so far, add it now.  */
276       if ((mode & RTLD_GLOBAL) && new->l_global == 0)
277         (void) add_to_global (new);
278
279       assert (_dl_debug_initialize (0, args->nsid)->r_state == RT_CONSISTENT);
280
281       return;
282     }
283
284   /* Load that object's dependencies.  */
285   _dl_map_object_deps (new, NULL, 0, 0,
286                        mode & (__RTLD_DLOPEN | RTLD_DEEPBIND | __RTLD_AUDIT));
287
288   /* So far, so good.  Now check the versions.  */
289   for (i = 0; i < new->l_searchlist.r_nlist; ++i)
290     if (new->l_searchlist.r_list[i]->l_real->l_versions == NULL)
291       (void) _dl_check_map_versions (new->l_searchlist.r_list[i]->l_real,
292                                      0, 0);
293
294 #ifdef SCOPE_DEBUG
295   show_scope (new);
296 #endif
297
298 #ifdef SHARED
299   /* Auditing checkpoint: we have added all objects.  */
300   if (__builtin_expect (GLRO(dl_naudit) > 0, 0))
301     {
302       struct link_map *head = GL(dl_ns)[new->l_ns]._ns_loaded;
303       /* Do not call the functions for any auditing object.  */
304       if (head->l_auditing == 0)
305         {
306           struct audit_ifaces *afct = GLRO(dl_audit);
307           for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
308             {
309               if (afct->activity != NULL)
310                 afct->activity (&head->l_audit[cnt].cookie, LA_ACT_CONSISTENT);
311
312               afct = afct->next;
313             }
314         }
315     }
316 #endif
317
318   /* Notify the debugger all new objects are now ready to go.  */
319   struct r_debug *r = _dl_debug_initialize (0, args->nsid);
320   r->r_state = RT_CONSISTENT;
321   _dl_debug_state ();
322
323   /* Only do lazy relocation if `LD_BIND_NOW' is not set.  */
324   lazy = (mode & RTLD_BINDING_MASK) == RTLD_LAZY && GLRO(dl_lazy);
325
326   /* Relocate the objects loaded.  We do this in reverse order so that copy
327      relocs of earlier objects overwrite the data written by later objects.  */
328
329   l = new;
330   while (l->l_next)
331     l = l->l_next;
332   while (1)
333     {
334       if (! l->l_real->l_relocated)
335         {
336 #ifdef SHARED
337           if (__builtin_expect (GLRO(dl_profile) != NULL, 0))
338             {
339               /* If this here is the shared object which we want to profile
340                  make sure the profile is started.  We can find out whether
341                  this is necessary or not by observing the `_dl_profile_map'
342                  variable.  If was NULL but is not NULL afterwars we must
343                  start the profiling.  */
344               struct link_map *old_profile_map = GL(dl_profile_map);
345
346               _dl_relocate_object (l, l->l_scoperec->scope, 1, 1);
347
348               if (old_profile_map == NULL && GL(dl_profile_map) != NULL)
349                 {
350                   /* We must prepare the profiling.  */
351                   _dl_start_profile ();
352
353                   /* Prevent unloading the object.  */
354                   GL(dl_profile_map)->l_flags_1 |= DF_1_NODELETE;
355                 }
356             }
357           else
358 #endif
359             _dl_relocate_object (l, l->l_scoperec->scope, lazy, 0);
360         }
361
362       if (l == new)
363         break;
364       l = l->l_prev;
365     }
366
367   /* If the file is not loaded now as a dependency, add the search
368      list of the newly loaded object to the scope.  */
369   for (i = 0; i < new->l_searchlist.r_nlist; ++i)
370     {
371       struct link_map *imap = new->l_searchlist.r_list[i];
372
373       /* If the initializer has been called already, the object has
374          not been loaded here and now.  */
375       if (imap->l_init_called && imap->l_type == lt_loaded)
376         {
377           struct r_scope_elem **runp = imap->l_scoperec->scope;
378           size_t cnt = 0;
379
380           while (*runp != NULL)
381             {
382               if (*runp == &new->l_searchlist)
383                 break;
384               ++cnt;
385               ++runp;
386             }
387
388           if (*runp != NULL)
389             /* Avoid duplicates.  */
390             continue;
391
392           if (__builtin_expect (cnt + 1 >= imap->l_scope_max, 0))
393             {
394               /* The 'r_scope' array is too small.  Allocate a new one
395                  dynamically.  */
396               size_t new_size;
397               struct r_scoperec *newp;
398
399               if (imap->l_scoperec != &imap->l_scoperec_mem
400                   && imap->l_scope_max < NINIT_SCOPE_ELEMS (imap)
401                   && imap->l_scoperec_mem.nusers == 0)
402                 {
403                   new_size = NINIT_SCOPE_ELEMS (imap);
404                   newp = &imap->l_scoperec_mem;
405                 }
406               else
407                 {
408                   new_size = imap->l_scope_max * 2;
409                   newp = (struct r_scoperec *)
410                     malloc (sizeof (struct r_scoperec)
411                             + new_size * sizeof (struct r_scope_elem *));
412                   if (newp == NULL)
413                     _dl_signal_error (ENOMEM, "dlopen", NULL,
414                                       N_("cannot create scope list"));
415                 }
416
417               newp->nusers = 0;
418               newp->remove_after_use = false;
419               newp->notify = false;
420               memcpy (newp->scope, imap->l_scoperec->scope,
421                       cnt * sizeof (imap->l_scoperec->scope[0]));
422               struct r_scoperec *old = imap->l_scoperec;
423
424               if (old == &imap->l_scoperec_mem)
425                 imap->l_scoperec = newp;
426               else
427                 {
428                   __rtld_mrlock_change (imap->l_scoperec_lock);
429                   imap->l_scoperec = newp;
430                   __rtld_mrlock_done (imap->l_scoperec_lock);
431
432                   catomic_increment (&old->nusers);
433                   old->remove_after_use = true;
434                   if (catomic_decrement_val (&old->nusers) == 0)
435                     /* No user, we can free it here and now.  */
436                     free (old);
437                 }
438
439               imap->l_scope_max = new_size;
440             }
441
442           /* First terminate the extended list.  Otherwise a thread
443              might use the new last element and then use the garbage
444              at offset IDX+1.  */
445           imap->l_scoperec->scope[cnt + 1] = NULL;
446           atomic_write_barrier ();
447           imap->l_scoperec->scope[cnt] = &new->l_searchlist;
448         }
449 #if USE_TLS
450       /* Only add TLS memory if this object is loaded now and
451          therefore is not yet initialized.  */
452       else if (! imap->l_init_called
453                /* Only if the module defines thread local data.  */
454                && __builtin_expect (imap->l_tls_blocksize > 0, 0))
455         {
456           /* Now that we know the object is loaded successfully add
457              modules containing TLS data to the slot info table.  We
458              might have to increase its size.  */
459           _dl_add_to_slotinfo (imap);
460
461           if (imap->l_need_tls_init)
462             {
463               imap->l_need_tls_init = 0;
464 # ifdef SHARED
465               /* Update the slot information data for at least the
466                  generation of the DSO we are allocating data for.  */
467               _dl_update_slotinfo (imap->l_tls_modid);
468 # endif
469
470               GL(dl_init_static_tls) (imap);
471               assert (imap->l_need_tls_init == 0);
472             }
473
474           /* We have to bump the generation counter.  */
475           any_tls = true;
476         }
477 #endif
478     }
479
480 #if USE_TLS
481   /* Bump the generation number if necessary.  */
482   if (any_tls && __builtin_expect (++GL(dl_tls_generation) == 0, 0))
483     _dl_fatal_printf (N_("\
484 TLS generation counter wrapped!  Please report this."));
485 #endif
486
487   /* Run the initializer functions of new objects.  */
488   _dl_init (new, args->argc, args->argv, args->env);
489
490   /* Now we can make the new map available in the global scope.  */
491   if (mode & RTLD_GLOBAL)
492     /* Move the object in the global namespace.  */
493     if (add_to_global (new) != 0)
494       /* It failed.  */
495       return;
496
497   /* Mark the object as not deletable if the RTLD_NODELETE flags was
498      passed.  */
499   if (__builtin_expect (mode & RTLD_NODELETE, 0))
500     new->l_flags_1 |= DF_1_NODELETE;
501
502 #ifndef SHARED
503   /* We must be the static _dl_open in libc.a.  A static program that
504      has loaded a dynamic object now has competition.  */
505   __libc_multiple_libcs = 1;
506 #endif
507
508   /* Let the user know about the opencount.  */
509   if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
510     _dl_debug_printf ("opening file=%s [%lu]; direct_opencount=%u\n\n",
511                       new->l_name, new->l_ns, new->l_direct_opencount);
512 }
513
514
515 void *
516 _dl_open (const char *file, int mode, const void *caller_dlopen, Lmid_t nsid,
517           int argc, char *argv[], char *env[])
518 {
519   if ((mode & RTLD_BINDING_MASK) == 0)
520     /* One of the flags must be set.  */
521     _dl_signal_error (EINVAL, file, NULL, N_("invalid mode for dlopen()"));
522
523   /* Make sure we are alone.  */
524   __rtld_lock_lock_recursive (GL(dl_load_lock));
525
526   if (nsid == LM_ID_NEWLM)
527     {
528       /* Find a new namespace.  */
529       for (nsid = 1; nsid < DL_NNS; ++nsid)
530         if (GL(dl_ns)[nsid]._ns_loaded == NULL)
531           break;
532
533       if (nsid == DL_NNS)
534         {
535           /* No more namespace available.  */
536           __rtld_lock_unlock_recursive (GL(dl_load_lock));
537
538           _dl_signal_error (EINVAL, file, NULL, N_("\
539 no more namespaces available for dlmopen()"));
540         }
541
542       _dl_debug_initialize (0, nsid)->r_state = RT_CONSISTENT;
543     }
544   /* Never allow loading a DSO in a namespace which is empty.  Such
545      direct placements is only causing problems.  Also don't allow
546      loading into a namespace used for auditing.  */
547   else if (nsid != LM_ID_BASE && nsid != __LM_ID_CALLER
548            && (GL(dl_ns)[nsid]._ns_nloaded == 0
549                || GL(dl_ns)[nsid]._ns_loaded->l_auditing))
550     _dl_signal_error (EINVAL, file, NULL,
551                       N_("invalid target namespace in dlmopen()"));
552
553   struct dl_open_args args;
554   args.file = file;
555   args.mode = mode;
556   args.caller_dlopen = caller_dlopen;
557   args.caller_dl_open = RETURN_ADDRESS (0);
558   args.map = NULL;
559   args.nsid = nsid;
560   args.argc = argc;
561   args.argv = argv;
562   args.env = env;
563
564   const char *objname;
565   const char *errstring;
566   bool malloced;
567   int errcode = _dl_catch_error (&objname, &errstring, &malloced,
568                                  dl_open_worker, &args);
569
570 #ifndef MAP_COPY
571   /* We must munmap() the cache file.  */
572   _dl_unload_cache ();
573 #endif
574
575   /* Release the lock.  */
576   __rtld_lock_unlock_recursive (GL(dl_load_lock));
577
578   if (__builtin_expect (errstring != NULL, 0))
579     {
580       /* Some error occurred during loading.  */
581       char *local_errstring;
582       size_t len_errstring;
583
584       /* Remove the object from memory.  It may be in an inconsistent
585          state if relocation failed, for example.  */
586       if (args.map)
587         {
588 #ifdef USE_TLS
589           /* Maybe some of the modules which were loaded use TLS.
590              Since it will be removed in the following _dl_close call
591              we have to mark the dtv array as having gaps to fill the
592              holes.  This is a pessimistic assumption which won't hurt
593              if not true.  There is no need to do this when we are
594              loading the auditing DSOs since TLS has not yet been set
595              up.  */
596           if ((mode & __RTLD_AUDIT) == 0)
597             GL(dl_tls_dtv_gaps) = true;
598 #endif
599
600           _dl_close (args.map);
601         }
602
603       /* Make a local copy of the error string so that we can release the
604          memory allocated for it.  */
605       len_errstring = strlen (errstring) + 1;
606       if (objname == errstring + len_errstring)
607         {
608           size_t total_len = len_errstring + strlen (objname) + 1;
609           local_errstring = alloca (total_len);
610           memcpy (local_errstring, errstring, total_len);
611           objname = local_errstring + len_errstring;
612         }
613       else
614         {
615           local_errstring = alloca (len_errstring);
616           memcpy (local_errstring, errstring, len_errstring);
617         }
618
619       if (malloced)
620         free ((char *) errstring);
621
622       assert (_dl_debug_initialize (0, args.nsid)->r_state == RT_CONSISTENT);
623
624       /* Reraise the error.  */
625       _dl_signal_error (errcode, objname, NULL, local_errstring);
626     }
627
628   assert (_dl_debug_initialize (0, args.nsid)->r_state == RT_CONSISTENT);
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