elf/rtld.c

   1 /* Run time dynamic linker.
   2 Copyright (C) 1995 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 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);
  43
  44 int _dl_secure;
  45 int _dl_argc;
  46 char **_dl_argv;
  47 const char *_dl_rpath;
  48
  49 struct r_debug dl_r_debug;
  50
  51 static void dl_main (const Elf32_Phdr *phdr,
  52                      Elf32_Word phent,
  53                      Elf32_Addr *user_entry);
  54
  55 static struct link_map rtld_map;
  56
  57 Elf32_Addr
  58 _dl_start (void *arg)
  59 {
  60   struct link_map bootstrap_map;
  61
  62   /* Figure out the run-time load address of the dynamic linker itself.  */
  63   bootstrap_map.l_addr = elf_machine_load_address ();
  64
  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);
  70
  71 #ifdef ELF_MACHINE_BEFORE_RTLD_RELOC
  72   ELF_MACHINE_BEFORE_RTLD_RELOC (bootstrap_map.l_info);
  73 #endif
  74
  75   /* Relocate ourselves so we can do normal function calls and
  76      data access using the global offset table.  */
  77
  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);
  86
  87
  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.  */
  92
  93
  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);
  99
 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);
 105
 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);
 111 }
 112
 113
 114 /* Now life is peachy; we can do all normal operations.
 115    On to the real work.  */
 116
 117 void _start (void);
 118
 119 unsigned int _dl_skip_args;     /* Nonzero if we were run directly.  */
 120
 121 static void
 122 dl_main (const Elf32_Phdr *phdr,
 123          Elf32_Word phent,
 124          Elf32_Addr *user_entry)
 125 {
 126   void doit (void)
 127     {
 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;
 133
 134       if (*user_entry == (Elf32_Addr) &_start)
 135         {
 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:
 140
 141              ld.so PROGRAM ARGS...
 142
 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);
 166
 167           interpreter_name = _dl_argv[0];
 168
 169           if (! strcmp (_dl_argv[1], "--list"))
 170             {
 171               list_only = 1;
 172
 173               ++_dl_skip_args;
 174               --_dl_argc;
 175               ++_dl_argv;
 176             }
 177
 178           ++_dl_skip_args;
 179           --_dl_argc;
 180           ++_dl_argv;
 181
 182           l = _dl_map_object (NULL, _dl_argv[0]);
 183           phdr = l->l_phdr;
 184           phent = l->l_phnum;
 185           l->l_name = (char *) "";
 186           *user_entry = l->l_entry;
 187         }
 188       else
 189         {
 190           /* Create a link_map for the executable itself.
 191              This will be what dlopen on "" returns.  */
 192           l = _dl_new_object ((char *) "", "", lt_executable);
 193           l->l_phdr = phdr;
 194           l->l_phnum = phent;
 195           interpreter_name = 0;
 196           l->l_entry = *user_entry;
 197         }
 198
 199       if (l != _dl_loaded)
 200         {
 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;
 205           if (l->l_next)
 206             l->l_next->l_prev = l->l_prev;
 207           l->l_prev = NULL;
 208           l->l_next = _dl_loaded;
 209           _dl_loaded->l_prev = l;
 210           _dl_loaded = l;
 211         }
 212
 213       /* Scan the program header table for the dynamic section.  */
 214       for (ph = phdr; ph < &phdr[phent]; ++ph)
 215         switch (ph->p_type)
 216           {
 217           case PT_DYNAMIC:
 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;
 221             break;
 222           case PT_INTERP:
 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             interpreter_name = (void *) l->l_addr + ph->p_vaddr;
 230             break;
 231           }
 232       assert (interpreter_name); /* How else did we get here?  */
 233
 234       /* Extract the contents of the dynamic section for easy access.  */
 235       elf_get_dynamic_info (l->l_ld, l->l_info);
 236       if (l->l_info[DT_HASH])
 237         /* Set up our cache of pointers into the hash table.  */
 238         _dl_setup_hash (l);
 239
 240       if (l->l_info[DT_DEBUG])
 241         /* There is a DT_DEBUG entry in the dynamic section.  Fill it in
 242            with the run-time address of the r_debug structure, which we
 243            will set up later to communicate with the debugger.  */
 244         l->l_info[DT_DEBUG]->d_un.d_ptr = (Elf32_Addr) &dl_r_debug;
 245
 246       /* Put the link_map for ourselves on the chain so it can be found by
 247          name.  */
 248       rtld_map.l_name = (char *) rtld_map.l_libname = interpreter_name;
 249       rtld_map.l_type = lt_interpreter;
 250       while (l->l_next)
 251         l = l->l_next;
 252       l->l_next = &rtld_map;
 253       rtld_map.l_prev = l;
 254
 255       /* Now process all the DT_NEEDED entries and map in the objects.
 256          Each new link_map will go on the end of the chain, so we will
 257          come across it later in the loop to map in its dependencies.  */
 258       before_rtld = NULL;
 259       for (l = _dl_loaded; l; l = l->l_next)
 260         {
 261           if (l->l_info[DT_NEEDED])
 262             {
 263               const char *strtab
 264                 = (void *) l->l_addr + l->l_info[DT_STRTAB]->d_un.d_ptr;
 265               const Elf32_Dyn *d;
 266               last = l;
 267               for (d = l->l_ld; d->d_tag != DT_NULL; ++d)
 268                 if (d->d_tag == DT_NEEDED)
 269                   {
 270                     struct link_map *new;
 271                     new = _dl_map_object (l, strtab + d->d_un.d_val);
 272                     new->l_type = lt_library;
 273                     if (!before_rtld && new == &rtld_map)
 274                       before_rtld = last;
 275                     last = new;
 276                   }
 277             }
 278           l->l_deps_loaded = 1;
 279         }
 280
 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)
 288         {
 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;
 294         }
 295
 296       if (list_only)
 297         {
 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.  */
 302
 303           if (! _dl_loaded->l_info[DT_NEEDED])
 304             _dl_sysdep_message ("\t", "statically linked\n", NULL);
 305           else
 306             for (l = _dl_loaded->l_next; l; l = l->l_next)
 307               {
 308                 char buf[20], *bp;
 309                 buf[sizeof buf - 1] = '\0';
 310                 bp = _itoa (l->l_addr, &buf[sizeof buf - 1], 16, 0);
 311                 while (&buf[sizeof buf - 1] - bp < sizeof l->l_addr * 2)
 312                   *--bp = '0';
 313                 _dl_sysdep_message ("\t", l->l_libname, " => ", l->l_name,
 314                                     " (0x", bp, ")\n", NULL);
 315               }
 316
 317           _exit (0);
 318         }
 319
 320       lazy = !_dl_secure && *(getenv ("LD_BIND_NOW") ?: "") == '\0';
 321
 322       /* Do any necessary cleanups for the startup OS interface code.
 323          We do these now so that no calls are made after real relocation
 324          which might be resolved to different functions than we expect.  */
 325       _dl_sysdep_start_cleanup ();
 326
 327       /* Now we have all the objects loaded.  Relocate them all.
 328          We do this in reverse order so that copy relocs of earlier
 329          objects overwrite the data written by later objects.  */
 330       l = _dl_loaded;
 331       while (l->l_next)
 332         l = l->l_next;
 333       do
 334         {
 335           _dl_relocate_object (l, lazy);
 336           l = l->l_prev;
 337         } while (l);
 338
 339       /* Tell the debugger where to find the map of loaded objects.  */
 340       dl_r_debug.r_version = 1  /* R_DEBUG_VERSION XXX */;
 341       dl_r_debug.r_ldbase = rtld_map.l_addr; /* Record our load address.  */
 342       dl_r_debug.r_map = _dl_loaded;
 343       dl_r_debug.r_brk = (Elf32_Addr) &_dl_r_debug_state;
 344
 345       if (rtld_map.l_info[DT_INIT])
 346         {
 347           /* Call the initializer for the compatibility version of the
 348              dynamic linker.  There is no additional initialization
 349              required for the ABI-compliant dynamic linker.  */
 350
 351           (*(void (*) (void)) (rtld_map.l_addr +
 352                                rtld_map.l_info[DT_INIT]->d_un.d_ptr)) ();
 353
 354           /* Clear the field so a future dlopen won't run it again.  */
 355           rtld_map.l_info[DT_INIT] = NULL;
 356         }
 357     }
 358   const char *errstring;
 359   const char *errobj;
 360   int err;
 361
 362   err = _dl_catch_error (&errstring, &errobj, &doit);
 363   if (errstring)
 364     _dl_sysdep_fatal (_dl_argv[0] ?: "<program name unknown>",
 365                       ": error in loading shared libraries\n",
 366                       errobj ?: "", errobj ? ": " : "",
 367                       errstring, err ? ": " : "",
 368                       err ? strerror (err) : "", "\n", NULL);
 369
 370   /* Once we return, _dl_sysdep_start will invoke
 371      the DT_INIT functions and then *USER_ENTRY.  */
 372 }
 373
 374 /* This function exists solely to have a breakpoint set on it by the
 375    debugger.  */
 376 void
 377 _dl_r_debug_state (void)
 378 {
 379 }