1 /* Run time dynamic linker.
2 Copyright (C) 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Library General Public License as
7 published by the Free Software Foundation; either version 2 of the
8 License, or (at your option) any later version.
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 Library General Public License for more details.
15 You should have received a copy of the GNU Library General Public
16 License along with the GNU C Library; see the file COPYING.LIB. If not,
17 write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA. */
26 #include <sys/mman.h> /* Check if MAP_ANON is defined. */
27 #include <stdio-common/_itoa.h>
30 #include "dynamic-link.h"
33 /* System-specific function to do initial startup for the dynamic linker.
34 After this, file access calls and getenv must work. This is responsible
35 for setting __libc_enable_secure if we need to be secure (e.g. setuid),
36 and for setting _dl_argc and _dl_argv, and then calling _dl_main. */
37 extern ElfW(Addr
) _dl_sysdep_start (void **start_argptr
,
38 void (*dl_main
) (const ElfW(Phdr
) *phdr
,
40 ElfW(Addr
) *user_entry
));
41 extern void _dl_sysdep_start_cleanup (void);
43 /* System-dependent function to read a file's whole contents
44 in the most convenient manner available. */
45 extern void *_dl_sysdep_read_whole_file (const char *filename
,
49 /* Helper function to handle errors while resolving symbols. */
50 static void print_unresolved (int errcode
, const char *objname
,
51 const char *errsting
);
53 /* Helper function to handle errors when a version is missing. */
54 static void print_missing_version (int errcode
, const char *objname
,
55 const char *errsting
);
58 /* This is a list of all the modes the dynamic loader can be in. */
59 enum mode
{ normal
, list
, verify
, trace
};
61 /* Process all environments variables the dynamic linker must recognize.
62 Since all of them start with `LD_' we are a bit smarter while finding
64 static void process_envvars (enum mode
*modep
, int *lazyp
);
68 const char *_dl_rpath
;
70 const char *_dl_platform
;
71 size_t _dl_platformlen
;
72 unsigned long _dl_hwcap
;
73 struct r_search_path
*_dl_search_paths
;
74 const char *_dl_profile
;
75 const char *_dl_profile_output
;
76 struct link_map
*_dl_profile_map
;
78 int _dl_debug_impcalls
;
79 int _dl_debug_bindings
;
80 int _dl_debug_symbols
;
81 int _dl_debug_versions
;
85 /* Set nonzero during loading and initialization of executable and
86 libraries, cleared before the executable's entry point runs. This
87 must not be initialized to nonzero, because the unused dynamic
88 linker loaded in for libc.so's "ld.so.1" dep will provide the
89 definition seen by libc.so's initializer; that value must be zero,
90 and will be since that dynamic linker's _dl_start and dl_main will
94 static void dl_main (const ElfW(Phdr
) *phdr
,
96 ElfW(Addr
) *user_entry
);
98 struct link_map _dl_rtld_map
;
99 struct libname_list _dl_rtld_libname
;
100 struct libname_list _dl_rtld_libname2
;
105 #error "sysdeps/MACHINE/dl-machine.h fails to define RTLD_START"
109 _dl_start (void *arg
)
111 struct link_map bootstrap_map
;
113 /* This #define produces dynamic linking inline functions for
114 bootstrap relocation instead of general-purpose relocation. */
115 #define RTLD_BOOTSTRAP
116 #define RESOLVE(sym, version, flags) bootstrap_map.l_addr
117 #include "dynamic-link.h"
119 /* Figure out the run-time load address of the dynamic linker itself. */
120 bootstrap_map
.l_addr
= elf_machine_load_address ();
122 /* Read our own dynamic section and fill in the info array. */
123 bootstrap_map
.l_ld
= (void *) bootstrap_map
.l_addr
+ elf_machine_dynamic ();
124 elf_get_dynamic_info (bootstrap_map
.l_ld
, bootstrap_map
.l_info
);
126 #ifdef ELF_MACHINE_BEFORE_RTLD_RELOC
127 ELF_MACHINE_BEFORE_RTLD_RELOC (bootstrap_map
.l_info
);
130 /* Relocate ourselves so we can do normal function calls and
131 data access using the global offset table. */
133 ELF_DYNAMIC_RELOCATE (&bootstrap_map
, 0, 0);
134 /* Please note that we don't allow profiling of this object and
135 therefore need not test whether we have to allocate the array
136 for the relocation results (as done in dl-reloc.c). */
138 /* Now life is sane; we can call functions and access global data.
139 Set up to use the operating system facilities, and find out from
140 the operating system's program loader where to find the program
141 header table in core. */
143 /* Transfer data about ourselves to the permanent link_map structure. */
144 _dl_rtld_map
.l_addr
= bootstrap_map
.l_addr
;
145 _dl_rtld_map
.l_ld
= bootstrap_map
.l_ld
;
146 _dl_rtld_map
.l_opencount
= 1;
147 memcpy (_dl_rtld_map
.l_info
, bootstrap_map
.l_info
,
148 sizeof _dl_rtld_map
.l_info
);
149 _dl_setup_hash (&_dl_rtld_map
);
151 /* Cache the DT_RPATH stored in ld.so itself; this will be
152 the default search path. */
153 if (_dl_rtld_map
.l_info
[DT_STRTAB
] && _dl_rtld_map
.l_info
[DT_RPATH
])
155 _dl_rpath
= (void *) (_dl_rtld_map
.l_addr
+
156 _dl_rtld_map
.l_info
[DT_STRTAB
]->d_un
.d_ptr
+
157 _dl_rtld_map
.l_info
[DT_RPATH
]->d_un
.d_val
);
160 /* Call the OS-dependent function to set up life so we can do things like
161 file access. It will call `dl_main' (below) to do all the real work
162 of the dynamic linker, and then unwind our frame and run the user
163 entry point on the same stack we entered on. */
164 return _dl_sysdep_start (arg
, &dl_main
);
167 /* Now life is peachy; we can do all normal operations.
168 On to the real work. */
170 void ENTRY_POINT (void);
172 /* Some helper functions. */
174 /* Arguments to relocate_doit. */
183 /* Argument to map_doit. */
185 /* Return value of map_doit. */
186 struct link_map
*main_map
;
189 /* Arguments to version_check_doit. */
190 struct version_check_args
192 struct link_map
*main_map
;
197 relocate_doit (void *a
)
199 struct relocate_args
*args
= (struct relocate_args
*) a
;
201 _dl_relocate_object (args
->l
, _dl_object_relocation_scope (args
->l
),
208 struct map_args
*args
= (struct map_args
*)a
;
209 args
->main_map
= _dl_map_object (NULL
, args
->str
, 0, lt_library
, 0);
213 version_check_doit (void *a
)
215 struct version_check_args
*args
= (struct version_check_args
*)a
;
216 if (_dl_check_all_versions (args
->main_map
, 1) && args
->doexit
)
217 /* We cannot start the application. Abort now. */
222 static inline struct link_map
*
223 find_needed (const char *name
)
227 for (n
= 0; n
< _dl_loaded
->l_nsearchlist
; ++n
)
228 if (_dl_name_match_p (name
, _dl_loaded
->l_searchlist
[n
]))
229 return _dl_loaded
->l_searchlist
[n
];
231 /* Should never happen. */
236 match_version (const char *string
, struct link_map
*map
)
238 const char *strtab
= (const char *) (map
->l_addr
239 + map
->l_info
[DT_STRTAB
]->d_un
.d_ptr
);
242 #define VERDEFTAG (DT_NUM + DT_PROCNUM + DT_VERSIONTAGIDX (DT_VERDEF))
243 if (map
->l_info
[VERDEFTAG
] == NULL
)
244 /* The file has no symbol versioning. */
247 def
= (ElfW(Verdef
) *) ((char *) map
->l_addr
248 + map
->l_info
[VERDEFTAG
]->d_un
.d_ptr
);
251 ElfW(Verdaux
) *aux
= (ElfW(Verdaux
) *) ((char *) def
+ def
->vd_aux
);
253 /* Compare the version strings. */
254 if (strcmp (string
, strtab
+ aux
->vda_name
) == 0)
258 /* If no more definitions we failed to find what we want. */
259 if (def
->vd_next
== 0)
262 /* Next definition. */
263 def
= (ElfW(Verdef
) *) ((char *) def
+ def
->vd_next
);
269 static unsigned int _dl_skip_args
; /* Nonzero if we were run directly. */
270 static const char *library_path
; /* The library search path. */
271 static const char *preloadlist
; /* The list preloaded objects. */
272 static int version_info
; /* Nonzero if information about
273 versions has to be printed. */
276 dl_main (const ElfW(Phdr
) *phdr
,
278 ElfW(Addr
) *user_entry
)
280 const ElfW(Phdr
) *ph
;
281 struct link_map
*main_map
;
284 struct link_map
**preloads
;
285 unsigned int npreloads
;
291 /* Process the environment variable which control the behaviour. */
292 process_envvars (&mode
, &lazy
);
294 /* Set up a flag which tells we are just starting. */
297 if (*user_entry
== (ElfW(Addr
)) &ENTRY_POINT
)
299 /* Ho ho. We are not the program interpreter! We are the program
300 itself! This means someone ran ld.so as a command. Well, that
301 might be convenient to do sometimes. We support it by
302 interpreting the args like this:
304 ld.so PROGRAM ARGS...
306 The first argument is the name of a file containing an ELF
307 executable we will load and run with the following arguments.
308 To simplify life here, PROGRAM is searched for using the
309 normal rules for shared objects, rather than $PATH or anything
310 like that. We just load it and use its entry point; we don't
311 pay attention to its PT_INTERP command (we are the interpreter
312 ourselves). This is an easy way to test a new ld.so before
315 /* Note the place where the dynamic linker actually came from. */
316 _dl_rtld_map
.l_name
= _dl_argv
[0];
319 if (! strcmp (_dl_argv
[1], "--list"))
322 lazy
= -1; /* This means do no dependency analysis. */
328 else if (! strcmp (_dl_argv
[1], "--verify"))
336 else if (! strcmp (_dl_argv
[1], "--library-path")
339 library_path
= _dl_argv
[2];
348 /* If we have no further argument the program was called incorrectly.
349 Grant the user some education. */
352 Usage: ld.so [--list|--verify] EXECUTABLE-FILE [ARGS-FOR-PROGRAM...]\n\
353 You have invoked `ld.so', the helper program for shared library executables.\n\
354 This program usually lives in the file `/lib/ld.so', and special directives\n\
355 in executable files using ELF shared libraries tell the system's program\n\
356 loader to load the helper program from this file. This helper program loads\n\
357 the shared libraries needed by the program executable, prepares the program\n\
358 to run, and runs it. You may invoke this helper program directly from the\n\
359 command line to load and run an ELF executable file; this is like executing\n\
360 that file itself, but always uses this helper program from the file you\n\
361 specified, instead of the helper program file specified in the executable\n\
362 file you run. This is mostly of use for maintainers to test new versions\n\
363 of this helper program; chances are you did not intend to run this program.\n",
370 /* Initialize the data structures for the search paths for shared
372 _dl_init_paths (library_path
);
376 char *err_str
= NULL
;
377 const char *obj_name
__attribute__ ((unused
));
378 struct map_args args
;
380 args
.str
= _dl_argv
[0];
381 (void) _dl_catch_error (&err_str
, &obj_name
, map_doit
, &args
);
382 main_map
= args
.main_map
;
386 _exit (EXIT_FAILURE
);
390 main_map
= _dl_map_object (NULL
, _dl_argv
[0], 0, lt_library
, 0);
392 phdr
= main_map
->l_phdr
;
393 phent
= main_map
->l_phnum
;
394 main_map
->l_name
= (char *) "";
395 *user_entry
= main_map
->l_entry
;
399 /* Create a link_map for the executable itself.
400 This will be what dlopen on "" returns. */
401 main_map
= _dl_new_object ((char *) "", "", lt_executable
);
402 if (main_map
== NULL
)
403 _dl_sysdep_fatal ("cannot allocate memory for link map\n", NULL
);
404 main_map
->l_phdr
= phdr
;
405 main_map
->l_phnum
= phent
;
406 main_map
->l_entry
= *user_entry
;
407 main_map
->l_opencount
= 1;
409 /* We delay initializing the path structure until we got the dynamic
410 information for the program. */
413 /* Scan the program header table for the dynamic section. */
414 for (ph
= phdr
; ph
< &phdr
[phent
]; ++ph
)
418 /* Find out the load address. */
419 main_map
->l_addr
= (ElfW(Addr
)) phdr
- ph
->p_vaddr
;
422 /* This tells us where to find the dynamic section,
423 which tells us everything we need to do. */
424 main_map
->l_ld
= (void *) main_map
->l_addr
+ ph
->p_vaddr
;
427 /* This "interpreter segment" was used by the program loader to
428 find the program interpreter, which is this program itself, the
429 dynamic linker. We note what name finds us, so that a future
430 dlopen call or DT_NEEDED entry, for something that wants to link
431 against the dynamic linker as a shared library, will know that
432 the shared object is already loaded. */
433 _dl_rtld_libname
.name
= (const char *) main_map
->l_addr
+ ph
->p_vaddr
;
434 _dl_rtld_libname
.next
= NULL
;
435 _dl_rtld_map
.l_libname
= &_dl_rtld_libname
;
437 /* Ordinarilly, we would get additional names for the loader from
438 our DT_SONAME. This can't happen if we were actually linked as
439 a static executable (detect this case when we have no DYNAMIC).
440 If so, assume the filename component of the interpreter path to
441 be our SONAME, and add it to our name list. */
442 if (_dl_rtld_map
.l_ld
== NULL
)
444 char *p
= strrchr (_dl_rtld_libname
.name
, '/');
447 _dl_rtld_libname2
.name
= p
+1;
448 _dl_rtld_libname2
.next
= NULL
;
449 _dl_rtld_libname
.next
= &_dl_rtld_libname2
;
456 if (! _dl_rtld_map
.l_libname
&& _dl_rtld_map
.l_name
)
458 /* We were invoked directly, so the program might not have a
460 _dl_rtld_libname
.name
= _dl_rtld_map
.l_name
;
461 _dl_rtld_libname
.next
= NULL
;
462 _dl_rtld_map
.l_libname
= &_dl_rtld_libname
;
465 assert (_dl_rtld_map
.l_libname
); /* How else did we get here? */
468 /* We were called just to verify that this is a dynamic executable
469 using us as the program interpreter. */
470 _exit (main_map
->l_ld
== NULL
? 1 : has_interp
? 0 : 2);
472 /* Extract the contents of the dynamic section for easy access. */
473 elf_get_dynamic_info (main_map
->l_ld
, main_map
->l_info
);
474 if (main_map
->l_info
[DT_HASH
])
475 /* Set up our cache of pointers into the hash table. */
476 _dl_setup_hash (main_map
);
478 if (*user_entry
!= (ElfW(Addr
)) &ENTRY_POINT
)
479 /* Initialize the data structures for the search paths for shared
481 _dl_init_paths (library_path
);
483 /* Put the link_map for ourselves on the chain so it can be found by
484 name. Note that at this point the global chain of link maps contains
485 exactly one element, which is pointed to by main_map. */
486 if (! _dl_rtld_map
.l_name
)
487 /* If not invoked directly, the dynamic linker shared object file was
488 found by the PT_INTERP name. */
489 _dl_rtld_map
.l_name
= (char *) _dl_rtld_map
.l_libname
->name
;
490 _dl_rtld_map
.l_type
= lt_library
;
491 main_map
->l_next
= &_dl_rtld_map
;
492 _dl_rtld_map
.l_prev
= main_map
;
494 /* We have two ways to specify objects to preload: via environment
495 variable and via the file /etc/ld.so.preload. The later can also
496 be used when security is enabled. */
502 /* The LD_PRELOAD environment variable gives list of libraries
503 separated by white space or colons that are loaded before the
504 executable's dependencies and prepended to the global scope
505 list. If the binary is running setuid all elements
506 containing a '/' are ignored since it is insecure. */
507 char *list
= strdupa (preloadlist
);
509 while ((p
= strsep (&list
, " :")) != NULL
)
510 if (! __libc_enable_secure
|| strchr (p
, '/') == NULL
)
512 struct link_map
*new_map
= _dl_map_object (NULL
, p
, 1,
514 if (new_map
->l_opencount
== 1)
515 /* It is no duplicate. */
520 /* Read the contents of the file. */
521 file
= _dl_sysdep_read_whole_file ("/etc/ld.so.preload", &file_size
,
522 PROT_READ
| PROT_WRITE
);
525 /* Parse the file. It contains names of libraries to be loaded,
526 separated by white spaces or `:'. It may also contain
527 comments introduced by `#'. */
532 /* Eliminate comments. */
537 char *comment
= memchr (runp
, '#', rest
);
541 rest
-= comment
- runp
;
544 while (--rest
> 0 && *++comment
!= '\n');
547 /* We have one problematic case: if we have a name at the end of
548 the file without a trailing terminating characters, we cannot
549 place the \0. Handle the case separately. */
550 if (file
[file_size
- 1] != ' ' && file
[file_size
- 1] != '\t'
551 && file
[file_size
- 1] != '\n' && file
[file_size
- 1] != ':')
553 problem
= &file
[file_size
];
554 while (problem
> file
&& problem
[-1] != ' ' && problem
[-1] != '\t'
555 && problem
[-1] != '\n' && problem
[-1] != ':')
564 file
[file_size
- 1] = '\0';
570 runp
= file
+ strspn (file
, ": \t\n");
571 while ((p
= strsep (&runp
, ": \t\n")) != NULL
)
573 struct link_map
*new_map
= _dl_map_object (NULL
, p
, 1,
575 if (new_map
->l_opencount
== 1)
576 /* It is no duplicate. */
580 runp
+= strspn (runp
, ": \t\n");
586 char *p
= strndupa (problem
, file_size
- (problem
- file
));
587 struct link_map
*new_map
= _dl_map_object (NULL
, p
, 1,
589 if (new_map
->l_opencount
== 1)
590 /* It is no duplicate. */
594 /* We don't need the file anymore. */
595 __munmap (file
, file_size
);
600 /* Set up PRELOADS with a vector of the preloaded libraries. */
602 preloads
= __alloca (npreloads
* sizeof preloads
[0]);
603 l
= _dl_rtld_map
.l_next
; /* End of the chain before preloads. */
610 assert (i
== npreloads
);
613 /* Load all the libraries specified by DT_NEEDED entries. If LD_PRELOAD
614 specified some libraries to load, these are inserted before the actual
615 dependencies in the executable's searchlist for symbol resolution. */
616 _dl_map_object_deps (main_map
, preloads
, npreloads
, mode
== trace
);
619 /* We are done mapping things, so close the zero-fill descriptor. */
620 __close (_dl_zerofd
);
624 /* Remove _dl_rtld_map from the chain. */
625 _dl_rtld_map
.l_prev
->l_next
= _dl_rtld_map
.l_next
;
626 if (_dl_rtld_map
.l_next
)
627 _dl_rtld_map
.l_next
->l_prev
= _dl_rtld_map
.l_prev
;
629 if (_dl_rtld_map
.l_opencount
)
631 /* Some DT_NEEDED entry referred to the interpreter object itself, so
632 put it back in the list of visible objects. We insert it into the
633 chain in symbol search order because gdb uses the chain's order as
634 its symbol search order. */
636 while (main_map
->l_searchlist
[i
] != &_dl_rtld_map
)
638 _dl_rtld_map
.l_prev
= main_map
->l_searchlist
[i
- 1];
639 _dl_rtld_map
.l_next
= (i
+ 1 < main_map
->l_nsearchlist
?
640 main_map
->l_searchlist
[i
+ 1] : NULL
);
641 assert (_dl_rtld_map
.l_prev
->l_next
== _dl_rtld_map
.l_next
);
642 _dl_rtld_map
.l_prev
->l_next
= &_dl_rtld_map
;
643 if (_dl_rtld_map
.l_next
)
645 assert (_dl_rtld_map
.l_next
->l_prev
== _dl_rtld_map
.l_prev
);
646 _dl_rtld_map
.l_next
->l_prev
= &_dl_rtld_map
;
650 /* Now let us see whether all libraries are available in the
653 struct version_check_args args
;
654 args
.doexit
= mode
== normal
;
655 args
.main_map
= main_map
;
656 _dl_receive_error (print_missing_version
, version_check_doit
, &args
);
661 /* We were run just to list the shared libraries. It is
662 important that we do this before real relocation, because the
663 functions we call below for output may no longer work properly
665 if (! _dl_loaded
->l_info
[DT_NEEDED
])
666 _dl_sysdep_message ("\t", "statically linked\n", NULL
);
671 for (l
= _dl_loaded
->l_next
; l
; l
= l
->l_next
)
672 if (l
->l_opencount
== 0)
673 /* The library was not found. */
674 _dl_sysdep_message ("\t", l
->l_libname
->name
, " => not found\n",
679 buf
[sizeof buf
- 1] = '\0';
680 bp
= _itoa_word (l
->l_addr
, &buf
[sizeof buf
- 1], 16, 0);
681 while ((size_t) (&buf
[sizeof buf
- 1] - bp
)
682 < sizeof l
->l_addr
* 2)
684 _dl_sysdep_message ("\t", l
->l_libname
->name
, " => ",
685 l
->l_name
, " (0x", bp
, ")\n", NULL
);
690 for (i
= 1; i
< _dl_argc
; ++i
)
692 const ElfW(Sym
) *ref
= NULL
;
693 ElfW(Addr
) loadbase
= _dl_lookup_symbol (_dl_argv
[i
], &ref
,
694 &_dl_default_scope
[2],
696 ELF_MACHINE_JMP_SLOT
);
698 buf
[sizeof buf
- 1] = '\0';
699 bp
= _itoa_word (ref
->st_value
, &buf
[sizeof buf
- 1], 16, 0);
700 while ((size_t) (&buf
[sizeof buf
- 1] - bp
) < sizeof loadbase
* 2)
702 _dl_sysdep_message (_dl_argv
[i
], " found at 0x", bp
, NULL
);
703 buf
[sizeof buf
- 1] = '\0';
704 bp
= _itoa_word (loadbase
, &buf
[sizeof buf
- 1], 16, 0);
705 while ((size_t) (&buf
[sizeof buf
- 1] - bp
) < sizeof loadbase
* 2)
707 _dl_sysdep_message (" in object at 0x", bp
, "\n", NULL
);
713 /* We have to do symbol dependency testing. */
714 struct relocate_args args
;
724 if (l
!= &_dl_rtld_map
&& l
->l_opencount
> 0)
727 _dl_receive_error (print_unresolved
, relocate_doit
,
729 *_dl_global_scope_end
= NULL
;
735 #define VERNEEDTAG (DT_NUM + DT_PROCNUM + DT_VERSIONTAGIDX (DT_VERNEED))
738 /* Print more information. This means here, print information
739 about the versions needed. */
741 struct link_map
*map
= _dl_loaded
;
743 for (map
= _dl_loaded
; map
!= NULL
; map
= map
->l_next
)
746 ElfW(Dyn
) *dyn
= map
->l_info
[VERNEEDTAG
];
752 strtab
= (const char *)
753 (map
->l_addr
+ map
->l_info
[DT_STRTAB
]->d_un
.d_ptr
);
754 ent
= (ElfW(Verneed
) *) (map
->l_addr
+ dyn
->d_un
.d_ptr
);
758 _dl_sysdep_message ("\n\tVersion information:\n", NULL
);
762 _dl_sysdep_message ("\t", (map
->l_name
[0]
763 ? map
->l_name
: _dl_argv
[0]),
769 struct link_map
*needed
;
771 needed
= find_needed (strtab
+ ent
->vn_file
);
772 aux
= (ElfW(Vernaux
) *) ((char *) ent
+ ent
->vn_aux
);
776 const char *fname
= NULL
;
778 _dl_sysdep_message ("\t\t",
779 strtab
+ ent
->vn_file
,
780 " (", strtab
+ aux
->vna_name
,
788 && match_version (strtab
+aux
->vna_name
, needed
))
789 fname
= needed
->l_name
;
791 _dl_sysdep_message (fname
?: "not found", "\n",
794 if (aux
->vna_next
== 0)
795 /* No more symbols. */
799 aux
= (ElfW(Vernaux
) *) ((char *) aux
803 if (ent
->vn_next
== 0)
804 /* No more dependencies. */
807 /* Next dependency. */
808 ent
= (ElfW(Verneed
) *) ((char *) ent
+ ent
->vn_next
);
818 /* Now we have all the objects loaded. Relocate them all except for
819 the dynamic linker itself. We do this in reverse order so that copy
820 relocs of earlier objects overwrite the data written by later
821 objects. We do not re-relocate the dynamic linker itself in this
822 loop because that could result in the GOT entries for functions we
823 call being changed, and that would break us. It is safe to relocate
824 the dynamic linker out of order because it has no copy relocs (we
825 know that because it is self-contained). */
833 if (l
!= &_dl_rtld_map
)
835 _dl_relocate_object (l
, _dl_object_relocation_scope (l
), lazy
);
836 *_dl_global_scope_end
= NULL
;
841 /* Do any necessary cleanups for the startup OS interface code.
842 We do these now so that no calls are made after rtld re-relocation
843 which might be resolved to different functions than we expect.
844 We cannot do this before relocating the other objects because
845 _dl_relocate_object might need to call `mprotect' for DT_TEXTREL. */
846 _dl_sysdep_start_cleanup ();
848 if (_dl_rtld_map
.l_opencount
> 0)
849 /* There was an explicit ref to the dynamic linker as a shared lib.
850 Re-relocate ourselves with user-controlled symbol definitions. */
851 _dl_relocate_object (&_dl_rtld_map
, &_dl_default_scope
[2], 0);
855 /* Initialize _r_debug. */
856 struct r_debug
*r
= _dl_debug_initialize (_dl_rtld_map
.l_addr
);
861 #ifdef ELF_MACHINE_DEBUG_SETUP
863 /* Some machines (e.g. MIPS) don't use DT_DEBUG in this way. */
865 ELF_MACHINE_DEBUG_SETUP (l
, r
);
866 ELF_MACHINE_DEBUG_SETUP (&_dl_rtld_map
, r
);
870 if (l
->l_info
[DT_DEBUG
])
871 /* There is a DT_DEBUG entry in the dynamic section. Fill it in
872 with the run-time address of the r_debug structure */
873 l
->l_info
[DT_DEBUG
]->d_un
.d_ptr
= (ElfW(Addr
)) r
;
875 /* Fill in the pointer in the dynamic linker's own dynamic section, in
876 case you run gdb on the dynamic linker directly. */
877 if (_dl_rtld_map
.l_info
[DT_DEBUG
])
878 _dl_rtld_map
.l_info
[DT_DEBUG
]->d_un
.d_ptr
= (ElfW(Addr
)) r
;
882 /* Notify the debugger that all objects are now mapped in. */
887 /* Now enable profiling if needed. */
888 if (_dl_profile_map
!= NULL
)
889 /* We must prepare the profiling. */
890 _dl_start_profile (_dl_profile_map
, _dl_profile_output
);
892 /* Once we return, _dl_sysdep_start will invoke
893 the DT_INIT functions and then *USER_ENTRY. */
896 /* This is a little helper function for resolving symbols while
897 tracing the binary. */
899 print_unresolved (int errcode
__attribute__ ((unused
)), const char *objname
,
900 const char *errstring
)
902 if (objname
[0] == '\0')
903 objname
= _dl_argv
[0] ?: "<main program>";
904 _dl_sysdep_error (errstring
, " (", objname
, ")\n", NULL
);
907 /* This is a little helper function for resolving symbols while
908 tracing the binary. */
910 print_missing_version (int errcode
__attribute__ ((unused
)),
911 const char *objname
, const char *errstring
)
913 _dl_sysdep_error (_dl_argv
[0] ?: "<program name unknown>", ": ",
914 objname
, ": ", errstring
, "\n", NULL
);
917 /* Nonzero if any of the debugging options is enabled. */
918 static int any_debug
;
920 /* Process the string given as the parameter which explains which debugging
921 options are enabled. */
923 process_dl_debug (char *dl_debug
)
927 #define issep(Ch) ((Ch) == ' ' || (Ch) == ',')
928 /* Skip separating white spaces and commas. */
929 while (issep (*dl_debug
))
931 if (*dl_debug
!= '\0')
933 if (strncmp (dl_debug
, "files", 5) == 0
934 && (issep (dl_debug
[5]) || dl_debug
[5] == '\0'))
937 _dl_debug_impcalls
= 1;
941 else if (strncmp (dl_debug
, "bindings", 8) == 0
942 && (issep (dl_debug
[8]) || dl_debug
[8] == '\0'))
944 _dl_debug_bindings
= 1;
945 _dl_debug_impcalls
= 1;
949 else if (strncmp (dl_debug
, "help", 4) == 0
950 && (issep (dl_debug
[4]) || dl_debug
[4] == '\0'))
952 _dl_sysdep_message ("\
953 Valid options for the LD_DEBUG environment variable are:\n\
955 bindings display information about symbol binding\n\
956 files display processing of files and libraries\n\
957 help display this help message and exit\n\
958 libs display library search paths\n\
959 reloc display relocation processing\n\
960 symbols display symbol table processing\n\
961 versions display version dependencies\n\
963 To direct the debugging output into a file instead of standard output\n\
964 a filename can be specified using the LD_DEBUG_OUTPUT environment variable.\n",
968 else if (strncmp (dl_debug
, "libs", 4) == 0
969 && (issep (dl_debug
[4]) || dl_debug
[4] == '\0'))
972 _dl_debug_impcalls
= 1;
976 else if (strncmp (dl_debug
, "reloc", 4) == 0
977 && (issep (dl_debug
[5]) || dl_debug
[5] == '\0'))
980 _dl_debug_impcalls
= 1;
984 else if (strncmp (dl_debug
, "symbols", 7) == 0
985 && (issep (dl_debug
[7]) || dl_debug
[7] == '\0'))
987 _dl_debug_symbols
= 1;
988 _dl_debug_impcalls
= 1;
992 else if (strncmp (dl_debug
, "versions", 8) == 0
993 && (issep (dl_debug
[8]) || dl_debug
[8] == '\0'))
995 _dl_debug_versions
= 1;
996 _dl_debug_impcalls
= 1;
1002 /* Display a warning and skip everything until next
1004 char *startp
= dl_debug
;
1008 while (*dl_debug
!= '\0' && !issep (*dl_debug
));
1010 startp
= strndupa (startp
, dl_debug
- startp
);
1011 _dl_sysdep_error ("warning: debug option `", startp
,
1012 "' unknown; try LD_DEBUG=help\n", NULL
);
1017 while (*dl_debug
!= '\0');
1020 /* Process all environments variables the dynamic linker must recognize.
1021 Since all of them start with `LD_' we are a bit smarter while finding
1024 process_envvars (enum mode
*modep
, int *lazyp
)
1028 enum mode mode
= normal
;
1030 char *debug_output
= NULL
;
1032 /* This is the default place for profiling data file. */
1033 _dl_profile_output
= "/var/tmp";
1035 while ((envline
= _dl_next_ld_env_entry (&runp
)) != NULL
)
1039 /* Do we bind early? */
1040 result
= strncmp (&envline
[3], "BIND_NOW=", 9);
1049 /* Debugging of the dynamic linker? */
1050 result
= strncmp (&envline
[3], "DEBUG=", 6);
1053 process_dl_debug (&envline
[9]);
1059 /* Where to place the profiling data file. */
1060 result
= strncmp (&envline
[3], "DEBUG_OUTPUT=", 13);
1063 debug_output
= &envline
[16];
1069 /* The library search path. */
1070 result
= strncmp (&envline
[3], "LIBRARY_PATH=", 13);
1073 library_path
= &envline
[16];
1079 /* List of objects to be preloaded. */
1080 result
= strncmp (&envline
[3], "PRELOAD=", 8);
1083 preloadlist
= &envline
[11];
1089 /* Which shared object shall be profiled. */
1090 result
= strncmp (&envline
[3], "PROFILE=", 8);
1093 _dl_profile
= &envline
[11];
1094 if (*_dl_profile
== '\0')
1101 /* Where to place the profiling data file. */
1102 result
= strncmp (&envline
[3], "PROFILE_OUTPUT=", 15);
1105 _dl_profile_output
= &envline
[18];
1106 if (*_dl_profile_output
== '\0')
1107 _dl_profile_output
= "/var/tmp";
1113 /* Test whether we want to see the content of the auxiliary
1114 array passed up from the kernel. */
1115 result
= strncmp (&envline
[3], "SHOW_AUXV=", 10);
1124 /* The mode of the dynamic linker can be set. */
1125 result
= strncmp (&envline
[3], "TRACE_LOADED_OBJECTS=", 21);
1134 /* Print information about versions. */
1135 result
= strncmp (&envline
[3], "VERBOSE=", 8);
1138 version_info
= envline
[11] != '\0';
1144 /* Warning level, verbose or not. */
1145 result
= strncmp (&envline
[3], "WARN=", 5);
1148 _dl_verbose
= envline
[8] != '\0';
1153 /* If we have to run the dynamic linker in debugging mode and the
1154 LD_DEBUG_OUTPUT environment variable is given, we write the debug
1155 messages to this file. */
1156 if (any_debug
&& debug_output
!= NULL
)
1158 _dl_debug_fd
= __open (debug_output
, O_WRONLY
| O_APPEND
| O_CREAT
,
1160 if (_dl_debug_fd
== -1)
1161 /* We use standard output if opening the file failed. */
1162 _dl_debug_fd
= STDOUT_FILENO
;
1165 /* LAZY is determined by the environment variable LD_WARN and
1166 LD_BIND_NOW if we trace the binary. */
1168 *lazyp
= _dl_verbose
? !bind_now
: -1;
1170 *lazyp
= !__libc_enable_secure
&& !bind_now
;