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.
   4
   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.
   9
  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.
  14
  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.  */
  19
  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"
  26
  27
  28 #ifdef RTLD_START
  29 RTLD_START
  30 #else
  31 #error "sysdeps/MACHINE/dl-machine.h fails to define RTLD_START"
  32 #endif
  33
  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 ElfW(Addr) _dl_sysdep_start (void **start_argptr,
  39                                     void (*dl_main) (const ElfW(Phdr) *phdr,
  40                                                      ElfW(Half) phent,
  41                                                      ElfW(Addr) *user_entry));
  42 extern void _dl_sysdep_start_cleanup (void);
  43
  44 int _dl_secure;
  45 int _dl_argc;
  46 char **_dl_argv;
  47 const char *_dl_rpath;
  48
  49 static void dl_main (const ElfW(Phdr) *phdr,
  50                      ElfW(Half) phent,
  51                      ElfW(Addr) *user_entry);
  52
  53 struct link_map _dl_rtld_map;
  54
  55 ElfW(Addr)
  56 _dl_start (void *arg)
  57 {
  58   struct link_map bootstrap_map;
  59
  60   /* Figure out the run-time load address of the dynamic linker itself.  */
  61   bootstrap_map.l_addr = elf_machine_load_address ();
  62
  63   /* Read our own dynamic section and fill in the info array.
  64      Conveniently, the first element of the GOT contains the
  65      offset of _DYNAMIC relative to the run-time load address.  */
  66   bootstrap_map.l_ld = (void *) bootstrap_map.l_addr + *elf_machine_got ();
  67   elf_get_dynamic_info (bootstrap_map.l_ld, bootstrap_map.l_info);
  68
  69 #ifdef ELF_MACHINE_BEFORE_RTLD_RELOC
  70   ELF_MACHINE_BEFORE_RTLD_RELOC (bootstrap_map.l_info);
  71 #endif
  72
  73   /* Relocate ourselves so we can do normal function calls and
  74      data access using the global offset table.  */
  75
  76   ELF_DYNAMIC_RELOCATE (&bootstrap_map, 0, NULL);
  77
  78
  79   /* Now life is sane; we can call functions and access global data.
  80      Set up to use the operating system facilities, and find out from
  81      the operating system's program loader where to find the program
  82      header table in core.  */
  83
  84
  85   /* Transfer data about ourselves to the permanent link_map structure.  */
  86   _dl_rtld_map.l_addr = bootstrap_map.l_addr;
  87   _dl_rtld_map.l_ld = bootstrap_map.l_ld;
  88   memcpy (_dl_rtld_map.l_info, bootstrap_map.l_info,
  89           sizeof _dl_rtld_map.l_info);
  90   _dl_setup_hash (&_dl_rtld_map);
  91
  92   /* Cache the DT_RPATH stored in ld.so itself; this will be
  93      the default search path.  */
  94   _dl_rpath = (void *) (_dl_rtld_map.l_addr +
  95                         _dl_rtld_map.l_info[DT_STRTAB]->d_un.d_ptr +
  96                         _dl_rtld_map.l_info[DT_RPATH]->d_un.d_val);
  97
  98   /* Call the OS-dependent function to set up life so we can do things like
  99      file access.  It will call `dl_main' (below) to do all the real work
 100      of the dynamic linker, and then unwind our frame and run the user
 101      entry point on the same stack we entered on.  */
 102   return _dl_sysdep_start (arg, &dl_main);
 103 }
 104
 105
 106 /* Now life is peachy; we can do all normal operations.
 107    On to the real work.  */
 108
 109 void _start (void);
 110
 111 unsigned int _dl_skip_args;     /* Nonzero if we were run directly.  */
 112
 113 static void
 114 dl_main (const ElfW(Phdr) *phdr,
 115          ElfW(Half) phent,
 116          ElfW(Addr) *user_entry)
 117 {
 118   const ElfW(Phdr) *ph;
 119   struct link_map *l;
 120   const char *interpreter_name;
 121   int lazy;
 122   int list_only = 0;
 123
 124   if (*user_entry == (ElfW(Addr)) &_start)
 125     {
 126       /* Ho ho.  We are not the program interpreter!  We are the program
 127          itself!  This means someone ran ld.so as a command.  Well, that
 128          might be convenient to do sometimes.  We support it by
 129          interpreting the args like this:
 130
 131          ld.so PROGRAM ARGS...
 132
 133          The first argument is the name of a file containing an ELF
 134          executable we will load and run with the following arguments.
 135          To simplify life here, PROGRAM is searched for using the
 136          normal rules for shared objects, rather than $PATH or anything
 137          like that.  We just load it and use its entry point; we don't
 138          pay attention to its PT_INTERP command (we are the interpreter
 139          ourselves).  This is an easy way to test a new ld.so before
 140          installing it.  */
 141       if (_dl_argc < 2)
 142         _dl_sysdep_fatal ("\
 143 Usage: ld.so [--list] EXECUTABLE-FILE [ARGS-FOR-PROGRAM...]\n\
 144 You have invoked `ld.so', the helper program for shared library executables.\n\
 145 This program usually lives in the file `/lib/ld.so', and special directives\n\
 146 in executable files using ELF shared libraries tell the system's program\n\
 147 loader to load the helper program from this file.  This helper program loads\n\
 148 the shared libraries needed by the program executable, prepares the program\n\
 149 to run, and runs it.  You may invoke this helper program directly from the\n\
 150 command line to load and run an ELF executable file; this is like executing\n\
 151 that file itself, but always uses this helper program from the file you\n\
 152 specified, instead of the helper program file specified in the executable\n\
 153 file you run.  This is mostly of use for maintainers to test new versions\n\
 154 of this helper program; chances are you did not intend to run this program.\n",
 155                           NULL);
 156
 157       interpreter_name = _dl_argv[0];
 158
 159       if (! strcmp (_dl_argv[1], "--list"))
 160         {
 161           list_only = 1;
 162
 163           ++_dl_skip_args;
 164           --_dl_argc;
 165           ++_dl_argv;
 166         }
 167
 168       ++_dl_skip_args;
 169       --_dl_argc;
 170       ++_dl_argv;
 171
 172       l = _dl_map_object (NULL, _dl_argv[0], lt_library);
 173       phdr = l->l_phdr;
 174       phent = l->l_phnum;
 175       l->l_name = (char *) "";
 176       *user_entry = l->l_entry;
 177     }
 178   else
 179     {
 180       /* Create a link_map for the executable itself.
 181          This will be what dlopen on "" returns.  */
 182       l = _dl_new_object ((char *) "", "", lt_library);
 183       l->l_phdr = phdr;
 184       l->l_phnum = phent;
 185       interpreter_name = 0;
 186       l->l_entry = *user_entry;
 187     }
 188
 189   if (l != _dl_loaded)
 190     {
 191       /* GDB assumes that the first element on the chain is the
 192          link_map for the executable itself, and always skips it.
 193          Make sure the first one is indeed that one.  */
 194       l->l_prev->l_next = l->l_next;
 195       if (l->l_next)
 196         l->l_next->l_prev = l->l_prev;
 197       l->l_prev = NULL;
 198       l->l_next = _dl_loaded;
 199       _dl_loaded->l_prev = l;
 200       _dl_loaded = l;
 201     }
 202
 203   /* Scan the program header table for the dynamic section.  */
 204   for (ph = phdr; ph < &phdr[phent]; ++ph)
 205     switch (ph->p_type)
 206       {
 207       case PT_DYNAMIC:
 208         /* This tells us where to find the dynamic section,
 209            which tells us everything we need to do.  */
 210         l->l_ld = (void *) l->l_addr + ph->p_vaddr;
 211         break;
 212       case PT_INTERP:
 213         /* This "interpreter segment" was used by the program loader to
 214            find the program interpreter, which is this program itself, the
 215            dynamic linker.  We note what name finds us, so that a future
 216            dlopen call or DT_NEEDED entry, for something that wants to link
 217            against the dynamic linker as a shared library, will know that
 218            the shared object is already loaded.  */
 219         interpreter_name = (void *) l->l_addr + ph->p_vaddr;
 220         break;
 221       }
 222   assert (interpreter_name);    /* How else did we get here?  */
 223
 224   /* Extract the contents of the dynamic section for easy access.  */
 225   elf_get_dynamic_info (l->l_ld, l->l_info);
 226   if (l->l_info[DT_HASH])
 227     /* Set up our cache of pointers into the hash table.  */
 228     _dl_setup_hash (l);
 229
 230   /* Put the link_map for ourselves on the chain so it can be found by
 231      name.  */
 232   _dl_rtld_map.l_name = (char *) _dl_rtld_map.l_libname = interpreter_name;
 233   _dl_rtld_map.l_type = lt_library;
 234   while (l->l_next)
 235     l = l->l_next;
 236   l->l_next = &_dl_rtld_map;
 237   _dl_rtld_map.l_prev = l;
 238
 239   /* Load all the libraries specified by DT_NEEDED entries.  */
 240   _dl_map_object_deps (l);
 241
 242   /* XXX if kept, move it so l_next list is in dep order because
 243      it will determine gdb's search order.
 244      Perhaps do this always, so later dlopen by name finds it?
 245      XXX But then gdb always considers it present.  */
 246   if (_dl_rtld_map.l_opencount == 0)
 247     {
 248       /* No DT_NEEDED entry referred to the interpreter object itself,
 249          so remove it from the list of visible objects.  */
 250       _dl_rtld_map.l_prev->l_next = _dl_rtld_map.l_next;
 251       if (_dl_rtld_map.l_next)
 252         _dl_rtld_map.l_next->l_prev = _dl_rtld_map.l_prev;
 253     }
 254
 255   if (list_only)
 256     {
 257       /* We were run just to list the shared libraries.  It is
 258          important that we do this before real relocation, because the
 259          functions we call below for output may no longer work properly
 260          after relocation.  */
 261
 262       int i;
 263
 264       if (! _dl_loaded->l_info[DT_NEEDED])
 265         _dl_sysdep_message ("\t", "statically linked\n", NULL);
 266       else
 267         for (l = _dl_loaded->l_next; l; l = l->l_next)
 268           {
 269             char buf[20], *bp;
 270             buf[sizeof buf - 1] = '\0';
 271             bp = _itoa (l->l_addr, &buf[sizeof buf - 1], 16, 0);
 272             while (&buf[sizeof buf - 1] - bp < sizeof l->l_addr * 2)
 273               *--bp = '0';
 274             _dl_sysdep_message ("\t", l->l_libname, " => ", l->l_name,
 275                                 " (0x", bp, ")\n", NULL);
 276           }
 277
 278       for (i = 1; i < _dl_argc; ++i)
 279         {
 280           const ElfW(Sym) *ref = NULL;
 281           ElfW(Addr) loadbase = _dl_lookup_symbol (_dl_argv[i], &ref,
 282                                                    &_dl_default_scope[2],
 283                                                    "argument", 0, 0);
 284           char buf[20], *bp;
 285           buf[sizeof buf - 1] = '\0';
 286           bp = _itoa (ref->st_value, &buf[sizeof buf - 1], 16, 0);
 287           while (&buf[sizeof buf - 1] - bp < sizeof loadbase * 2)
 288             *--bp = '0';
 289           _dl_sysdep_message (_dl_argv[i], " found at 0x", bp, NULL);
 290           buf[sizeof buf - 1] = '\0';
 291           bp = _itoa (loadbase, &buf[sizeof buf - 1], 16, 0);
 292           while (&buf[sizeof buf - 1] - bp < sizeof loadbase * 2)
 293             *--bp = '0';
 294           _dl_sysdep_message (" in object at 0x", bp, "\n", NULL);
 295         }
 296
 297       _exit (0);
 298     }
 299
 300   lazy = !_dl_secure && *(getenv ("LD_BIND_NOW") ?: "") == '\0';
 301
 302   {
 303     /* Now we have all the objects loaded.  Relocate them all except for
 304        the dynamic linker itself.  We do this in reverse order so that copy
 305        relocs of earlier objects overwrite the data written by later
 306        objects.  We do not re-relocate the dynamic linker itself in this
 307        loop because that could result in the GOT entries for functions we
 308        call being changed, and that would break us.  It is safe to relocate
 309        the dynamic linker out of order because it has no copy relocs (we
 310        know that because it is self-contained).  */
 311
 312     l = _dl_loaded;
 313     while (l->l_next)
 314       l = l->l_next;
 315     do
 316       {
 317         if (l != &_dl_rtld_map)
 318           {
 319             _dl_relocate_object (l, _dl_object_relocation_scope (l), lazy);
 320             *_dl_global_scope_end = NULL;
 321           }
 322         l = l->l_prev;
 323       } while (l);
 324
 325     /* Do any necessary cleanups for the startup OS interface code.
 326        We do these now so that no calls are made after rtld re-relocation
 327        which might be resolved to different functions than we expect.
 328        We cannot do this before relocating the other objects because
 329        _dl_relocate_object might need to call `mprotect' for DT_TEXTREL.  */
 330     _dl_sysdep_start_cleanup ();
 331
 332     if (_dl_rtld_map.l_opencount > 0)
 333       /* There was an explicit ref to the dynamic linker as a shared lib.
 334          Re-relocate ourselves with user-controlled symbol definitions.  */
 335       _dl_relocate_object (&_dl_rtld_map, &_dl_default_scope[2], 0);
 336   }
 337
 338   {
 339     /* Initialize _r_debug.  */
 340     struct r_debug *r = _dl_debug_initialize (_dl_rtld_map.l_addr);
 341
 342     l = _dl_loaded;
 343     if (l->l_info[DT_DEBUG])
 344       /* There is a DT_DEBUG entry in the dynamic section.  Fill it in
 345          with the run-time address of the r_debug structure  */
 346       l->l_info[DT_DEBUG]->d_un.d_ptr = (ElfW(Addr)) r;
 347
 348     /* Notify the debugger that all objects are now mapped in.  */
 349     r->r_state = RT_ADD;
 350     _dl_debug_state ();
 351   }
 352
 353   if (_dl_rtld_map.l_info[DT_INIT])
 354     {
 355       /* Call the initializer for the compatibility version of the
 356          dynamic linker.  There is no additional initialization
 357          required for the ABI-compliant dynamic linker.  */
 358
 359       (*(void (*) (void)) (_dl_rtld_map.l_addr +
 360                            _dl_rtld_map.l_info[DT_INIT]->d_un.d_ptr)) ();
 361
 362       /* Clear the field so a future dlopen won't run it again.  */
 363       _dl_rtld_map.l_info[DT_INIT] = NULL;
 364     }
 365
 366   /* Once we return, _dl_sysdep_start will invoke
 367      the DT_INIT functions and then *USER_ENTRY.  */
 368 }