]>
sourceware.org Git - glibc.git/blob - elf/rtld.c
1 /* Run time dynamic linker.
2 Copyright (C) 1995, 1996 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
17 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
18 Cambridge, MA 02139, USA. */
25 #include <sys/mman.h> /* Check if MAP_ANON is defined. */
26 #include "../stdio-common/_itoa.h"
28 #include "dynamic-link.h"
31 /* System-specific function to do initial startup for the dynamic linker.
32 After this, file access calls and getenv must work. This is responsible
33 for setting __libc_enable_secure if we need to be secure (e.g. setuid),
34 and for setting _dl_argc and _dl_argv, and then calling _dl_main. */
35 extern ElfW(Addr
) _dl_sysdep_start (void **start_argptr
,
36 void (*dl_main
) (const ElfW(Phdr
) *phdr
,
38 ElfW(Addr
) *user_entry
));
39 extern void _dl_sysdep_start_cleanup (void);
43 const char *_dl_rpath
;
45 /* Set nonzero during loading and initialization of executable and
46 libraries, cleared before the executable's entry point runs. This
47 must not be initialized to nonzero, because the unused dynamic
48 linker loaded in for libc.so's "ld.so.1" dep will provide the
49 definition seen by libc.so's initializer; that value must be zero,
50 and will be since that dynamic linker's _dl_start and dl_main will
54 static void dl_main (const ElfW(Phdr
) *phdr
,
56 ElfW(Addr
) *user_entry
);
58 struct link_map _dl_rtld_map
;
63 #error "sysdeps/MACHINE/dl-machine.h fails to define RTLD_START"
69 struct link_map bootstrap_map
;
71 /* This #define produces dynamic linking inline functions for
72 bootstrap relocation instead of general-purpose relocation. */
73 #define RTLD_BOOTSTRAP
74 #define RESOLVE(sym, flags) bootstrap_map.l_addr
75 #include "dynamic-link.h"
77 /* Figure out the run-time load address of the dynamic linker itself. */
78 bootstrap_map
.l_addr
= elf_machine_load_address ();
80 /* Read our own dynamic section and fill in the info array.
81 Conveniently, the first element of the GOT contains the
82 offset of _DYNAMIC relative to the run-time load address. */
83 bootstrap_map
.l_ld
= (void *) bootstrap_map
.l_addr
+ *elf_machine_got ();
84 elf_get_dynamic_info (bootstrap_map
.l_ld
, bootstrap_map
.l_info
);
86 #ifdef ELF_MACHINE_BEFORE_RTLD_RELOC
87 ELF_MACHINE_BEFORE_RTLD_RELOC (bootstrap_map
.l_info
);
90 /* Relocate ourselves so we can do normal function calls and
91 data access using the global offset table. */
93 ELF_DYNAMIC_RELOCATE (&bootstrap_map
, 0);
96 /* Now life is sane; we can call functions and access global data.
97 Set up to use the operating system facilities, and find out from
98 the operating system's program loader where to find the program
99 header table in core. */
102 /* Transfer data about ourselves to the permanent link_map structure. */
103 _dl_rtld_map
.l_addr
= bootstrap_map
.l_addr
;
104 _dl_rtld_map
.l_ld
= bootstrap_map
.l_ld
;
105 memcpy (_dl_rtld_map
.l_info
, bootstrap_map
.l_info
,
106 sizeof _dl_rtld_map
.l_info
);
107 _dl_setup_hash (&_dl_rtld_map
);
109 /* Cache the DT_RPATH stored in ld.so itself; this will be
110 the default search path. */
111 _dl_rpath
= (void *) (_dl_rtld_map
.l_addr
+
112 _dl_rtld_map
.l_info
[DT_STRTAB
]->d_un
.d_ptr
+
113 _dl_rtld_map
.l_info
[DT_RPATH
]->d_un
.d_val
);
115 /* Call the OS-dependent function to set up life so we can do things like
116 file access. It will call `dl_main' (below) to do all the real work
117 of the dynamic linker, and then unwind our frame and run the user
118 entry point on the same stack we entered on. */
119 return _dl_sysdep_start (arg
, &dl_main
);
123 /* Now life is peachy; we can do all normal operations.
124 On to the real work. */
128 unsigned int _dl_skip_args
; /* Nonzero if we were run directly. */
131 dl_main (const ElfW(Phdr
) *phdr
,
133 ElfW(Addr
) *user_entry
)
135 const ElfW(Phdr
) *ph
;
138 enum { normal
, list
, verify
, trace
} mode
;
139 struct link_map
**preloads
;
140 unsigned int npreloads
;
142 mode
= getenv ("LD_TRACE_LOADED_OBJECTS") != NULL
? trace
: normal
;
144 if (*user_entry
== (ElfW(Addr
)) &_start
)
146 /* Ho ho. We are not the program interpreter! We are the program
147 itself! This means someone ran ld.so as a command. Well, that
148 might be convenient to do sometimes. We support it by
149 interpreting the args like this:
151 ld.so PROGRAM ARGS...
153 The first argument is the name of a file containing an ELF
154 executable we will load and run with the following arguments.
155 To simplify life here, PROGRAM is searched for using the
156 normal rules for shared objects, rather than $PATH or anything
157 like that. We just load it and use its entry point; we don't
158 pay attention to its PT_INTERP command (we are the interpreter
159 ourselves). This is an easy way to test a new ld.so before
163 Usage: ld.so [--list|--verify] EXECUTABLE-FILE [ARGS-FOR-PROGRAM...]\n\
164 You have invoked `ld.so', the helper program for shared library executables.\n\
165 This program usually lives in the file `/lib/ld.so', and special directives\n\
166 in executable files using ELF shared libraries tell the system's program\n\
167 loader to load the helper program from this file. This helper program loads\n\
168 the shared libraries needed by the program executable, prepares the program\n\
169 to run, and runs it. You may invoke this helper program directly from the\n\
170 command line to load and run an ELF executable file; this is like executing\n\
171 that file itself, but always uses this helper program from the file you\n\
172 specified, instead of the helper program file specified in the executable\n\
173 file you run. This is mostly of use for maintainers to test new versions\n\
174 of this helper program; chances are you did not intend to run this program.\n",
177 /* Note the place where the dynamic linker actually came from. */
178 _dl_rtld_map
.l_name
= _dl_argv
[0];
180 if (! strcmp (_dl_argv
[1], "--list"))
188 else if (! strcmp (_dl_argv
[1], "--verify"))
205 l
= _dl_map_object (NULL
, _dl_argv
[0], lt_library
);
207 char *err_str
= NULL
;
208 const char *obj_name
__attribute__ ((unused
));
210 (void) _dl_catch_error (&err_str
, &obj_name
, doit
);
214 _exit (EXIT_FAILURE
);
218 l
= _dl_map_object (NULL
, _dl_argv
[0], lt_library
);
222 l
->l_name
= (char *) "";
223 *user_entry
= l
->l_entry
;
227 /* Create a link_map for the executable itself.
228 This will be what dlopen on "" returns. */
229 l
= _dl_new_object ((char *) "", "", lt_executable
);
232 l
->l_entry
= *user_entry
;
237 /* GDB assumes that the first element on the chain is the
238 link_map for the executable itself, and always skips it.
239 Make sure the first one is indeed that one. */
240 l
->l_prev
->l_next
= l
->l_next
;
242 l
->l_next
->l_prev
= l
->l_prev
;
244 l
->l_next
= _dl_loaded
;
245 _dl_loaded
->l_prev
= l
;
249 /* Scan the program header table for the dynamic section. */
250 for (ph
= phdr
; ph
< &phdr
[phent
]; ++ph
)
254 /* This tells us where to find the dynamic section,
255 which tells us everything we need to do. */
256 l
->l_ld
= (void *) l
->l_addr
+ ph
->p_vaddr
;
259 /* This "interpreter segment" was used by the program loader to
260 find the program interpreter, which is this program itself, the
261 dynamic linker. We note what name finds us, so that a future
262 dlopen call or DT_NEEDED entry, for something that wants to link
263 against the dynamic linker as a shared library, will know that
264 the shared object is already loaded. */
265 _dl_rtld_map
.l_libname
= (const char *) l
->l_addr
+ ph
->p_vaddr
;
268 if (! _dl_rtld_map
.l_libname
&& _dl_rtld_map
.l_name
)
269 /* We were invoked directly, so the program might not have a PT_INTERP. */
270 _dl_rtld_map
.l_libname
= _dl_rtld_map
.l_name
;
272 assert (_dl_rtld_map
.l_libname
); /* How else did we get here? */
275 /* We were called just to verify that this is a dynamic executable
276 using us as the program interpreter. */
277 _exit ((strcmp (_dl_rtld_map
.l_libname
, _dl_rtld_map
.l_name
) ||
279 ? EXIT_FAILURE
: EXIT_SUCCESS
);
281 /* Extract the contents of the dynamic section for easy access. */
282 elf_get_dynamic_info (l
->l_ld
, l
->l_info
);
283 if (l
->l_info
[DT_HASH
])
284 /* Set up our cache of pointers into the hash table. */
287 /* Put the link_map for ourselves on the chain so it can be found by
289 if (! _dl_rtld_map
.l_name
)
290 /* If not invoked directly, the dynamic linker shared object file was
291 found by the PT_INTERP name. */
292 _dl_rtld_map
.l_name
= (char *) _dl_rtld_map
.l_libname
;
293 _dl_rtld_map
.l_type
= lt_library
;
296 l
->l_next
= &_dl_rtld_map
;
297 _dl_rtld_map
.l_prev
= l
;
301 if (! __libc_enable_secure
)
303 const char *preloadlist
= getenv ("LD_PRELOAD");
306 /* The LD_PRELOAD environment variable gives a colon-separated
307 list of libraries that are loaded before the executable's
308 dependencies and prepended to the global scope list. */
309 char *list
= strdupa (preloadlist
);
311 while ((p
= strsep (&list
, ":")) != NULL
)
313 (void) _dl_map_object (NULL
, p
, lt_library
);
319 /* Set up PRELOADS with a vector of the preloaded libraries. */
322 preloads
= __alloca (npreloads
* sizeof preloads
[0]);
323 l
= _dl_rtld_map
.l_next
; /* End of the chain before preloads. */
330 assert (i
== npreloads
);
335 /* Load all the libraries specified by DT_NEEDED entries. If LD_PRELOAD
336 specified some libraries to load, these are inserted before the actual
337 dependencies in the executable's searchlist for symbol resolution. */
338 _dl_map_object_deps (l
, preloads
, npreloads
);
341 /* We are done mapping things, so close the zero-fill descriptor. */
342 __close (_dl_zerofd
);
346 /* Remove _dl_rtld_map from the chain. */
347 _dl_rtld_map
.l_prev
->l_next
= _dl_rtld_map
.l_next
;
348 if (_dl_rtld_map
.l_next
)
349 _dl_rtld_map
.l_next
->l_prev
= _dl_rtld_map
.l_prev
;
351 if (_dl_rtld_map
.l_opencount
)
353 /* Some DT_NEEDED entry referred to the interpreter object itself, so
354 put it back in the list of visible objects. We insert it into the
355 chain in symbol search order because gdb uses the chain's order as
356 its symbol search order. */
358 while (l
->l_searchlist
[i
] != &_dl_rtld_map
)
360 _dl_rtld_map
.l_prev
= l
->l_searchlist
[i
- 1];
361 _dl_rtld_map
.l_next
= (i
+ 1 < l
->l_nsearchlist
?
362 l
->l_searchlist
[i
+ 1] : NULL
);
363 assert (_dl_rtld_map
.l_prev
->l_next
== _dl_rtld_map
.l_next
);
364 _dl_rtld_map
.l_prev
->l_next
= &_dl_rtld_map
;
365 if (_dl_rtld_map
.l_next
)
367 assert (_dl_rtld_map
.l_next
->l_prev
== _dl_rtld_map
.l_prev
);
368 _dl_rtld_map
.l_next
->l_prev
= &_dl_rtld_map
;
374 /* We were run just to list the shared libraries. It is
375 important that we do this before real relocation, because the
376 functions we call below for output may no longer work properly
381 if (! _dl_loaded
->l_info
[DT_NEEDED
])
382 _dl_sysdep_message ("\t", "statically linked\n", NULL
);
384 for (l
= _dl_loaded
->l_next
; l
; l
= l
->l_next
)
387 buf
[sizeof buf
- 1] = '\0';
388 bp
= _itoa (l
->l_addr
, &buf
[sizeof buf
- 1], 16, 0);
389 while (&buf
[sizeof buf
- 1] - bp
< sizeof l
->l_addr
* 2)
391 _dl_sysdep_message ("\t", l
->l_libname
, " => ", l
->l_name
,
392 " (0x", bp
, ")\n", NULL
);
396 for (i
= 1; i
< _dl_argc
; ++i
)
398 const ElfW(Sym
) *ref
= NULL
;
399 ElfW(Addr
) loadbase
= _dl_lookup_symbol (_dl_argv
[i
], &ref
,
400 &_dl_default_scope
[2],
404 buf
[sizeof buf
- 1] = '\0';
405 bp
= _itoa (ref
->st_value
, &buf
[sizeof buf
- 1], 16, 0);
406 while (&buf
[sizeof buf
- 1] - bp
< sizeof loadbase
* 2)
408 _dl_sysdep_message (_dl_argv
[i
], " found at 0x", bp
, NULL
);
409 buf
[sizeof buf
- 1] = '\0';
410 bp
= _itoa (loadbase
, &buf
[sizeof buf
- 1], 16, 0);
411 while (&buf
[sizeof buf
- 1] - bp
< sizeof loadbase
* 2)
413 _dl_sysdep_message (" in object at 0x", bp
, "\n", NULL
);
419 lazy
= !__libc_enable_secure
&& *(getenv ("LD_BIND_NOW") ?: "") == '\0';
422 /* Now we have all the objects loaded. Relocate them all except for
423 the dynamic linker itself. We do this in reverse order so that copy
424 relocs of earlier objects overwrite the data written by later
425 objects. We do not re-relocate the dynamic linker itself in this
426 loop because that could result in the GOT entries for functions we
427 call being changed, and that would break us. It is safe to relocate
428 the dynamic linker out of order because it has no copy relocs (we
429 know that because it is self-contained). */
436 if (l
!= &_dl_rtld_map
)
438 _dl_relocate_object (l
, _dl_object_relocation_scope (l
), lazy
);
439 *_dl_global_scope_end
= NULL
;
444 /* Do any necessary cleanups for the startup OS interface code.
445 We do these now so that no calls are made after rtld re-relocation
446 which might be resolved to different functions than we expect.
447 We cannot do this before relocating the other objects because
448 _dl_relocate_object might need to call `mprotect' for DT_TEXTREL. */
449 _dl_sysdep_start_cleanup ();
451 if (_dl_rtld_map
.l_opencount
> 0)
452 /* There was an explicit ref to the dynamic linker as a shared lib.
453 Re-relocate ourselves with user-controlled symbol definitions. */
454 _dl_relocate_object (&_dl_rtld_map
, &_dl_default_scope
[2], 0);
458 /* Initialize _r_debug. */
459 struct r_debug
*r
= _dl_debug_initialize (_dl_rtld_map
.l_addr
);
463 #ifdef ELF_MACHINE_DEBUG_SETUP
465 /* Some machines (e.g. MIPS) don't use DT_DEBUG in this way. */
467 ELF_MACHINE_DEBUG_SETUP (l
, r
);
468 ELF_MACHINE_DEBUG_SETUP (&_dl_rtld_map
, r
);
472 if (l
->l_info
[DT_DEBUG
])
473 /* There is a DT_DEBUG entry in the dynamic section. Fill it in
474 with the run-time address of the r_debug structure */
475 l
->l_info
[DT_DEBUG
]->d_un
.d_ptr
= (ElfW(Addr
)) r
;
477 /* Fill in the pointer in the dynamic linker's own dynamic section, in
478 case you run gdb on the dynamic linker directly. */
479 if (_dl_rtld_map
.l_info
[DT_DEBUG
])
480 _dl_rtld_map
.l_info
[DT_DEBUG
]->d_un
.d_ptr
= (ElfW(Addr
)) r
;
484 /* Notify the debugger that all objects are now mapped in. */
489 if (_dl_rtld_map
.l_info
[DT_INIT
])
491 /* Call the initializer for the compatibility version of the
492 dynamic linker. There is no additional initialization
493 required for the ABI-compliant dynamic linker. */
495 (*(void (*) (int, char **, char**))
496 (_dl_rtld_map
.l_addr
+ _dl_rtld_map
.l_info
[DT_INIT
]->d_un
.d_ptr
))
499 /* Clear the field so a future dlopen won't run it again. */
500 _dl_rtld_map
.l_info
[DT_INIT
] = NULL
;
503 /* We finished the intialization and will start up. */
506 /* Once we return, _dl_sysdep_start will invoke
507 the DT_INIT functions and then *USER_ENTRY. */
This page took 0.060162 seconds and 6 git commands to generate.