← Back to branch summary

~ubuntu-branches/ubuntu/natty/eglibc/natty-security

« back to all changes in this revision

Viewing changes to elf/dl-open.c

  • Committer: Bazaar Package Importer
  • Author(s): Aurelien Jarno
  • Date: 2009-05-05 09:54:14 UTC
  • Revision ID: james.westby@ubuntu.com-20090505095414-c45qsg9ixjheohru
Import upstream version 2.9

Show diffs side-by-side

added added

removed removed

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