Fri Dec 8 13:04:51 1995 Roland McGrath <roland@churchy.gnu.ai.mit.edu>
[glibc.git] / elf / rtld.c
blob62d6488767efbe41548a17672e8f771cfc0c3f2e
1 /* Run time dynamic linker.
2 Copyright (C) 1995 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. */
20 #include <link.h>
21 #include "dynamic-link.h"
22 #include <stddef.h>
23 #include <stdlib.h>
24 #include <unistd.h>
25 #include "../stdio-common/_itoa.h"
28 #ifdef RTLD_START
29 RTLD_START
30 #else
31 #error "sysdeps/MACHINE/dl-machine.h fails to define RTLD_START"
32 #endif
34 /* System-specific function to do initial startup for the dynamic linker.
35 After this, file access calls and getenv must work. This is responsible
36 for setting _dl_secure if we need to be secure (e.g. setuid),
37 and for setting _dl_argc and _dl_argv, and then calling _dl_main. */
38 extern Elf32_Addr _dl_sysdep_start (void **start_argptr,
39 void (*dl_main) (const Elf32_Phdr *phdr,
40 Elf32_Word phent,
41 Elf32_Addr *user_entry));
42 extern void _dl_sysdep_start_cleanup (void);
44 int _dl_secure;
45 int _dl_argc;
46 char **_dl_argv;
47 const char *_dl_rpath;
49 struct r_debug dl_r_debug;
51 static void dl_main (const Elf32_Phdr *phdr,
52 Elf32_Word phent,
53 Elf32_Addr *user_entry);
55 static struct link_map rtld_map;
57 Elf32_Addr
58 _dl_start (void *arg)
60 struct link_map bootstrap_map;
62 /* Figure out the run-time load address of the dynamic linker itself. */
63 bootstrap_map.l_addr = elf_machine_load_address ();
65 /* Read our own dynamic section and fill in the info array.
66 Conveniently, the first element of the GOT contains the
67 offset of _DYNAMIC relative to the run-time load address. */
68 bootstrap_map.l_ld = (void *) bootstrap_map.l_addr + *elf_machine_got ();
69 elf_get_dynamic_info (bootstrap_map.l_ld, bootstrap_map.l_info);
71 #ifdef ELF_MACHINE_BEFORE_RTLD_RELOC
72 ELF_MACHINE_BEFORE_RTLD_RELOC (bootstrap_map.l_info);
73 #endif
75 /* Relocate ourselves so we can do normal function calls and
76 data access using the global offset table. */
78 /* We must initialize `l_type' to make sure it is not `lt_interpreter'.
79 That is the type to describe us, but not during bootstrapping--it
80 indicates to elf_machine_rel{,a} that we were already relocated during
81 bootstrapping, so it must anti-perform each bootstrapping relocation
82 before applying the final relocation when ld.so is linked in as
83 normal a shared library. */
84 bootstrap_map.l_type = lt_library;
85 ELF_DYNAMIC_RELOCATE (&bootstrap_map, 0, NULL);
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 rtld_map.l_addr = bootstrap_map.l_addr;
96 rtld_map.l_ld = bootstrap_map.l_ld;
97 memcpy (rtld_map.l_info, bootstrap_map.l_info, sizeof rtld_map.l_info);
98 _dl_setup_hash (&rtld_map);
100 /* Cache the DT_RPATH stored in ld.so itself; this will be
101 the default search path. */
102 _dl_rpath = (void *) (rtld_map.l_addr +
103 rtld_map.l_info[DT_STRTAB]->d_un.d_ptr +
104 rtld_map.l_info[DT_RPATH]->d_un.d_val);
106 /* Call the OS-dependent function to set up life so we can do things like
107 file access. It will call `dl_main' (below) to do all the real work
108 of the dynamic linker, and then unwind our frame and run the user
109 entry point on the same stack we entered on. */
110 return _dl_sysdep_start (&arg, &dl_main);
114 /* Now life is peachy; we can do all normal operations.
115 On to the real work. */
117 void _start (void);
119 unsigned int _dl_skip_args; /* Nonzero if we were run directly. */
121 static void
122 dl_main (const Elf32_Phdr *phdr,
123 Elf32_Word phent,
124 Elf32_Addr *user_entry)
126 void doit (void)
128 const Elf32_Phdr *ph;
129 struct link_map *l, *last, *before_rtld;
130 const char *interpreter_name;
131 int lazy;
132 int list_only = 0;
134 if (*user_entry == (Elf32_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
150 installing it. */
151 if (_dl_argc < 2)
152 _dl_sysdep_fatal ("\
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",
165 NULL);
167 interpreter_name = _dl_argv[0];
169 if (! strcmp (_dl_argv[1], "--list"))
171 list_only = 1;
173 ++_dl_skip_args;
174 --_dl_argc;
175 ++_dl_argv;
178 ++_dl_skip_args;
179 --_dl_argc;
180 ++_dl_argv;
182 l = _dl_map_object (NULL, _dl_argv[0]);
183 phdr = l->l_phdr;
184 phent = l->l_phnum;
185 l->l_type = lt_executable;
186 l->l_libname = (char *) "";
187 *user_entry = l->l_entry;
189 else
191 /* Create a link_map for the executable itself.
192 This will be what dlopen on "" returns. */
193 l = _dl_new_object ((char *) "", "", lt_executable);
194 l->l_phdr = phdr;
195 l->l_phnum = phent;
196 interpreter_name = 0;
197 l->l_entry = *user_entry;
200 if (l != _dl_loaded)
202 /* GDB assumes that the first element on the chain is the
203 link_map for the executable itself, and always skips it.
204 Make sure the first one is indeed that one. */
205 l->l_prev->l_next = l->l_next;
206 if (l->l_next)
207 l->l_next->l_prev = l->l_prev;
208 l->l_prev = NULL;
209 l->l_next = _dl_loaded;
210 _dl_loaded->l_prev = l;
211 _dl_loaded = l;
214 /* Scan the program header table for the dynamic section. */
215 for (ph = phdr; ph < &phdr[phent]; ++ph)
216 switch (ph->p_type)
218 case PT_DYNAMIC:
219 /* This tells us where to find the dynamic section,
220 which tells us everything we need to do. */
221 l->l_ld = (void *) l->l_addr + ph->p_vaddr;
222 break;
223 case PT_INTERP:
224 /* This "interpreter segment" was used by the program loader to
225 find the program interpreter, which is this program itself, the
226 dynamic linker. We note what name finds us, so that a future
227 dlopen call or DT_NEEDED entry, for something that wants to link
228 against the dynamic linker as a shared library, will know that
229 the shared object is already loaded. */
230 interpreter_name = (void *) l->l_addr + ph->p_vaddr;
231 break;
233 assert (interpreter_name); /* How else did we get here? */
235 /* Extract the contents of the dynamic section for easy access. */
236 elf_get_dynamic_info (l->l_ld, l->l_info);
237 if (l->l_info[DT_HASH])
238 /* Set up our cache of pointers into the hash table. */
239 _dl_setup_hash (l);
241 if (l->l_info[DT_DEBUG])
242 /* There is a DT_DEBUG entry in the dynamic section. Fill it in
243 with the run-time address of the r_debug structure, which we
244 will set up later to communicate with the debugger. */
245 l->l_info[DT_DEBUG]->d_un.d_ptr = (Elf32_Addr) &dl_r_debug;
247 /* Put the link_map for ourselves on the chain so it can be found by
248 name. */
249 rtld_map.l_name = (char *) rtld_map.l_libname = interpreter_name;
250 rtld_map.l_type = lt_interpreter;
251 while (l->l_next)
252 l = l->l_next;
253 l->l_next = &rtld_map;
254 rtld_map.l_prev = l;
256 /* Now process all the DT_NEEDED entries and map in the objects.
257 Each new link_map will go on the end of the chain, so we will
258 come across it later in the loop to map in its dependencies. */
259 before_rtld = NULL;
260 for (l = _dl_loaded; l; l = l->l_next)
262 if (l->l_info[DT_NEEDED])
264 const char *strtab
265 = (void *) l->l_addr + l->l_info[DT_STRTAB]->d_un.d_ptr;
266 const Elf32_Dyn *d;
267 last = l;
268 for (d = l->l_ld; d->d_tag != DT_NULL; ++d)
269 if (d->d_tag == DT_NEEDED)
271 struct link_map *new;
272 new = _dl_map_object (l, strtab + d->d_un.d_val);
273 if (!before_rtld && new == &rtld_map)
274 before_rtld = last;
275 last = new;
278 l->l_deps_loaded = 1;
281 /* If any DT_NEEDED entry referred to the interpreter object itself,
282 reorder the list so it appears after its dependent. If not,
283 remove it from the maps we will use for symbol resolution. */
284 rtld_map.l_prev->l_next = rtld_map.l_next;
285 if (rtld_map.l_next)
286 rtld_map.l_next->l_prev = rtld_map.l_prev;
287 if (before_rtld)
289 rtld_map.l_prev = before_rtld;
290 rtld_map.l_next = before_rtld->l_next;
291 before_rtld->l_next = &rtld_map;
292 if (rtld_map.l_next)
293 rtld_map.l_next->l_prev = &rtld_map;
296 if (list_only)
298 /* We were run just to list the shared libraries. It is
299 important that we do this before real relocation, because the
300 functions we call below for output may no longer work properly
301 after relocation. */
303 if (! _dl_loaded->l_info[DT_NEEDED])
305 _dl_sysdep_message (_dl_loaded->l_name, ": statically linked\n",
306 NULL);
307 _exit (1);
310 for (l = _dl_loaded->l_next; l; l = l->l_next)
312 char buf[20], *bp;
313 buf[sizeof buf - 1] = '\0';
314 bp = _itoa (l->l_addr, &buf[sizeof buf - 1], 16, 0);
315 while (&buf[sizeof buf - 1] - bp < sizeof l->l_addr * 2)
316 *--bp = '0';
317 _dl_sysdep_message ("\t", l->l_libname, " => ", l->l_name,
318 " (0x", bp, ")\n", NULL);
321 _exit (0);
324 lazy = !_dl_secure && *(getenv ("LD_BIND_NOW") ?: "") == '\0';
326 /* Do any necessary cleanups for the startup OS interface code.
327 We do these now so that no calls are made after real relocation
328 which might be resolved to different functions than we expect. */
329 _dl_sysdep_start_cleanup ();
331 /* Now we have all the objects loaded. Relocate them all.
332 We do this in reverse order so that copy relocs of earlier
333 objects overwrite the data written by later objects. */
334 l = _dl_loaded;
335 while (l->l_next)
336 l = l->l_next;
339 _dl_relocate_object (l, lazy);
340 l = l->l_prev;
341 } while (l);
343 /* Tell the debugger where to find the map of loaded objects. */
344 dl_r_debug.r_version = 1 /* R_DEBUG_VERSION XXX */;
345 dl_r_debug.r_ldbase = rtld_map.l_addr; /* Record our load address. */
346 dl_r_debug.r_map = _dl_loaded;
347 dl_r_debug.r_brk = (Elf32_Addr) &_dl_r_debug_state;
349 if (rtld_map.l_info[DT_INIT])
351 /* Call the initializer for the compatibility version of the
352 dynamic linker. There is no additional initialization
353 required for the ABI-compliant dynamic linker. */
355 (*(void (*) (void)) (rtld_map.l_addr +
356 rtld_map.l_info[DT_INIT]->d_un.d_ptr)) ();
358 /* Clear the field so a future dlopen won't run it again. */
359 rtld_map.l_info[DT_INIT] = NULL;
362 const char *errstring;
363 const char *errobj;
364 int err;
366 err = _dl_catch_error (&errstring, &errobj, &doit);
367 if (errstring)
368 _dl_sysdep_fatal (_dl_argv[0] ?: "<program name unknown>",
369 ": error in loading shared libraries\n",
370 errobj ?: "", errobj ? ": " : "",
371 errstring, err ? ": " : "",
372 err ? strerror (err) : "", "\n", NULL);
374 /* Once we return, _dl_sysdep_start will invoke
375 the DT_INIT functions and then *USER_ENTRY. */
378 /* This function exists solely to have a breakpoint set on it by the
379 debugger. */
380 void
381 _dl_r_debug_state (void)