1 /* vi: set sw=4 ts=4: */
3 * Program to load an ELF binary on a linux system, and run it
4 * after resolving ELF shared library symbols
6 * Copyright (C) 2005 by Joakim Tjernlund
7 * Copyright (C) 2000-2006 by Erik Andersen <andersen@codepoet.org>
8 * Copyright (c) 1994-2000 Eric Youngdale, Peter MacDonald,
9 * David Engel, Hongjiu Lu and Mitch D'Souza
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. The name of the above contributors may not be
17 * used to endorse or promote products derived from this software
18 * without specific prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 #include "unsecvars.h"
36 /* Pull in common debug code */
39 #define ALLOW_ZERO_PLTGOT
41 /* Pull in the value of _dl_progname */
42 #include LDSO_ELFINTERP
44 /* Global variables used within the shared library loader */
45 char *_dl_library_path = 0; /* Where we look for libraries */
46 char *_dl_preload = 0; /* Things to be loaded before the libs */
47 char *_dl_ldsopath = 0; /* Location of the shared lib loader */
48 int _dl_secure = 1; /* Are we dealing with setuid stuff? */
49 int _dl_errno = 0; /* We can't use the real errno in ldso */
50 size_t _dl_pagesize = 0; /* Store the page size for use later */
51 struct r_debug *_dl_debug_addr = NULL; /* Used to communicate with the gdb debugger */
52 void *(*_dl_malloc_function) (size_t size) = NULL;
53 void (*_dl_free_function) (void *p) = NULL;
55 #ifdef __SUPPORT_LD_DEBUG__
57 char *_dl_debug_symbols = 0;
58 char *_dl_debug_move = 0;
59 char *_dl_debug_reloc = 0;
60 char *_dl_debug_detail = 0;
61 char *_dl_debug_nofixups = 0;
62 char *_dl_debug_bindings = 0;
63 int _dl_debug_file = 2;
66 /* Needed for standalone execution. */
67 unsigned long attribute_hidden _dl_skip_args = 0;
68 const char *_dl_progname = UCLIBC_LDSO; /* The name of the executable being run */
69 #include "dl-startup.c"
71 /* Forward function declarations */
72 static int _dl_suid_ok(void);
75 * This stub function is used by some debuggers. The idea is that they
76 * can set an internal breakpoint on it, so that we are notified when the
77 * address mapping is changed in some way.
79 void _dl_debug_state(void);
80 rtld_hidden_proto(_dl_debug_state, noinline);
81 void _dl_debug_state(void)
83 /* Make sure GCC doesn't recognize this function as pure, to avoid
84 * having the calls optimized away.
88 rtld_hidden_def(_dl_debug_state);
90 static unsigned char *_dl_malloc_addr = 0; /* Lets _dl_malloc use the already allocated memory page */
91 static unsigned char *_dl_mmap_zero = 0; /* Also used by _dl_malloc */
93 static struct elf_resolve **init_fini_list;
94 static unsigned int nlist; /* # items in init_fini_list */
95 extern void _start(void);
97 #ifdef __UCLIBC_HAS_SSP__
98 # include <dl-osinfo.h>
99 uintptr_t stack_chk_guard;
100 # ifndef THREAD_SET_STACK_GUARD
101 /* Only exported for architectures that don't store the stack guard canary
102 * in local thread area. */
103 uintptr_t __stack_chk_guard attribute_relro;
104 # ifdef __UCLIBC_HAS_SSP_COMPAT__
105 strong_alias(__stack_chk_guard,__guard)
107 # elif defined __UCLIBC_HAS_SSP_COMPAT__
108 uintptr_t __guard attribute_relro;
112 static void __attribute__ ((destructor)) __attribute_used__ _dl_fini(void)
115 struct elf_resolve * tpnt;
117 for (i = 0; i < nlist; ++i) {
118 tpnt = init_fini_list[i];
119 if (tpnt->init_flag & FINI_FUNCS_CALLED)
121 tpnt->init_flag |= FINI_FUNCS_CALLED;
122 _dl_run_fini_array(tpnt);
123 if (tpnt->dynamic_info[DT_FINI]) {
124 void (*dl_elf_func) (void);
126 dl_elf_func = (void (*)(void)) (intptr_t) DL_RELOC_ADDR(tpnt->loadaddr, tpnt->dynamic_info[DT_FINI]);
127 _dl_if_debug_dprint("\ncalling FINI: %s\n\n", tpnt->libname);
128 DL_CALL_FUNC_AT_ADDR (dl_elf_func, tpnt->loadaddr, (void(*)(void)));
133 void _dl_get_ready_to_run(struct elf_resolve *tpnt, DL_LOADADDR_TYPE load_addr,
134 ElfW(auxv_t) auxvt[AT_EGID + 1], char **envp,
136 DL_GET_READY_TO_RUN_EXTRA_PARMS)
138 ElfW(Addr) app_mapaddr = 0;
143 int unlazy = 0, trace_loaded_objects = 0;
144 struct dyn_elf *rpnt;
145 struct elf_resolve *tcurr;
146 struct elf_resolve *tpnt1;
147 struct elf_resolve app_tpnt_tmp;
148 struct elf_resolve *app_tpnt = &app_tpnt_tmp;
149 struct r_debug *debug_addr;
151 unsigned long *_dl_envp; /* The environment address */
152 ElfW(Addr) relro_addr = 0;
153 size_t relro_size = 0;
156 /* Wahoo!!! We managed to make a function call! Get malloc
157 * setup so we can use _dl_dprintf() to print debug noise
158 * instead of the SEND_STDERR macros used in dl-startup.c */
160 _dl_memset(app_tpnt, 0x00, sizeof(*app_tpnt));
162 /* Store the page size for later use */
163 _dl_pagesize = (auxvt[AT_PAGESZ].a_un.a_val) ? (size_t) auxvt[AT_PAGESZ].a_un.a_val : PAGE_SIZE;
164 /* Make it so _dl_malloc can use the page of memory we have already
165 * allocated. We shouldn't need to grab any more memory. This must
166 * be first since things like _dl_dprintf() use _dl_malloc()...
168 _dl_malloc_addr = (unsigned char *)_dl_pagesize;
172 _dl_debug_early("Cool, ldso survived making function calls\n");
174 /* Now we have done the mandatory linking of some things. We are now
175 * free to start using global variables, since these things have all
176 * been fixed up by now. Still no function calls outside of this
177 * library, since the dynamic resolver is not yet ready.
180 _dl_progname = argv[0];
183 if (_start == (void *) auxvt[AT_ENTRY].a_un.a_val) {
184 _dl_dprintf(_dl_debug_file, "Standalone execution is not supported yet\n");
188 /* Start to build the tables of the modules that are required for
189 * this beast to run. We start with the basic executable, and then
190 * go from there. Eventually we will run across ourself, and we
191 * will need to properly deal with that as well.
194 if (_dl_getenv("LD_BIND_NOW", envp))
197 /* Now we need to figure out what kind of options are selected.
198 * Note that for SUID programs we ignore the settings in
201 if ((auxvt[AT_UID].a_un.a_val == (size_t)-1 && _dl_suid_ok()) ||
202 (auxvt[AT_UID].a_un.a_val != (size_t)-1 &&
203 auxvt[AT_UID].a_un.a_val == auxvt[AT_EUID].a_un.a_val &&
204 auxvt[AT_GID].a_un.a_val == auxvt[AT_EGID].a_un.a_val)) {
206 _dl_preload = _dl_getenv("LD_PRELOAD", envp);
207 _dl_library_path = _dl_getenv("LD_LIBRARY_PATH", envp);
209 static const char unsecure_envvars[] =
210 #ifdef EXTRA_UNSECURE_ENVVARS
211 EXTRA_UNSECURE_ENVVARS
217 nextp = unsecure_envvars;
219 _dl_unsetenv (nextp, envp);
220 /* We could use rawmemchr but this need not be fast. */
221 nextp = (char *) _dl_strchr(nextp, '\0') + 1;
222 } while (*nextp != '\0');
224 _dl_library_path = NULL;
225 /* SUID binaries can be exploited if they do LAZY relocation. */
229 /* sjhill: your TLS init should go before this */
230 #ifdef __UCLIBC_HAS_SSP__
231 /* Set up the stack checker's canary. */
232 stack_chk_guard = _dl_setup_stack_chk_guard ();
233 # ifdef THREAD_SET_STACK_GUARD
234 THREAD_SET_STACK_GUARD (stack_chk_guard);
235 # ifdef __UCLIBC_HAS_SSP_COMPAT__
236 __guard = stack_chk_guard;
239 __stack_chk_guard = stack_chk_guard;
243 /* At this point we are now free to examine the user application,
244 * and figure out which libraries are supposed to be called. Until
245 * we have this list, we will not be completely ready for dynamic
249 /* Find the runtime load address of the main executable. This may be
250 * different from what the ELF header says for ET_DYN/PIE executables.
254 ElfW(Phdr) *phdr = (ElfW(Phdr) *) auxvt[AT_PHDR].a_un.a_val;
256 for (idx = 0; idx < auxvt[AT_PHNUM].a_un.a_val; idx++, phdr++)
257 if (phdr->p_type == PT_PHDR) {
258 DL_INIT_LOADADDR_PROG(app_tpnt->loadaddr, auxvt[AT_PHDR].a_un.a_val - phdr->p_vaddr);
262 if (DL_LOADADDR_BASE(app_tpnt->loadaddr))
263 _dl_debug_early("Position Independent Executable: "
264 "app_tpnt->loadaddr=%x\n", DL_LOADADDR_BASE(app_tpnt->loadaddr));
268 * This is used by gdb to locate the chain of shared libraries that are
271 debug_addr = _dl_malloc(sizeof(struct r_debug));
272 _dl_memset(debug_addr, 0, sizeof(struct r_debug));
274 ppnt = (ElfW(Phdr) *) auxvt[AT_PHDR].a_un.a_val;
275 for (i = 0; i < auxvt[AT_PHNUM].a_un.a_val; i++, ppnt++) {
276 if (ppnt->p_type == PT_GNU_RELRO) {
277 relro_addr = ppnt->p_vaddr;
278 relro_size = ppnt->p_memsz;
280 if (!app_mapaddr && (ppnt->p_type == PT_LOAD)) {
281 app_mapaddr = DL_RELOC_ADDR (app_tpnt->loadaddr, ppnt->p_vaddr);
283 if (ppnt->p_type == PT_DYNAMIC) {
284 dpnt = (ElfW(Dyn) *) DL_RELOC_ADDR(app_tpnt->loadaddr, ppnt->p_vaddr);
285 _dl_parse_dynamic_info(dpnt, app_tpnt->dynamic_info, debug_addr, app_tpnt->loadaddr);
286 #ifndef __FORCE_SHAREABLE_TEXT_SEGMENTS__
287 /* Ugly, ugly. We need to call mprotect to change the
288 * protection of the text pages so that we can do the
289 * dynamic linking. We can set the protection back
290 * again once we are done.
292 _dl_debug_early("calling mprotect on the application program\n");
293 /* Now cover the application program. */
294 if (app_tpnt->dynamic_info[DT_TEXTREL]) {
295 ElfW(Phdr) *ppnt_outer = ppnt;
296 ppnt = (ElfW(Phdr) *) auxvt[AT_PHDR].a_un.a_val;
297 for (i = 0; i < auxvt[AT_PHNUM].a_un.a_val; i++, ppnt++) {
298 if (ppnt->p_type == PT_LOAD && !(ppnt->p_flags & PF_W))
299 _dl_mprotect((void *) (DL_RELOC_ADDR(app_tpnt->loadaddr, ppnt->p_vaddr) & PAGE_ALIGN),
300 ((ppnt->p_vaddr + app_tpnt->loadaddr) & ADDR_ALIGN) +
301 (unsigned long) ppnt->p_filesz,
302 PROT_READ | PROT_WRITE | PROT_EXEC);
307 if (app_tpnt->dynamic_info[DT_TEXTREL]) {
308 _dl_dprintf(_dl_debug_file, "Can't modify application's text section; use the GCC option -fPIE for position-independent executables.\n");
313 #ifndef ALLOW_ZERO_PLTGOT
314 /* make sure it's really there. */
315 if (app_tpnt->dynamic_info[DT_PLTGOT] == 0)
318 /* OK, we have what we need - slip this one into the list. */
319 app_tpnt = _dl_add_elf_hash_table(_dl_progname, app_tpnt->loadaddr,
320 app_tpnt->dynamic_info,
321 (unsigned long) DL_RELOC_ADDR(app_tpnt->loadaddr, ppnt->p_vaddr),
323 _dl_loaded_modules->libtype = elf_executable;
324 _dl_loaded_modules->ppnt = (ElfW(Phdr) *) auxvt[AT_PHDR].a_un.a_val;
325 _dl_loaded_modules->n_phent = auxvt[AT_PHNUM].a_un.a_val;
326 _dl_symbol_tables = rpnt = (struct dyn_elf *) _dl_malloc(sizeof(struct dyn_elf));
327 _dl_memset(rpnt, 0, sizeof(struct dyn_elf));
328 rpnt->dyn = _dl_loaded_modules;
329 app_tpnt->mapaddr = app_mapaddr;
330 app_tpnt->rtld_flags = unlazy | RTLD_GLOBAL;
331 app_tpnt->usage_count++;
332 app_tpnt->symbol_scope = _dl_symbol_tables;
333 lpnt = (unsigned long *) (app_tpnt->dynamic_info[DT_PLTGOT]);
334 #ifdef ALLOW_ZERO_PLTGOT
337 INIT_GOT(lpnt, _dl_loaded_modules);
340 /* OK, fill this in - we did not have this before */
341 if (ppnt->p_type == PT_INTERP) {
344 tpnt->libname = (char *) DL_RELOC_ADDR(app_tpnt->loadaddr, ppnt->p_vaddr);
346 /* Store the path where the shared lib loader was found
349 _dl_ldsopath = _dl_strdup(tpnt->libname);
350 ptmp = _dl_strrchr(_dl_ldsopath, '/');
351 if (ptmp != _dl_ldsopath)
354 _dl_debug_early("Lib Loader: (%x) %s\n", (unsigned) DL_LOADADDR_BASE(tpnt->loadaddr), tpnt->libname);
357 app_tpnt->relro_addr = relro_addr;
358 app_tpnt->relro_size = relro_size;
360 #ifdef __SUPPORT_LD_DEBUG__
361 _dl_debug = _dl_getenv("LD_DEBUG", envp);
363 if (_dl_strstr(_dl_debug, "all")) {
364 _dl_debug_detail = _dl_debug_move = _dl_debug_symbols
365 = _dl_debug_reloc = _dl_debug_bindings = _dl_debug_nofixups = (void*)1;
367 _dl_debug_detail = _dl_strstr(_dl_debug, "detail");
368 _dl_debug_move = _dl_strstr(_dl_debug, "move");
369 _dl_debug_symbols = _dl_strstr(_dl_debug, "sym");
370 _dl_debug_reloc = _dl_strstr(_dl_debug, "reloc");
371 _dl_debug_nofixups = _dl_strstr(_dl_debug, "nofix");
372 _dl_debug_bindings = _dl_strstr(_dl_debug, "bind");
377 const char *dl_debug_output;
379 dl_debug_output = _dl_getenv("LD_DEBUG_OUTPUT", envp);
381 if (dl_debug_output) {
382 char tmp[22], *tmp1, *filename;
385 _dl_memset(tmp, 0, sizeof(tmp));
386 tmp1 = _dl_simple_ltoa( tmp, (unsigned long)_dl_getpid());
388 len1 = _dl_strlen(dl_debug_output);
389 len2 = _dl_strlen(tmp1);
391 filename = _dl_malloc(len1+len2+2);
394 _dl_strcpy (filename, dl_debug_output);
395 filename[len1] = '.';
396 _dl_strcpy (&filename[len1+1], tmp1);
398 _dl_debug_file= _dl_open(filename, O_WRONLY|O_CREAT, 0644);
399 if (_dl_debug_file < 0) {
401 _dl_dprintf(_dl_debug_file, "can't open file: '%s'\n",filename);
408 if (_dl_getenv("LD_TRACE_LOADED_OBJECTS", envp) != NULL) {
409 trace_loaded_objects++;
412 #ifndef __LDSO_LDD_SUPPORT__
413 if (trace_loaded_objects) {
414 _dl_dprintf(_dl_debug_file, "Use the ldd provided by uClibc\n");
420 * OK, fix one more thing - set up debug_addr so it will point
421 * to our chain. Later we may need to fill in more fields, but this
422 * should be enough for now.
424 debug_addr->r_map = (struct link_map *) _dl_loaded_modules;
425 debug_addr->r_version = 1;
426 debug_addr->r_ldbase = DL_LOADADDR_BASE(load_addr);
427 debug_addr->r_brk = (unsigned long) &_dl_debug_state;
428 _dl_debug_addr = debug_addr;
430 /* Do not notify the debugger until the interpreter is in the list */
432 /* OK, we now have the application in the list, and we have some
433 * basic stuff in place. Now search through the list for other shared
434 * libraries that should be loaded, and insert them on the list in the
444 while (*str == ':' || *str == ' ' || *str == '\t')
449 while (*str2 && *str2 != ':' && *str2 != ' ' && *str2 != '\t')
454 if (!_dl_secure || _dl_strchr(str, '/') == NULL) {
455 _dl_if_debug_dprint("\tfile='%s'; needed by '%s'\n", str, _dl_progname);
457 tpnt1 = _dl_load_shared_library(_dl_secure, &rpnt, NULL, str, trace_loaded_objects);
459 #ifdef __LDSO_LDD_SUPPORT__
460 if (trace_loaded_objects)
461 _dl_dprintf(1, "\t%s => not found\n", str);
465 _dl_dprintf(_dl_debug_file, "%s: can't load " "library '%s'\n", _dl_progname, str);
469 tpnt1->rtld_flags = unlazy | RTLD_GLOBAL;
471 _dl_debug_early("Loading: (%x) %s\n", DL_LOADADDR_BASE(tpnt1->loadaddr), tpnt1->libname);
473 #ifdef __LDSO_LDD_SUPPORT__
474 if (trace_loaded_objects &&
475 tpnt1->usage_count == 1) {
476 /* This is a real hack to make
477 * ldd not print the library
478 * itself when run on a
481 if (_dl_strcmp(_dl_progname, str) != 0)
482 _dl_dprintf(1, "\t%s => %s (%x)\n", str, tpnt1->libname,
483 DL_LOADADDR_BASE(tpnt1->loadaddr));
491 while (*str == ':' || *str == ' ' || *str == '\t')
496 #ifdef __LDSO_PRELOAD_FILE_SUPPORT__
502 if (_dl_stat(LDSO_PRELOAD, &st) || st.st_size == 0) {
506 if ((fd = _dl_open(LDSO_PRELOAD, O_RDONLY, 0)) < 0) {
507 _dl_dprintf(_dl_debug_file, "%s: can't open file '%s'\n",
508 _dl_progname, LDSO_PRELOAD);
512 preload = (caddr_t) _dl_mmap(0, st.st_size + 1,
513 PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
515 if (preload == (caddr_t) -1) {
516 _dl_dprintf(_dl_debug_file, "%s:%i: can't map '%s'\n",
517 _dl_progname, __LINE__, LDSO_PRELOAD);
521 /* convert all separators and comments to spaces */
522 for (cp = preload; *cp; /*nada */ ) {
523 if (*cp == ':' || *cp == '\t' || *cp == '\n') {
525 } else if (*cp == '#') {
528 } while (*cp != '\n' && *cp != '\0');
534 /* find start of first library */
535 for (cp = preload; *cp && *cp == ' '; cp++)
539 /* find end of library */
540 for (cp2 = cp; *cp && *cp != ' '; cp++)
545 _dl_if_debug_dprint("\tfile='%s'; needed by '%s'\n", cp2, _dl_progname);
547 tpnt1 = _dl_load_shared_library(0, &rpnt, NULL, cp2, trace_loaded_objects);
549 #ifdef __LDSO_LDD_SUPPORT__
550 if (trace_loaded_objects)
551 _dl_dprintf(1, "\t%s => not found\n", cp2);
555 _dl_dprintf(_dl_debug_file, "%s: can't load library '%s'\n", _dl_progname, cp2);
559 tpnt1->rtld_flags = unlazy | RTLD_GLOBAL;
561 _dl_debug_early("Loading: (%x) %s\n", DL_LOADADDR_BASE(tpnt1->loadaddr), tpnt1->libname);
563 #ifdef __LDSO_LDD_SUPPORT__
564 if (trace_loaded_objects &&
565 tpnt1->usage_count == 1) {
566 _dl_dprintf(1, "\t%s => %s (%x)\n",
568 DL_LOADADDR_BASE(tpnt1->loadaddr));
573 /* find start of next library */
575 for ( /*nada */ ; *cp && *cp == ' '; cp++)
579 _dl_munmap(preload, st.st_size + 1);
581 #endif /* __LDSO_PRELOAD_FILE_SUPPORT__ */
584 for (tcurr = _dl_loaded_modules; tcurr; tcurr = tcurr->next) {
585 ElfW(Dyn) *this_dpnt;
588 for (this_dpnt = (ElfW(Dyn) *) tcurr->dynamic_addr; this_dpnt->d_tag; this_dpnt++) {
589 if (this_dpnt->d_tag == DT_NEEDED) {
591 struct init_fini_list *tmp;
593 lpntstr = (char*) (tcurr->dynamic_info[DT_STRTAB] + this_dpnt->d_un.d_val);
594 name = _dl_get_last_path_component(lpntstr);
595 if (_dl_strcmp(name, UCLIBC_LDSO) == 0)
598 _dl_if_debug_dprint("\tfile='%s'; needed by '%s'\n", lpntstr, _dl_progname);
600 if (!(tpnt1 = _dl_load_shared_library(0, &rpnt, tcurr, lpntstr, trace_loaded_objects))) {
601 #ifdef __LDSO_LDD_SUPPORT__
602 if (trace_loaded_objects) {
603 _dl_dprintf(1, "\t%s => not found\n", lpntstr);
608 _dl_dprintf(_dl_debug_file, "%s: can't load library '%s'\n", _dl_progname, lpntstr);
613 tmp = alloca(sizeof(struct init_fini_list)); /* Allocates on stack, no need to free this memory */
615 tmp->next = tcurr->init_fini;
616 tcurr->init_fini = tmp;
618 tpnt1->rtld_flags = unlazy | RTLD_GLOBAL;
620 _dl_debug_early("Loading: (%x) %s\n", DL_LOADADDR_BASE(tpnt1->loadaddr), tpnt1->libname);
622 #ifdef __LDSO_LDD_SUPPORT__
623 if (trace_loaded_objects &&
624 tpnt1->usage_count == 1) {
625 _dl_dprintf(1, "\t%s => %s (%x)\n",
626 lpntstr, tpnt1->libname,
627 DL_LOADADDR_BASE(tpnt1->loadaddr));
635 --nlist; /* Exclude the application. */
636 init_fini_list = _dl_malloc(nlist * sizeof(struct elf_resolve *));
638 for (tcurr = _dl_loaded_modules->next; tcurr; tcurr = tcurr->next) {
639 init_fini_list[i++] = tcurr;
642 /* Sort the INIT/FINI list in dependency order. */
643 for (tcurr = _dl_loaded_modules->next; tcurr; tcurr = tcurr->next) {
646 for (j = 0; init_fini_list[j] != tcurr; ++j)
648 for (k = j + 1; k < nlist; ++k) {
649 struct init_fini_list *runp = init_fini_list[k]->init_fini;
651 for (; runp; runp = runp->next) {
652 if (runp->tpnt == tcurr) {
653 struct elf_resolve *here = init_fini_list[k];
654 _dl_if_debug_dprint("Move %s from pos %d to %d in INIT/FINI list\n", here->libname, k, j);
655 for (i = (k - j); i; --i)
656 init_fini_list[i+j] = init_fini_list[i+j-1];
657 init_fini_list[j] = here;
664 #ifdef __SUPPORT_LD_DEBUG__
666 _dl_dprintf(_dl_debug_file, "\nINIT/FINI order and dependencies:\n");
667 for (i = 0; i < nlist; i++) {
668 struct init_fini_list *tmp;
670 _dl_dprintf(_dl_debug_file, "lib: %s has deps:\n",
671 init_fini_list[i]->libname);
672 tmp = init_fini_list[i]->init_fini;
673 for (; tmp; tmp = tmp->next)
674 _dl_dprintf(_dl_debug_file, " %s ", tmp->tpnt->libname);
675 _dl_dprintf(_dl_debug_file, "\n");
681 * If the program interpreter is not in the module chain, add it.
682 * This will be required for dlopen to be able to access the internal
683 * functions in the dynamic linker and to relocate the interpreter
684 * again once all libs are loaded.
687 ElfW(Ehdr) *epnt = (ElfW(Ehdr) *) auxvt[AT_BASE].a_un.a_val;
688 ElfW(Phdr) *myppnt = (ElfW(Phdr) *) DL_RELOC_ADDR(load_addr, epnt->e_phoff);
691 tpnt = _dl_add_elf_hash_table(tpnt->libname, load_addr,
693 (unsigned long)tpnt->dynamic_addr,
696 if (_dl_stat(tpnt->libname, &st) >= 0) {
697 tpnt->st_dev = st.st_dev;
698 tpnt->st_ino = st.st_ino;
700 tpnt->n_phent = epnt->e_phnum;
702 for (j = 0; j < epnt->e_phnum; j++, myppnt++) {
703 if (myppnt->p_type == PT_GNU_RELRO) {
704 tpnt->relro_addr = myppnt->p_vaddr;
705 tpnt->relro_size = myppnt->p_memsz;
709 tpnt->libtype = program_interpreter;
711 tpnt->symbol_scope = _dl_symbol_tables;
713 rpnt->next = (struct dyn_elf *) _dl_malloc(sizeof(struct dyn_elf));
714 _dl_memset(rpnt->next, 0, sizeof(struct dyn_elf));
715 rpnt->next->prev = rpnt;
718 rpnt = (struct dyn_elf *) _dl_malloc(sizeof(struct dyn_elf));
719 _dl_memset(rpnt, 0, sizeof(struct dyn_elf));
722 tpnt->rtld_flags = RTLD_NOW | RTLD_GLOBAL; /* Must not be LAZY */
723 #ifdef RERELOCATE_LDSO
724 /* Only rerelocate functions for now. */
725 tpnt->init_flag = RELOCS_DONE;
726 lpnt = (unsigned long *) (tpnt->dynamic_info[DT_PLTGOT]);
727 # ifdef ALLOW_ZERO_PLTGOT
728 if (tpnt->dynamic_info[DT_PLTGOT])
730 INIT_GOT(lpnt, tpnt);
732 tpnt->init_flag = RELOCS_DONE | JMP_RELOCS_DONE;
737 #ifdef __LDSO_LDD_SUPPORT__
738 /* End of the line for ldd.... */
739 if (trace_loaded_objects) {
740 _dl_dprintf(1, "\t%s => %s (%x)\n",
741 rpnt->dyn->libname + _dl_strlen(_dl_ldsopath) + 1,
742 rpnt->dyn->libname, DL_LOADADDR_BASE(rpnt->dyn->loadaddr));
747 _dl_debug_early("Beginning relocation fixups\n");
751 * Relocation of the GOT entries for MIPS have to be done
752 * after all the libraries have been loaded.
754 _dl_perform_mips_global_got_relocations(_dl_loaded_modules, !unlazy);
758 * OK, now all of the kids are tucked into bed in their proper
759 * addresses. Now we go through and look for REL and RELA records that
760 * indicate fixups to the GOT tables. We need to do this in reverse
761 * order so that COPY directives work correctly.
763 if (_dl_symbol_tables)
764 if (_dl_fixup(_dl_symbol_tables, unlazy))
767 for (tpnt = _dl_loaded_modules; tpnt; tpnt = tpnt->next) {
768 if (tpnt->relro_size)
769 _dl_protect_relro (tpnt);
772 /* OK, at this point things are pretty much ready to run. Now we need
773 * to touch up a few items that are required, and then we can let the
774 * user application have at it. Note that the dynamic linker itself
775 * is not guaranteed to be fully dynamicly linked if we are using
776 * ld.so.1, so we have to look up each symbol individually.
779 _dl_envp = (unsigned long *) (intptr_t) _dl_find_hash(__C_SYMBOL_PREFIX__ "__environ", _dl_symbol_tables, NULL, 0);
781 *_dl_envp = (unsigned long) envp;
783 #ifndef __FORCE_SHAREABLE_TEXT_SEGMENTS__
788 /* We had to set the protections of all pages to R/W for
789 * dynamic linking. Set text pages back to R/O.
791 for (tpnt = _dl_loaded_modules; tpnt; tpnt = tpnt->next) {
792 for (myppnt = tpnt->ppnt, j = 0; j < tpnt->n_phent; j++, myppnt++) {
793 if (myppnt->p_type == PT_LOAD && !(myppnt->p_flags & PF_W) && tpnt->dynamic_info[DT_TEXTREL]) {
794 _dl_mprotect((void *) (DL_RELOC_ADDR(tpnt->loadaddr, myppnt->p_vaddr) & PAGE_ALIGN),
795 (myppnt->p_vaddr & ADDR_ALIGN) + (unsigned long) myppnt->p_filesz, LXFLAGS(myppnt->p_flags));
802 /* Notify the debugger we have added some objects. */
803 _dl_debug_addr->r_state = RT_ADD;
806 /* Run pre-initialization functions for the executable. */
807 _dl_run_array_forward(_dl_loaded_modules->dynamic_info[DT_PREINIT_ARRAY],
808 _dl_loaded_modules->dynamic_info[DT_PREINIT_ARRAYSZ],
809 _dl_loaded_modules->loadaddr);
811 /* Run initialization functions for loaded objects. For the
812 main executable, they will be run from __uClibc_main. */
813 for (i = nlist; i; --i) {
814 tpnt = init_fini_list[i-1];
815 tpnt->init_fini = NULL; /* Clear, since alloca was used */
816 if (tpnt->init_flag & INIT_FUNCS_CALLED)
818 tpnt->init_flag |= INIT_FUNCS_CALLED;
820 if (tpnt->dynamic_info[DT_INIT]) {
821 void (*dl_elf_func) (void);
823 dl_elf_func = (void (*)(void)) DL_RELOC_ADDR(tpnt->loadaddr, tpnt->dynamic_info[DT_INIT]);
825 _dl_if_debug_dprint("calling INIT: %s\n\n", tpnt->libname);
827 DL_CALL_FUNC_AT_ADDR (dl_elf_func, tpnt->loadaddr, (void(*)(void)));
830 _dl_run_init_array(tpnt);
833 /* Find the real malloc function and make ldso functions use that from now on */
834 _dl_malloc_function = (void* (*)(size_t)) (intptr_t) _dl_find_hash(__C_SYMBOL_PREFIX__ "malloc",
835 _dl_symbol_tables, NULL, ELF_RTYPE_CLASS_PLT);
837 /* Notify the debugger that all objects are now mapped in. */
838 _dl_debug_addr->r_state = RT_CONSISTENT;
842 char *_dl_getenv(const char *symbol, char **envp)
847 while ((pnt = *envp++)) {
849 while (*pnt && *pnt == *pnt1)
851 if (!*pnt || *pnt != '=' || *pnt1)
858 void _dl_unsetenv(const char *symbol, char **envp)
862 char **newenvp = envp;
864 for (pnt = *envp; pnt; pnt = *++envp) {
866 while (*pnt && *pnt == *pnt1)
868 if (!*pnt || *pnt != '=' || *pnt1)
875 static int _dl_suid_ok(void)
877 __kernel_uid_t uid, euid;
878 __kernel_gid_t gid, egid;
881 euid = _dl_geteuid();
883 egid = _dl_getegid();
885 if (uid == euid && gid == egid) {
891 void *_dl_malloc(size_t size)
896 _dl_debug_early("request for %d bytes\n", size);
899 if (_dl_malloc_function)
900 return (*_dl_malloc_function) (size);
902 if (_dl_malloc_addr - _dl_mmap_zero + size > _dl_pagesize) {
905 /* Since the above assumes we get a full page even if
906 we request less than that, make sure we request a
907 full page, since uClinux may give us less than than
908 a full page. We might round even
909 larger-than-a-page sizes, but we end up never
910 reusing _dl_mmap_zero/_dl_malloc_addr in that case,
913 The actual page size doesn't really matter; as long
914 as we're self-consistent here, we're safe. */
915 if (size < _dl_pagesize)
916 rounded_size = (size + _dl_pagesize - 1) & _dl_pagesize;
920 _dl_debug_early("mmapping more memory\n");
921 _dl_mmap_zero = _dl_malloc_addr = _dl_mmap((void *) 0, rounded_size,
922 PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
923 if (_dl_mmap_check_error(_dl_mmap_zero)) {
924 _dl_dprintf(_dl_debug_file, "%s: mmap of a spare page failed!\n", _dl_progname);
928 retval = _dl_malloc_addr;
929 _dl_malloc_addr += size;
932 * Align memory to DL_MALLOC_ALIGN byte boundary. Some
933 * platforms require this, others simply get better
936 _dl_malloc_addr = (unsigned char *) (((unsigned long) _dl_malloc_addr + DL_MALLOC_ALIGN - 1) & ~(DL_MALLOC_ALIGN - 1));
940 void _dl_free (void *p)
942 if (_dl_free_function)
943 (*_dl_free_function) (p);