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   /* We are done mapping things, so close the zero-fill descriptor.  */
 243   __close (_dl_zerofd);
 244   _dl_zerofd = -1;
 245
 246   /* Remove _dl_rtld_map from the chain.  */
 247   _dl_rtld_map.l_prev->l_next = _dl_rtld_map.l_next;
 248   if (_dl_rtld_map.l_next)
 249     _dl_rtld_map.l_next->l_prev = _dl_rtld_map.l_prev;
 250
 251   if (_dl_rtld_map.l_opencount)
 252     {
 253       /* Some DT_NEEDED entry referred to the interpreter object itself, so
 254          put it back in the list of visible objects.  We insert it into the
 255          chain in symbol search order because gdb uses the chain's order as
 256          its symbol search order.  */
 257       unsigned int i = 1;
 258       while (l->l_searchlist[i] != &_dl_rtld_map)
 259         ++i;
 260       _dl_rtld_map.l_prev = l->l_searchlist[i - 1];
 261       _dl_rtld_map.l_next = (i + 1 < l->l_nsearchlist ?
 262                              l->l_searchlist[i + 1] : NULL);
 263       assert (_dl_rtld_map.l_prev->l_next == _dl_rtld_map.l_next);
 264       _dl_rtld_map.l_prev->l_next = &_dl_rtld_map;
 265       if (_dl_rtld_map.l_next)
 266         {
 267           assert (_dl_rtld_map.l_next->l_prev == _dl_rtld_map.l_prev);
 268           _dl_rtld_map.l_next->l_prev = &_dl_rtld_map;
 269         }
 270     }
 271
 272   if (list_only)
 273     {
 274       /* We were run just to list the shared libraries.  It is
 275          important that we do this before real relocation, because the
 276          functions we call below for output may no longer work properly
 277          after relocation.  */
 278
 279       int i;
 280
 281       if (! _dl_loaded->l_info[DT_NEEDED])
 282         _dl_sysdep_message ("\t", "statically linked\n", NULL);
 283       else
 284         for (l = _dl_loaded->l_next; l; l = l->l_next)
 285           {
 286             char buf[20], *bp;
 287             buf[sizeof buf - 1] = '\0';
 288             bp = _itoa (l->l_addr, &buf[sizeof buf - 1], 16, 0);
 289             while (&buf[sizeof buf - 1] - bp < sizeof l->l_addr * 2)
 290               *--bp = '0';
 291             _dl_sysdep_message ("\t", l->l_libname, " => ", l->l_name,
 292                                 " (0x", bp, ")\n", NULL);
 293           }
 294
 295       for (i = 1; i < _dl_argc; ++i)
 296         {
 297           const ElfW(Sym) *ref = NULL;
 298           ElfW(Addr) loadbase = _dl_lookup_symbol (_dl_argv[i], &ref,
 299                                                    &_dl_default_scope[2],
 300                                                    "argument", 0, 0);
 301           char buf[20], *bp;
 302           buf[sizeof buf - 1] = '\0';
 303           bp = _itoa (ref->st_value, &buf[sizeof buf - 1], 16, 0);
 304           while (&buf[sizeof buf - 1] - bp < sizeof loadbase * 2)
 305             *--bp = '0';
 306           _dl_sysdep_message (_dl_argv[i], " found at 0x", bp, NULL);
 307           buf[sizeof buf - 1] = '\0';
 308           bp = _itoa (loadbase, &buf[sizeof buf - 1], 16, 0);
 309           while (&buf[sizeof buf - 1] - bp < sizeof loadbase * 2)
 310             *--bp = '0';
 311           _dl_sysdep_message (" in object at 0x", bp, "\n", NULL);
 312         }
 313
 314       _exit (0);
 315     }
 316
 317   lazy = !_dl_secure && *(getenv ("LD_BIND_NOW") ?: "") == '\0';
 318
 319   {
 320     /* Now we have all the objects loaded.  Relocate them all except for
 321        the dynamic linker itself.  We do this in reverse order so that copy
 322        relocs of earlier objects overwrite the data written by later
 323        objects.  We do not re-relocate the dynamic linker itself in this
 324        loop because that could result in the GOT entries for functions we
 325        call being changed, and that would break us.  It is safe to relocate
 326        the dynamic linker out of order because it has no copy relocs (we
 327        know that because it is self-contained).  */
 328
 329     l = _dl_loaded;
 330     while (l->l_next)
 331       l = l->l_next;
 332     do
 333       {
 334         if (l != &_dl_rtld_map)
 335           {
 336             _dl_relocate_object (l, _dl_object_relocation_scope (l), lazy);
 337             *_dl_global_scope_end = NULL;
 338           }
 339         l = l->l_prev;
 340       } while (l);
 341
 342     /* Do any necessary cleanups for the startup OS interface code.
 343        We do these now so that no calls are made after rtld re-relocation
 344        which might be resolved to different functions than we expect.
 345        We cannot do this before relocating the other objects because
 346        _dl_relocate_object might need to call `mprotect' for DT_TEXTREL.  */
 347     _dl_sysdep_start_cleanup ();
 348
 349     if (_dl_rtld_map.l_opencount > 0)
 350       /* There was an explicit ref to the dynamic linker as a shared lib.
 351          Re-relocate ourselves with user-controlled symbol definitions.  */
 352       _dl_relocate_object (&_dl_rtld_map, &_dl_default_scope[2], 0);
 353   }
 354
 355   {
 356     /* Initialize _r_debug.  */
 357     struct r_debug *r = _dl_debug_initialize (_dl_rtld_map.l_addr);
 358
 359     l = _dl_loaded;
 360     if (l->l_info[DT_DEBUG])
 361       /* There is a DT_DEBUG entry in the dynamic section.  Fill it in
 362          with the run-time address of the r_debug structure  */
 363       l->l_info[DT_DEBUG]->d_un.d_ptr = (ElfW(Addr)) r;
 364
 365     /* Notify the debugger that all objects are now mapped in.  */
 366     r->r_state = RT_ADD;
 367     _dl_debug_state ();
 368   }
 369
 370   if (_dl_rtld_map.l_info[DT_INIT])
 371     {
 372       /* Call the initializer for the compatibility version of the
 373          dynamic linker.  There is no additional initialization
 374          required for the ABI-compliant dynamic linker.  */
 375
 376       (*(void (*) (void)) (_dl_rtld_map.l_addr +
 377                            _dl_rtld_map.l_info[DT_INIT]->d_un.d_ptr)) ();
 378
 379       /* Clear the field so a future dlopen won't run it again.  */
 380       _dl_rtld_map.l_info[DT_INIT] = NULL;
 381     }
 382
 383   /* Once we return, _dl_sysdep_start will invoke
 384      the DT_INIT functions and then *USER_ENTRY.  */
 385 }