]>
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 _dl_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);
44 const char *_dl_rpath
;
46 static void dl_main (const ElfW(Phdr
) *phdr
,
48 ElfW(Addr
) *user_entry
);
50 struct link_map _dl_rtld_map
;
55 #error "sysdeps/MACHINE/dl-machine.h fails to define RTLD_START"
61 struct link_map bootstrap_map
;
63 /* This #define produces dynamic linking inline functions for
64 bootstrap relocation instead of general-purpose relocation. */
65 #define RTLD_BOOTSTRAP
66 #define RESOLVE(sym, reloc_addr, noplt) bootstrap_map.l_addr
67 #include "dynamic-link.h"
69 /* Figure out the run-time load address of the dynamic linker itself. */
70 bootstrap_map
.l_addr
= elf_machine_load_address ();
72 /* Read our own dynamic section and fill in the info array.
73 Conveniently, the first element of the GOT contains the
74 offset of _DYNAMIC relative to the run-time load address. */
75 bootstrap_map
.l_ld
= (void *) bootstrap_map
.l_addr
+ *elf_machine_got ();
76 elf_get_dynamic_info (bootstrap_map
.l_ld
, bootstrap_map
.l_info
);
78 #ifdef ELF_MACHINE_BEFORE_RTLD_RELOC
79 ELF_MACHINE_BEFORE_RTLD_RELOC (bootstrap_map
.l_info
);
82 /* Relocate ourselves so we can do normal function calls and
83 data access using the global offset table. */
85 ELF_DYNAMIC_RELOCATE (&bootstrap_map
, 0);
88 /* Now life is sane; we can call functions and access global data.
89 Set up to use the operating system facilities, and find out from
90 the operating system's program loader where to find the program
91 header table in core. */
94 /* Transfer data about ourselves to the permanent link_map structure. */
95 _dl_rtld_map
.l_addr
= bootstrap_map
.l_addr
;
96 _dl_rtld_map
.l_ld
= bootstrap_map
.l_ld
;
97 memcpy (_dl_rtld_map
.l_info
, bootstrap_map
.l_info
,
98 sizeof _dl_rtld_map
.l_info
);
99 _dl_setup_hash (&_dl_rtld_map
);
101 /* Cache the DT_RPATH stored in ld.so itself; this will be
102 the default search path. */
103 _dl_rpath
= (void *) (_dl_rtld_map
.l_addr
+
104 _dl_rtld_map
.l_info
[DT_STRTAB
]->d_un
.d_ptr
+
105 _dl_rtld_map
.l_info
[DT_RPATH
]->d_un
.d_val
);
107 /* Call the OS-dependent function to set up life so we can do things like
108 file access. It will call `dl_main' (below) to do all the real work
109 of the dynamic linker, and then unwind our frame and run the user
110 entry point on the same stack we entered on. */
111 return _dl_sysdep_start (arg
, &dl_main
);
115 /* Now life is peachy; we can do all normal operations.
116 On to the real work. */
120 unsigned int _dl_skip_args
; /* Nonzero if we were run directly. */
123 dl_main (const ElfW(Phdr
) *phdr
,
125 ElfW(Addr
) *user_entry
)
127 const ElfW(Phdr
) *ph
;
131 struct link_map
**preloads
;
132 unsigned int npreloads
;
134 if (*user_entry
== (ElfW(Addr
)) &_start
)
136 /* Ho ho. We are not the program interpreter! We are the program
137 itself! This means someone ran ld.so as a command. Well, that
138 might be convenient to do sometimes. We support it by
139 interpreting the args like this:
141 ld.so PROGRAM ARGS...
143 The first argument is the name of a file containing an ELF
144 executable we will load and run with the following arguments.
145 To simplify life here, PROGRAM is searched for using the
146 normal rules for shared objects, rather than $PATH or anything
147 like that. We just load it and use its entry point; we don't
148 pay attention to its PT_INTERP command (we are the interpreter
149 ourselves). This is an easy way to test a new ld.so before
153 Usage: ld.so [--list] EXECUTABLE-FILE [ARGS-FOR-PROGRAM...]\n\
154 You have invoked `ld.so', the helper program for shared library executables.\n\
155 This program usually lives in the file `/lib/ld.so', and special directives\n\
156 in executable files using ELF shared libraries tell the system's program\n\
157 loader to load the helper program from this file. This helper program loads\n\
158 the shared libraries needed by the program executable, prepares the program\n\
159 to run, and runs it. You may invoke this helper program directly from the\n\
160 command line to load and run an ELF executable file; this is like executing\n\
161 that file itself, but always uses this helper program from the file you\n\
162 specified, instead of the helper program file specified in the executable\n\
163 file you run. This is mostly of use for maintainers to test new versions\n\
164 of this helper program; chances are you did not intend to run this program.\n",
167 /* Note the place where the dynamic linker actually came from. */
168 _dl_rtld_map
.l_name
= _dl_argv
[0];
170 if (! strcmp (_dl_argv
[1], "--list"))
183 l
= _dl_map_object (NULL
, _dl_argv
[0], lt_library
);
186 l
->l_name
= (char *) "";
187 *user_entry
= l
->l_entry
;
191 /* Create a link_map for the executable itself.
192 This will be what dlopen on "" returns. */
193 l
= _dl_new_object ((char *) "", "", lt_library
);
196 l
->l_entry
= *user_entry
;
201 /* GDB assumes that the first element on the chain is the
202 link_map for the executable itself, and always skips it.
203 Make sure the first one is indeed that one. */
204 l
->l_prev
->l_next
= l
->l_next
;
206 l
->l_next
->l_prev
= l
->l_prev
;
208 l
->l_next
= _dl_loaded
;
209 _dl_loaded
->l_prev
= l
;
213 /* Scan the program header table for the dynamic section. */
214 for (ph
= phdr
; ph
< &phdr
[phent
]; ++ph
)
218 /* This tells us where to find the dynamic section,
219 which tells us everything we need to do. */
220 l
->l_ld
= (void *) l
->l_addr
+ ph
->p_vaddr
;
223 /* This "interpreter segment" was used by the program loader to
224 find the program interpreter, which is this program itself, the
225 dynamic linker. We note what name finds us, so that a future
226 dlopen call or DT_NEEDED entry, for something that wants to link
227 against the dynamic linker as a shared library, will know that
228 the shared object is already loaded. */
229 _dl_rtld_map
.l_libname
= (const char *) l
->l_addr
+ ph
->p_vaddr
;
232 if (! _dl_rtld_map
.l_libname
&& _dl_rtld_map
.l_name
)
233 /* We were invoked directly, so the program might not have a PT_INTERP. */
234 _dl_rtld_map
.l_libname
= _dl_rtld_map
.l_name
;
236 assert (_dl_rtld_map
.l_libname
); /* How else did we get here? */
238 /* Extract the contents of the dynamic section for easy access. */
239 elf_get_dynamic_info (l
->l_ld
, l
->l_info
);
240 if (l
->l_info
[DT_HASH
])
241 /* Set up our cache of pointers into the hash table. */
244 /* Put the link_map for ourselves on the chain so it can be found by
246 if (! _dl_rtld_map
.l_name
)
247 /* If not invoked directly, the dynamic linker shared object file was
248 found by the PT_INTERP name. */
249 _dl_rtld_map
.l_name
= (char *) _dl_rtld_map
.l_libname
;
250 _dl_rtld_map
.l_type
= lt_library
;
253 l
->l_next
= &_dl_rtld_map
;
254 _dl_rtld_map
.l_prev
= l
;
260 const char *preloadlist
= getenv ("LD_PRELOAD");
263 /* The LD_PRELOAD environment variable gives a colon-separated
264 list of libraries that are loaded before the executable's
265 dependencies and prepended to the global scope list. */
266 char *list
= strdupa (preloadlist
);
268 while ((p
= strsep (&list
, ":")) != NULL
)
270 (void) _dl_map_object (NULL
, p
, lt_library
);
276 /* Set up PRELOADS with a vector of the preloaded libraries. */
279 preloads
= __alloca (npreloads
* sizeof preloads
[0]);
280 l
= _dl_rtld_map
.l_next
; /* End of the chain before preloads. */
287 assert (i
== npreloads
);
292 /* Load all the libraries specified by DT_NEEDED entries. If LD_PRELOAD
293 specified some libraries to load, these are inserted before the actual
294 dependencies in the executable's searchlist for symbol resolution. */
295 _dl_map_object_deps (l
, preloads
, npreloads
);
298 /* We are done mapping things, so close the zero-fill descriptor. */
299 __close (_dl_zerofd
);
303 /* Remove _dl_rtld_map from the chain. */
304 _dl_rtld_map
.l_prev
->l_next
= _dl_rtld_map
.l_next
;
305 if (_dl_rtld_map
.l_next
)
306 _dl_rtld_map
.l_next
->l_prev
= _dl_rtld_map
.l_prev
;
308 if (_dl_rtld_map
.l_opencount
)
310 /* Some DT_NEEDED entry referred to the interpreter object itself, so
311 put it back in the list of visible objects. We insert it into the
312 chain in symbol search order because gdb uses the chain's order as
313 its symbol search order. */
315 while (l
->l_searchlist
[i
] != &_dl_rtld_map
)
317 _dl_rtld_map
.l_prev
= l
->l_searchlist
[i
- 1];
318 _dl_rtld_map
.l_next
= (i
+ 1 < l
->l_nsearchlist
?
319 l
->l_searchlist
[i
+ 1] : NULL
);
320 assert (_dl_rtld_map
.l_prev
->l_next
== _dl_rtld_map
.l_next
);
321 _dl_rtld_map
.l_prev
->l_next
= &_dl_rtld_map
;
322 if (_dl_rtld_map
.l_next
)
324 assert (_dl_rtld_map
.l_next
->l_prev
== _dl_rtld_map
.l_prev
);
325 _dl_rtld_map
.l_next
->l_prev
= &_dl_rtld_map
;
331 /* We were run just to list the shared libraries. It is
332 important that we do this before real relocation, because the
333 functions we call below for output may no longer work properly
338 if (! _dl_loaded
->l_info
[DT_NEEDED
])
339 _dl_sysdep_message ("\t", "statically linked\n", NULL
);
341 for (l
= _dl_loaded
->l_next
; l
; l
= l
->l_next
)
344 buf
[sizeof buf
- 1] = '\0';
345 bp
= _itoa (l
->l_addr
, &buf
[sizeof buf
- 1], 16, 0);
346 while (&buf
[sizeof buf
- 1] - bp
< sizeof l
->l_addr
* 2)
348 _dl_sysdep_message ("\t", l
->l_libname
, " => ", l
->l_name
,
349 " (0x", bp
, ")\n", NULL
);
352 for (i
= 1; i
< _dl_argc
; ++i
)
354 const ElfW(Sym
) *ref
= NULL
;
355 ElfW(Addr
) loadbase
= _dl_lookup_symbol (_dl_argv
[i
], &ref
,
356 &_dl_default_scope
[2],
359 buf
[sizeof buf
- 1] = '\0';
360 bp
= _itoa (ref
->st_value
, &buf
[sizeof buf
- 1], 16, 0);
361 while (&buf
[sizeof buf
- 1] - bp
< sizeof loadbase
* 2)
363 _dl_sysdep_message (_dl_argv
[i
], " found at 0x", bp
, NULL
);
364 buf
[sizeof buf
- 1] = '\0';
365 bp
= _itoa (loadbase
, &buf
[sizeof buf
- 1], 16, 0);
366 while (&buf
[sizeof buf
- 1] - bp
< sizeof loadbase
* 2)
368 _dl_sysdep_message (" in object at 0x", bp
, "\n", NULL
);
374 lazy
= !_dl_secure
&& *(getenv ("LD_BIND_NOW") ?: "") == '\0';
377 /* Now we have all the objects loaded. Relocate them all except for
378 the dynamic linker itself. We do this in reverse order so that copy
379 relocs of earlier objects overwrite the data written by later
380 objects. We do not re-relocate the dynamic linker itself in this
381 loop because that could result in the GOT entries for functions we
382 call being changed, and that would break us. It is safe to relocate
383 the dynamic linker out of order because it has no copy relocs (we
384 know that because it is self-contained). */
391 if (l
!= &_dl_rtld_map
)
393 _dl_relocate_object (l
, _dl_object_relocation_scope (l
), lazy
);
394 *_dl_global_scope_end
= NULL
;
399 /* Do any necessary cleanups for the startup OS interface code.
400 We do these now so that no calls are made after rtld re-relocation
401 which might be resolved to different functions than we expect.
402 We cannot do this before relocating the other objects because
403 _dl_relocate_object might need to call `mprotect' for DT_TEXTREL. */
404 _dl_sysdep_start_cleanup ();
406 if (_dl_rtld_map
.l_opencount
> 0)
407 /* There was an explicit ref to the dynamic linker as a shared lib.
408 Re-relocate ourselves with user-controlled symbol definitions. */
409 _dl_relocate_object (&_dl_rtld_map
, &_dl_default_scope
[2], 0);
413 /* Initialize _r_debug. */
414 struct r_debug
*r
= _dl_debug_initialize (_dl_rtld_map
.l_addr
);
418 #ifdef ELF_MACHINE_DEBUG_SETUP
420 /* Some machines (e.g. MIPS) don't use DT_DEBUG in this way. */
422 ELF_MACHINE_DEBUG_SETUP (l
, r
);
423 ELF_MACHINE_DEBUG_SETUP (&_dl_rtld_map
, r
);
427 if (l
->l_info
[DT_DEBUG
])
428 /* There is a DT_DEBUG entry in the dynamic section. Fill it in
429 with the run-time address of the r_debug structure */
430 l
->l_info
[DT_DEBUG
]->d_un
.d_ptr
= (ElfW(Addr
)) r
;
432 /* Fill in the pointer in the dynamic linker's own dynamic section, in
433 case you run gdb on the dynamic linker directly. */
434 if (_dl_rtld_map
.l_info
[DT_DEBUG
])
435 _dl_rtld_map
.l_info
[DT_DEBUG
]->d_un
.d_ptr
= (ElfW(Addr
)) r
;
439 /* Notify the debugger that all objects are now mapped in. */
444 if (_dl_rtld_map
.l_info
[DT_INIT
])
446 /* Call the initializer for the compatibility version of the
447 dynamic linker. There is no additional initialization
448 required for the ABI-compliant dynamic linker. */
450 (*(void (*) (void)) (_dl_rtld_map
.l_addr
+
451 _dl_rtld_map
.l_info
[DT_INIT
]->d_un
.d_ptr
)) ();
453 /* Clear the field so a future dlopen won't run it again. */
454 _dl_rtld_map
.l_info
[DT_INIT
] = NULL
;
457 /* Once we return, _dl_sysdep_start will invoke
458 the DT_INIT functions and then *USER_ENTRY. */
This page took 0.064428 seconds and 6 git commands to generate.