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