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
;
82 /* Set nonzero during loading and initialization of executable and
83 libraries, cleared before the executable's entry point runs. This
84 must not be initialized to nonzero, because the unused dynamic
85 linker loaded in for libc.so's "ld.so.1" dep will provide the
86 definition seen by libc.so's initializer; that value must be zero,
87 and will be since that dynamic linker's _dl_start and dl_main will
91 static void dl_main (const ElfW(Phdr
) *phdr
,
93 ElfW(Addr
) *user_entry
);
95 struct link_map _dl_rtld_map
;
96 struct libname_list _dl_rtld_libname
;
97 struct libname_list _dl_rtld_libname2
;
102 #error "sysdeps/MACHINE/dl-machine.h fails to define RTLD_START"
106 _dl_start (void *arg
)
108 struct link_map bootstrap_map
;
110 /* This #define produces dynamic linking inline functions for
111 bootstrap relocation instead of general-purpose relocation. */
112 #define RTLD_BOOTSTRAP
113 #define RESOLVE(sym, version, flags) bootstrap_map.l_addr
114 #include "dynamic-link.h"
116 /* Figure out the run-time load address of the dynamic linker itself. */
117 bootstrap_map
.l_addr
= elf_machine_load_address ();
119 /* Read our own dynamic section and fill in the info array. */
120 bootstrap_map
.l_ld
= (void *) bootstrap_map
.l_addr
+ elf_machine_dynamic ();
121 elf_get_dynamic_info (bootstrap_map
.l_ld
, bootstrap_map
.l_info
);
123 #ifdef ELF_MACHINE_BEFORE_RTLD_RELOC
124 ELF_MACHINE_BEFORE_RTLD_RELOC (bootstrap_map
.l_info
);
127 /* Relocate ourselves so we can do normal function calls and
128 data access using the global offset table. */
130 ELF_DYNAMIC_RELOCATE (&bootstrap_map
, 0, 0);
131 /* Please note that we don't allow profiling of this object and
132 therefore need not test whether we have to allocate the array
133 for the relocation results (as done in dl-reloc.c). */
135 /* Now life is sane; we can call functions and access global data.
136 Set up to use the operating system facilities, and find out from
137 the operating system's program loader where to find the program
138 header table in core. */
140 /* Transfer data about ourselves to the permanent link_map structure. */
141 _dl_rtld_map
.l_addr
= bootstrap_map
.l_addr
;
142 _dl_rtld_map
.l_ld
= bootstrap_map
.l_ld
;
143 _dl_rtld_map
.l_opencount
= 1;
144 memcpy (_dl_rtld_map
.l_info
, bootstrap_map
.l_info
,
145 sizeof _dl_rtld_map
.l_info
);
146 _dl_setup_hash (&_dl_rtld_map
);
148 /* Cache the DT_RPATH stored in ld.so itself; this will be
149 the default search path. */
150 if (_dl_rtld_map
.l_info
[DT_STRTAB
] && _dl_rtld_map
.l_info
[DT_RPATH
])
152 _dl_rpath
= (void *) (_dl_rtld_map
.l_addr
+
153 _dl_rtld_map
.l_info
[DT_STRTAB
]->d_un
.d_ptr
+
154 _dl_rtld_map
.l_info
[DT_RPATH
]->d_un
.d_val
);
157 /* Call the OS-dependent function to set up life so we can do things like
158 file access. It will call `dl_main' (below) to do all the real work
159 of the dynamic linker, and then unwind our frame and run the user
160 entry point on the same stack we entered on. */
161 return _dl_sysdep_start (arg
, &dl_main
);
164 /* Now life is peachy; we can do all normal operations.
165 On to the real work. */
167 void ENTRY_POINT (void);
169 /* Some helper functions. */
171 /* Arguments to relocate_doit. */
180 /* Argument to map_doit. */
182 /* Return value of map_doit. */
183 struct link_map
*main_map
;
186 /* Arguments to version_check_doit. */
187 struct version_check_args
189 struct link_map
*main_map
;
194 relocate_doit (void *a
)
196 struct relocate_args
*args
= (struct relocate_args
*) a
;
198 _dl_relocate_object (args
->l
, _dl_object_relocation_scope (args
->l
),
205 struct map_args
*args
= (struct map_args
*)a
;
206 args
->main_map
= _dl_map_object (NULL
, args
->str
, 0, lt_library
, 0);
210 version_check_doit (void *a
)
212 struct version_check_args
*args
= (struct version_check_args
*)a
;
213 if (_dl_check_all_versions (args
->main_map
, 1) && args
->doexit
)
214 /* We cannot start the application. Abort now. */
219 static inline struct link_map
*
220 find_needed (const char *name
)
224 for (n
= 0; n
< _dl_loaded
->l_nsearchlist
; ++n
)
225 if (_dl_name_match_p (name
, _dl_loaded
->l_searchlist
[n
]))
226 return _dl_loaded
->l_searchlist
[n
];
228 /* Should never happen. */
233 match_version (const char *string
, struct link_map
*map
)
235 const char *strtab
= (const char *) (map
->l_addr
236 + map
->l_info
[DT_STRTAB
]->d_un
.d_ptr
);
239 #define VERDEFTAG (DT_NUM + DT_PROCNUM + DT_VERSIONTAGIDX (DT_VERDEF))
240 if (map
->l_info
[VERDEFTAG
] == NULL
)
241 /* The file has no symbol versioning. */
244 def
= (ElfW(Verdef
) *) ((char *) map
->l_addr
245 + map
->l_info
[VERDEFTAG
]->d_un
.d_ptr
);
248 ElfW(Verdaux
) *aux
= (ElfW(Verdaux
) *) ((char *) def
+ def
->vd_aux
);
250 /* Compare the version strings. */
251 if (strcmp (string
, strtab
+ aux
->vda_name
) == 0)
255 /* If no more definitions we failed to find what we want. */
256 if (def
->vd_next
== 0)
259 /* Next definition. */
260 def
= (ElfW(Verdef
) *) ((char *) def
+ def
->vd_next
);
266 static unsigned int _dl_skip_args
; /* Nonzero if we were run directly. */
267 static const char *library_path
; /* The library search path. */
268 static const char *preloadlist
; /* The list preloaded objects. */
269 static int version_info
; /* Nonzero if information about
270 versions has to be printed. */
273 dl_main (const ElfW(Phdr
) *phdr
,
275 ElfW(Addr
) *user_entry
)
277 const ElfW(Phdr
) *ph
;
278 struct link_map
*main_map
;
281 struct link_map
**preloads
;
282 unsigned int npreloads
;
288 /* Process the environment variable which control the behaviour. */
289 process_envvars (&mode
, &lazy
);
291 /* Set up a flag which tells we are just starting. */
294 if (*user_entry
== (ElfW(Addr
)) &ENTRY_POINT
)
296 /* Ho ho. We are not the program interpreter! We are the program
297 itself! This means someone ran ld.so as a command. Well, that
298 might be convenient to do sometimes. We support it by
299 interpreting the args like this:
301 ld.so PROGRAM ARGS...
303 The first argument is the name of a file containing an ELF
304 executable we will load and run with the following arguments.
305 To simplify life here, PROGRAM is searched for using the
306 normal rules for shared objects, rather than $PATH or anything
307 like that. We just load it and use its entry point; we don't
308 pay attention to its PT_INTERP command (we are the interpreter
309 ourselves). This is an easy way to test a new ld.so before
312 /* Note the place where the dynamic linker actually came from. */
313 _dl_rtld_map
.l_name
= _dl_argv
[0];
316 if (! strcmp (_dl_argv
[1], "--list"))
319 lazy
= -1; /* This means do no dependency analysis. */
325 else if (! strcmp (_dl_argv
[1], "--verify"))
333 else if (! strcmp (_dl_argv
[1], "--library-path")
336 library_path
= _dl_argv
[2];
345 /* If we have no further argument the program was called incorrectly.
346 Grant the user some education. */
349 Usage: ld.so [--list|--verify] EXECUTABLE-FILE [ARGS-FOR-PROGRAM...]\n\
350 You have invoked `ld.so', the helper program for shared library executables.\n\
351 This program usually lives in the file `/lib/ld.so', and special directives\n\
352 in executable files using ELF shared libraries tell the system's program\n\
353 loader to load the helper program from this file. This helper program loads\n\
354 the shared libraries needed by the program executable, prepares the program\n\
355 to run, and runs it. You may invoke this helper program directly from the\n\
356 command line to load and run an ELF executable file; this is like executing\n\
357 that file itself, but always uses this helper program from the file you\n\
358 specified, instead of the helper program file specified in the executable\n\
359 file you run. This is mostly of use for maintainers to test new versions\n\
360 of this helper program; chances are you did not intend to run this program.\n",
367 /* Initialize the data structures for the search paths for shared
369 _dl_init_paths (library_path
);
373 char *err_str
= NULL
;
374 const char *obj_name
__attribute__ ((unused
));
375 struct map_args args
;
377 args
.str
= _dl_argv
[0];
378 (void) _dl_catch_error (&err_str
, &obj_name
, map_doit
, &args
);
379 main_map
= args
.main_map
;
383 _exit (EXIT_FAILURE
);
387 main_map
= _dl_map_object (NULL
, _dl_argv
[0], 0, lt_library
, 0);
389 phdr
= main_map
->l_phdr
;
390 phent
= main_map
->l_phnum
;
391 main_map
->l_name
= (char *) "";
392 *user_entry
= main_map
->l_entry
;
396 /* Create a link_map for the executable itself.
397 This will be what dlopen on "" returns. */
398 main_map
= _dl_new_object ((char *) "", "", lt_executable
);
399 if (main_map
== NULL
)
400 _dl_sysdep_fatal ("cannot allocate memory for link map\n", NULL
);
401 main_map
->l_phdr
= phdr
;
402 main_map
->l_phnum
= phent
;
403 main_map
->l_entry
= *user_entry
;
404 main_map
->l_opencount
= 1;
406 /* We delay initializing the path structure until we got the dynamic
407 information for the program. */
410 /* Scan the program header table for the dynamic section. */
411 for (ph
= phdr
; ph
< &phdr
[phent
]; ++ph
)
415 /* Find out the load address. */
416 main_map
->l_addr
= (ElfW(Addr
)) phdr
- ph
->p_vaddr
;
419 /* This tells us where to find the dynamic section,
420 which tells us everything we need to do. */
421 main_map
->l_ld
= (void *) main_map
->l_addr
+ ph
->p_vaddr
;
424 /* This "interpreter segment" was used by the program loader to
425 find the program interpreter, which is this program itself, the
426 dynamic linker. We note what name finds us, so that a future
427 dlopen call or DT_NEEDED entry, for something that wants to link
428 against the dynamic linker as a shared library, will know that
429 the shared object is already loaded. */
430 _dl_rtld_libname
.name
= (const char *) main_map
->l_addr
+ ph
->p_vaddr
;
431 _dl_rtld_libname
.next
= NULL
;
432 _dl_rtld_map
.l_libname
= &_dl_rtld_libname
;
434 /* Ordinarilly, we would get additional names for the loader from
435 our DT_SONAME. This can't happen if we were actually linked as
436 a static executable (detect this case when we have no DYNAMIC).
437 If so, assume the filename component of the interpreter path to
438 be our SONAME, and add it to our name list. */
439 if (_dl_rtld_map
.l_ld
== NULL
)
441 char *p
= strrchr (_dl_rtld_libname
.name
, '/');
444 _dl_rtld_libname2
.name
= p
+1;
445 _dl_rtld_libname2
.next
= NULL
;
446 _dl_rtld_libname
.next
= &_dl_rtld_libname2
;
453 if (! _dl_rtld_map
.l_libname
&& _dl_rtld_map
.l_name
)
455 /* We were invoked directly, so the program might not have a
457 _dl_rtld_libname
.name
= _dl_rtld_map
.l_name
;
458 _dl_rtld_libname
.next
= NULL
;
459 _dl_rtld_map
.l_libname
= &_dl_rtld_libname
;
462 assert (_dl_rtld_map
.l_libname
); /* How else did we get here? */
465 /* We were called just to verify that this is a dynamic executable
466 using us as the program interpreter. */
467 _exit (main_map
->l_ld
== NULL
? 1 : has_interp
? 0 : 2);
469 /* Extract the contents of the dynamic section for easy access. */
470 elf_get_dynamic_info (main_map
->l_ld
, main_map
->l_info
);
471 if (main_map
->l_info
[DT_HASH
])
472 /* Set up our cache of pointers into the hash table. */
473 _dl_setup_hash (main_map
);
475 if (*user_entry
!= (ElfW(Addr
)) &ENTRY_POINT
)
476 /* Initialize the data structures for the search paths for shared
478 _dl_init_paths (library_path
);
480 /* Put the link_map for ourselves on the chain so it can be found by
481 name. Note that at this point the global chain of link maps contains
482 exactly one element, which is pointed to by main_map. */
483 if (! _dl_rtld_map
.l_name
)
484 /* If not invoked directly, the dynamic linker shared object file was
485 found by the PT_INTERP name. */
486 _dl_rtld_map
.l_name
= (char *) _dl_rtld_map
.l_libname
->name
;
487 _dl_rtld_map
.l_type
= lt_library
;
488 main_map
->l_next
= &_dl_rtld_map
;
489 _dl_rtld_map
.l_prev
= main_map
;
491 /* We have two ways to specify objects to preload: via environment
492 variable and via the file /etc/ld.so.preload. The later can also
493 be used when security is enabled. */
499 /* The LD_PRELOAD environment variable gives list of libraries
500 separated by white space or colons that are loaded before the
501 executable's dependencies and prepended to the global scope
502 list. If the binary is running setuid all elements
503 containing a '/' are ignored since it is insecure. */
504 char *list
= strdupa (preloadlist
);
506 while ((p
= strsep (&list
, " :")) != NULL
)
507 if (! __libc_enable_secure
|| strchr (p
, '/') == NULL
)
509 struct link_map
*new_map
= _dl_map_object (NULL
, p
, 1,
511 if (new_map
->l_opencount
== 1)
512 /* It is no duplicate. */
517 /* Read the contents of the file. */
518 file
= _dl_sysdep_read_whole_file ("/etc/ld.so.preload", &file_size
,
519 PROT_READ
| PROT_WRITE
);
522 /* Parse the file. It contains names of libraries to be loaded,
523 separated by white spaces or `:'. It may also contain
524 comments introduced by `#'. */
529 /* Eliminate comments. */
534 char *comment
= memchr (runp
, '#', rest
);
538 rest
-= comment
- runp
;
541 while (--rest
> 0 && *++comment
!= '\n');
544 /* We have one problematic case: if we have a name at the end of
545 the file without a trailing terminating characters, we cannot
546 place the \0. Handle the case separately. */
547 if (file
[file_size
- 1] != ' ' && file
[file_size
- 1] != '\t'
548 && file
[file_size
- 1] != '\n' && file
[file_size
- 1] != ':')
550 problem
= &file
[file_size
];
551 while (problem
> file
&& problem
[-1] != ' ' && problem
[-1] != '\t'
552 && problem
[-1] != '\n' && problem
[-1] != ':')
561 file
[file_size
- 1] = '\0';
567 runp
= file
+ strspn (file
, ": \t\n");
568 while ((p
= strsep (&runp
, ": \t\n")) != NULL
)
570 struct link_map
*new_map
= _dl_map_object (NULL
, p
, 1,
572 if (new_map
->l_opencount
== 1)
573 /* It is no duplicate. */
577 runp
+= strspn (runp
, ": \t\n");
583 char *p
= strndupa (problem
, file_size
- (problem
- file
));
584 struct link_map
*new_map
= _dl_map_object (NULL
, p
, 1,
586 if (new_map
->l_opencount
== 1)
587 /* It is no duplicate. */
591 /* We don't need the file anymore. */
592 __munmap (file
, file_size
);
597 /* Set up PRELOADS with a vector of the preloaded libraries. */
599 preloads
= __alloca (npreloads
* sizeof preloads
[0]);
600 l
= _dl_rtld_map
.l_next
; /* End of the chain before preloads. */
607 assert (i
== npreloads
);
610 /* Load all the libraries specified by DT_NEEDED entries. If LD_PRELOAD
611 specified some libraries to load, these are inserted before the actual
612 dependencies in the executable's searchlist for symbol resolution. */
613 _dl_map_object_deps (main_map
, preloads
, npreloads
, mode
== trace
);
616 /* We are done mapping things, so close the zero-fill descriptor. */
617 __close (_dl_zerofd
);
621 /* Remove _dl_rtld_map from the chain. */
622 _dl_rtld_map
.l_prev
->l_next
= _dl_rtld_map
.l_next
;
623 if (_dl_rtld_map
.l_next
)
624 _dl_rtld_map
.l_next
->l_prev
= _dl_rtld_map
.l_prev
;
626 if (_dl_rtld_map
.l_opencount
)
628 /* Some DT_NEEDED entry referred to the interpreter object itself, so
629 put it back in the list of visible objects. We insert it into the
630 chain in symbol search order because gdb uses the chain's order as
631 its symbol search order. */
633 while (main_map
->l_searchlist
[i
] != &_dl_rtld_map
)
635 _dl_rtld_map
.l_prev
= main_map
->l_searchlist
[i
- 1];
636 _dl_rtld_map
.l_next
= (i
+ 1 < main_map
->l_nsearchlist
?
637 main_map
->l_searchlist
[i
+ 1] : NULL
);
638 assert (_dl_rtld_map
.l_prev
->l_next
== _dl_rtld_map
.l_next
);
639 _dl_rtld_map
.l_prev
->l_next
= &_dl_rtld_map
;
640 if (_dl_rtld_map
.l_next
)
642 assert (_dl_rtld_map
.l_next
->l_prev
== _dl_rtld_map
.l_prev
);
643 _dl_rtld_map
.l_next
->l_prev
= &_dl_rtld_map
;
647 /* Now let us see whether all libraries are available in the
650 struct version_check_args args
;
651 args
.doexit
= mode
== normal
;
652 args
.main_map
= main_map
;
653 _dl_receive_error (print_missing_version
, version_check_doit
, &args
);
658 /* We were run just to list the shared libraries. It is
659 important that we do this before real relocation, because the
660 functions we call below for output may no longer work properly
662 if (! _dl_loaded
->l_info
[DT_NEEDED
])
663 _dl_sysdep_message ("\t", "statically linked\n", NULL
);
668 for (l
= _dl_loaded
->l_next
; l
; l
= l
->l_next
)
669 if (l
->l_opencount
== 0)
670 /* The library was not found. */
671 _dl_sysdep_message ("\t", l
->l_libname
->name
, " => not found\n",
676 buf
[sizeof buf
- 1] = '\0';
677 bp
= _itoa_word (l
->l_addr
, &buf
[sizeof buf
- 1], 16, 0);
678 while ((size_t) (&buf
[sizeof buf
- 1] - bp
)
679 < sizeof l
->l_addr
* 2)
681 _dl_sysdep_message ("\t", l
->l_libname
->name
, " => ",
682 l
->l_name
, " (0x", bp
, ")\n", NULL
);
687 for (i
= 1; i
< _dl_argc
; ++i
)
689 const ElfW(Sym
) *ref
= NULL
;
690 ElfW(Addr
) loadbase
= _dl_lookup_symbol (_dl_argv
[i
], &ref
,
691 &_dl_default_scope
[2],
693 ELF_MACHINE_JMP_SLOT
);
695 buf
[sizeof buf
- 1] = '\0';
696 bp
= _itoa_word (ref
->st_value
, &buf
[sizeof buf
- 1], 16, 0);
697 while ((size_t) (&buf
[sizeof buf
- 1] - bp
) < sizeof loadbase
* 2)
699 _dl_sysdep_message (_dl_argv
[i
], " found at 0x", bp
, NULL
);
700 buf
[sizeof buf
- 1] = '\0';
701 bp
= _itoa_word (loadbase
, &buf
[sizeof buf
- 1], 16, 0);
702 while ((size_t) (&buf
[sizeof buf
- 1] - bp
) < sizeof loadbase
* 2)
704 _dl_sysdep_message (" in object at 0x", bp
, "\n", NULL
);
710 /* We have to do symbol dependency testing. */
711 struct relocate_args args
;
721 if (l
!= &_dl_rtld_map
&& l
->l_opencount
> 0)
724 _dl_receive_error (print_unresolved
, relocate_doit
,
726 *_dl_global_scope_end
= NULL
;
732 #define VERNEEDTAG (DT_NUM + DT_PROCNUM + DT_VERSIONTAGIDX (DT_VERNEED))
735 /* Print more information. This means here, print information
736 about the versions needed. */
738 struct link_map
*map
= _dl_loaded
;
740 for (map
= _dl_loaded
; map
!= NULL
; map
= map
->l_next
)
743 ElfW(Dyn
) *dyn
= map
->l_info
[VERNEEDTAG
];
749 strtab
= (const char *)
750 (map
->l_addr
+ map
->l_info
[DT_STRTAB
]->d_un
.d_ptr
);
751 ent
= (ElfW(Verneed
) *) (map
->l_addr
+ dyn
->d_un
.d_ptr
);
755 _dl_sysdep_message ("\n\tVersion information:\n", NULL
);
759 _dl_sysdep_message ("\t", (map
->l_name
[0]
760 ? map
->l_name
: _dl_argv
[0]),
766 struct link_map
*needed
;
768 needed
= find_needed (strtab
+ ent
->vn_file
);
769 aux
= (ElfW(Vernaux
) *) ((char *) ent
+ ent
->vn_aux
);
773 const char *fname
= NULL
;
775 _dl_sysdep_message ("\t\t",
776 strtab
+ ent
->vn_file
,
777 " (", strtab
+ aux
->vna_name
,
785 && match_version (strtab
+aux
->vna_name
, needed
))
786 fname
= needed
->l_name
;
788 _dl_sysdep_message (fname
?: "not found", "\n",
791 if (aux
->vna_next
== 0)
792 /* No more symbols. */
796 aux
= (ElfW(Vernaux
) *) ((char *) aux
800 if (ent
->vn_next
== 0)
801 /* No more dependencies. */
804 /* Next dependency. */
805 ent
= (ElfW(Verneed
) *) ((char *) ent
+ ent
->vn_next
);
815 /* Now we have all the objects loaded. Relocate them all except for
816 the dynamic linker itself. We do this in reverse order so that copy
817 relocs of earlier objects overwrite the data written by later
818 objects. We do not re-relocate the dynamic linker itself in this
819 loop because that could result in the GOT entries for functions we
820 call being changed, and that would break us. It is safe to relocate
821 the dynamic linker out of order because it has no copy relocs (we
822 know that because it is self-contained). */
830 if (l
!= &_dl_rtld_map
)
832 _dl_relocate_object (l
, _dl_object_relocation_scope (l
), lazy
);
833 *_dl_global_scope_end
= NULL
;
838 /* Do any necessary cleanups for the startup OS interface code.
839 We do these now so that no calls are made after rtld re-relocation
840 which might be resolved to different functions than we expect.
841 We cannot do this before relocating the other objects because
842 _dl_relocate_object might need to call `mprotect' for DT_TEXTREL. */
843 _dl_sysdep_start_cleanup ();
845 if (_dl_rtld_map
.l_opencount
> 0)
846 /* There was an explicit ref to the dynamic linker as a shared lib.
847 Re-relocate ourselves with user-controlled symbol definitions. */
848 _dl_relocate_object (&_dl_rtld_map
, &_dl_default_scope
[2], 0);
852 /* Initialize _r_debug. */
853 struct r_debug
*r
= _dl_debug_initialize (_dl_rtld_map
.l_addr
);
858 #ifdef ELF_MACHINE_DEBUG_SETUP
860 /* Some machines (e.g. MIPS) don't use DT_DEBUG in this way. */
862 ELF_MACHINE_DEBUG_SETUP (l
, r
);
863 ELF_MACHINE_DEBUG_SETUP (&_dl_rtld_map
, r
);
867 if (l
->l_info
[DT_DEBUG
])
868 /* There is a DT_DEBUG entry in the dynamic section. Fill it in
869 with the run-time address of the r_debug structure */
870 l
->l_info
[DT_DEBUG
]->d_un
.d_ptr
= (ElfW(Addr
)) r
;
872 /* Fill in the pointer in the dynamic linker's own dynamic section, in
873 case you run gdb on the dynamic linker directly. */
874 if (_dl_rtld_map
.l_info
[DT_DEBUG
])
875 _dl_rtld_map
.l_info
[DT_DEBUG
]->d_un
.d_ptr
= (ElfW(Addr
)) r
;
879 /* Notify the debugger that all objects are now mapped in. */
884 /* Now enable profiling if needed. */
885 if (_dl_profile_map
!= NULL
)
886 /* We must prepare the profiling. */
887 _dl_start_profile (_dl_profile_map
, _dl_profile_output
);
889 /* Once we return, _dl_sysdep_start will invoke
890 the DT_INIT functions and then *USER_ENTRY. */
893 /* This is a little helper function for resolving symbols while
894 tracing the binary. */
896 print_unresolved (int errcode
__attribute__ ((unused
)), const char *objname
,
897 const char *errstring
)
899 if (objname
[0] == '\0')
900 objname
= _dl_argv
[0] ?: "<main program>";
901 _dl_sysdep_error (errstring
, " (", objname
, ")\n", NULL
);
904 /* This is a little helper function for resolving symbols while
905 tracing the binary. */
907 print_missing_version (int errcode
__attribute__ ((unused
)),
908 const char *objname
, const char *errstring
)
910 _dl_sysdep_error (_dl_argv
[0] ?: "<program name unknown>", ": ",
911 objname
, ": ", errstring
, "\n", NULL
);
914 /* Nonzero if any of the debugging options is enabled. */
915 static int any_debug
;
917 /* Process the string given as the parameter which explains which debugging
918 options are enabled. */
920 process_dl_debug (char *dl_debug
)
924 #define issep(Ch) ((Ch) == ' ' || (Ch) == ',')
925 /* Skip separating white spaces and commas. */
926 while (issep (*dl_debug
))
928 if (*dl_debug
!= '\0')
930 if (strncmp (dl_debug
, "bindings", 8) == 0
931 && (issep (dl_debug
[8]) || dl_debug
[8] == '\0'))
933 _dl_debug_bindings
= 1;
934 _dl_debug_impcalls
= 1;
938 else if (strncmp (dl_debug
, "libs", 4) == 0
939 && (issep (dl_debug
[4]) || dl_debug
[4] == '\0'))
942 _dl_debug_impcalls
= 1;
946 else if (strncmp (dl_debug
, "help", 4) == 0
947 && (issep (dl_debug
[4]) || dl_debug
[4] == '\0'))
949 _dl_sysdep_message ("\
950 Valid options for the LD_DEBUG environment variable are:\n\
952 bindings display information about symbol binding\n\
953 help display this help message and exit\n\
954 libs display library search paths\n\
955 symbols display symbol table processing\n\
957 To direct the debugging output into a file instead of standard output\n\
958 a filename can be specified using the LD_DEBUG_OUTPUT environment variable.\n",
962 else if (strncmp (dl_debug
, "symbols", 7) == 0
963 && (issep (dl_debug
[7]) || dl_debug
[7] == '\0'))
965 _dl_debug_symbols
= 1;
966 _dl_debug_impcalls
= 1;
972 /* Display a warning and skip everything until next
974 char *startp
= dl_debug
;
978 while (*dl_debug
!= '\0' && !issep (*dl_debug
));
980 startp
= strndupa (startp
, dl_debug
- startp
);
981 _dl_sysdep_error ("warning: debug option `", startp
,
982 "' unknown; try LD_DEBUG=help\n", NULL
);
987 while (*dl_debug
!= '\0');
990 /* Process all environments variables the dynamic linker must recognize.
991 Since all of them start with `LD_' we are a bit smarter while finding
994 process_envvars (enum mode
*modep
, int *lazyp
)
998 enum mode mode
= normal
;
1000 char *debug_output
= NULL
;
1002 /* This is the default place for profiling data file. */
1003 _dl_profile_output
= "/var/tmp";
1005 while ((envline
= _dl_next_ld_env_entry (&runp
)) != NULL
)
1009 /* Do we bind early? */
1010 result
= strncmp (&envline
[3], "BIND_NOW=", 9);
1019 /* Debugging of the dynamic linker? */
1020 result
= strncmp (&envline
[3], "DEBUG=", 6);
1023 process_dl_debug (&envline
[9]);
1029 /* Where to place the profiling data file. */
1030 result
= strncmp (&envline
[3], "DEBUG_OUTPUT=", 13);
1033 debug_output
= &envline
[16];
1039 /* The library search path. */
1040 result
= strncmp (&envline
[3], "LIBRARY_PATH=", 13);
1043 library_path
= &envline
[16];
1049 /* List of objects to be preloaded. */
1050 result
= strncmp (&envline
[3], "PRELOAD=", 8);
1053 preloadlist
= &envline
[11];
1059 /* Which shared object shall be profiled. */
1060 result
= strncmp (&envline
[3], "PROFILE=", 8);
1063 _dl_profile
= &envline
[11];
1064 if (*_dl_profile
== '\0')
1071 /* Where to place the profiling data file. */
1072 result
= strncmp (&envline
[3], "PROFILE_OUTPUT=", 15);
1075 _dl_profile_output
= &envline
[18];
1076 if (*_dl_profile_output
== '\0')
1077 _dl_profile_output
= "/var/tmp";
1083 /* Test whether we want to see the content of the auxiliary
1084 array passed up from the kernel. */
1085 result
= strncmp (&envline
[3], "SHOW_AUXV=", 10);
1094 /* The mode of the dynamic linker can be set. */
1095 result
= strncmp (&envline
[3], "TRACE_LOADED_OBJECTS=", 21);
1104 /* Print information about versions. */
1105 result
= strncmp (&envline
[3], "VERBOSE=", 8);
1108 version_info
= envline
[11] != '\0';
1114 /* Warning level, verbose or not. */
1115 result
= strncmp (&envline
[3], "WARN=", 5);
1118 _dl_verbose
= envline
[8] != '\0';
1123 /* If we have to run the dynamic linker in debugging mode and the
1124 LD_DEBUG_OUTPUT environment variable is given, we write the debug
1125 messages to this file. */
1126 if (any_debug
&& debug_output
!= NULL
)
1128 _dl_debug_fd
= __open (debug_output
, O_WRONLY
| O_APPEND
| O_CREAT
,
1130 if (_dl_debug_fd
== -1)
1131 /* We use standard output if opening the file failed. */
1132 _dl_debug_fd
= STDOUT_FILENO
;
1135 /* LAZY is determined by the environment variable LD_WARN and
1136 LD_BIND_NOW if we trace the binary. */
1138 *lazyp
= _dl_verbose
? !bind_now
: -1;
1140 *lazyp
= !__libc_enable_secure
&& !bind_now
;