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   int lazy;
 121   int list_only = 0;
 122
 123   if (*user_entry == (ElfW(Addr)) &_start)
 124     {
 125       /* Ho ho.  We are not the program interpreter!  We are the program
 126          itself!  This means someone ran ld.so as a command.  Well, that
 127          might be convenient to do sometimes.  We support it by
 128          interpreting the args like this:
 129
 130          ld.so PROGRAM ARGS...
 131
 132          The first argument is the name of a file containing an ELF
 133          executable we will load and run with the following arguments.
 134          To simplify life here, PROGRAM is searched for using the
 135          normal rules for shared objects, rather than $PATH or anything
 136          like that.  We just load it and use its entry point; we don't
 137          pay attention to its PT_INTERP command (we are the interpreter
 138          ourselves).  This is an easy way to test a new ld.so before
 139          installing it.  */
 140       if (_dl_argc < 2)
 141         _dl_sysdep_fatal ("\
 142 Usage: ld.so [--list] EXECUTABLE-FILE [ARGS-FOR-PROGRAM...]\n\
 143 You have invoked `ld.so', the helper program for shared library executables.\n\
 144 This program usually lives in the file `/lib/ld.so', and special directives\n\
 145 in executable files using ELF shared libraries tell the system's program\n\
 146 loader to load the helper program from this file.  This helper program loads\n\
 147 the shared libraries needed by the program executable, prepares the program\n\
 148 to run, and runs it.  You may invoke this helper program directly from the\n\
 149 command line to load and run an ELF executable file; this is like executing\n\
 150 that file itself, but always uses this helper program from the file you\n\
 151 specified, instead of the helper program file specified in the executable\n\
 152 file you run.  This is mostly of use for maintainers to test new versions\n\
 153 of this helper program; chances are you did not intend to run this program.\n",
 154                           NULL);
 155
 156       /* Note the place where the dynamic linker actually came from.  */
 157       _dl_rtld_map.l_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       l->l_entry = *user_entry;
 186     }
 187
 188   if (l != _dl_loaded)
 189     {
 190       /* GDB assumes that the first element on the chain is the
 191          link_map for the executable itself, and always skips it.
 192          Make sure the first one is indeed that one.  */
 193       l->l_prev->l_next = l->l_next;
 194       if (l->l_next)
 195         l->l_next->l_prev = l->l_prev;
 196       l->l_prev = NULL;
 197       l->l_next = _dl_loaded;
 198       _dl_loaded->l_prev = l;
 199       _dl_loaded = l;
 200     }
 201
 202   /* Scan the program header table for the dynamic section.  */
 203   for (ph = phdr; ph < &phdr[phent]; ++ph)
 204     switch (ph->p_type)
 205       {
 206       case PT_DYNAMIC:
 207         /* This tells us where to find the dynamic section,
 208            which tells us everything we need to do.  */
 209         l->l_ld = (void *) l->l_addr + ph->p_vaddr;
 210         break;
 211       case PT_INTERP:
 212         /* This "interpreter segment" was used by the program loader to
 213            find the program interpreter, which is this program itself, the
 214            dynamic linker.  We note what name finds us, so that a future
 215            dlopen call or DT_NEEDED entry, for something that wants to link
 216            against the dynamic linker as a shared library, will know that
 217            the shared object is already loaded.  */
 218         _dl_rtld_map.l_libname = (const char *) l->l_addr + ph->p_vaddr;
 219         break;
 220       }
 221   if (! _dl_rtld_map.l_libname && _dl_rtld_map.l_name)
 222     /* We were invoked directly, so the program might not have a PT_INTERP.  */
 223     _dl_rtld_map.l_libname = _dl_rtld_map.l_name;
 224   else
 225     assert (_dl_rtld_map.l_libname); /* How else did we get here?  */
 226
 227   /* Extract the contents of the dynamic section for easy access.  */
 228   elf_get_dynamic_info (l->l_ld, l->l_info);
 229   if (l->l_info[DT_HASH])
 230     /* Set up our cache of pointers into the hash table.  */
 231     _dl_setup_hash (l);
 232
 233   /* Put the link_map for ourselves on the chain so it can be found by
 234      name.  */
 235   if (! _dl_rtld_map.l_name)
 236     /* If not invoked directly, the dynamic linker shared object file was
 237        found by the PT_INTERP name.  */
 238     _dl_rtld_map.l_name = (char *) _dl_rtld_map.l_libname;
 239   _dl_rtld_map.l_type = lt_library;
 240   while (l->l_next)
 241     l = l->l_next;
 242   l->l_next = &_dl_rtld_map;
 243   _dl_rtld_map.l_prev = l;
 244
 245   /* Load all the libraries specified by DT_NEEDED entries.  */
 246   _dl_map_object_deps (l);
 247
 248   /* We are done mapping things, so close the zero-fill descriptor.  */
 249   __close (_dl_zerofd);
 250   _dl_zerofd = -1;
 251
 252   /* Remove _dl_rtld_map from the chain.  */
 253   _dl_rtld_map.l_prev->l_next = _dl_rtld_map.l_next;
 254   if (_dl_rtld_map.l_next)
 255     _dl_rtld_map.l_next->l_prev = _dl_rtld_map.l_prev;
 256
 257   if (_dl_rtld_map.l_opencount)
 258     {
 259       /* Some DT_NEEDED entry referred to the interpreter object itself, so
 260          put it back in the list of visible objects.  We insert it into the
 261          chain in symbol search order because gdb uses the chain's order as
 262          its symbol search order.  */
 263       unsigned int i = 1;
 264       while (l->l_searchlist[i] != &_dl_rtld_map)
 265         ++i;
 266       _dl_rtld_map.l_prev = l->l_searchlist[i - 1];
 267       _dl_rtld_map.l_next = (i + 1 < l->l_nsearchlist ?
 268                              l->l_searchlist[i + 1] : NULL);
 269       assert (_dl_rtld_map.l_prev->l_next == _dl_rtld_map.l_next);
 270       _dl_rtld_map.l_prev->l_next = &_dl_rtld_map;
 271       if (_dl_rtld_map.l_next)
 272         {
 273           assert (_dl_rtld_map.l_next->l_prev == _dl_rtld_map.l_prev);
 274           _dl_rtld_map.l_next->l_prev = &_dl_rtld_map;
 275         }
 276     }
 277
 278   if (list_only)
 279     {
 280       /* We were run just to list the shared libraries.  It is
 281          important that we do this before real relocation, because the
 282          functions we call below for output may no longer work properly
 283          after relocation.  */
 284
 285       int i;
 286
 287       if (! _dl_loaded->l_info[DT_NEEDED])
 288         _dl_sysdep_message ("\t", "statically linked\n", NULL);
 289       else
 290         for (l = _dl_loaded->l_next; l; l = l->l_next)
 291           {
 292             char buf[20], *bp;
 293             buf[sizeof buf - 1] = '\0';
 294             bp = _itoa (l->l_addr, &buf[sizeof buf - 1], 16, 0);
 295             while (&buf[sizeof buf - 1] - bp < sizeof l->l_addr * 2)
 296               *--bp = '0';
 297             _dl_sysdep_message ("\t", l->l_libname, " => ", l->l_name,
 298                                 " (0x", bp, ")\n", NULL);
 299           }
 300
 301       for (i = 1; i < _dl_argc; ++i)
 302         {
 303           const ElfW(Sym) *ref = NULL;
 304           ElfW(Addr) loadbase = _dl_lookup_symbol (_dl_argv[i], &ref,
 305                                                    &_dl_default_scope[2],
 306                                                    "argument", 0, 0);
 307           char buf[20], *bp;
 308           buf[sizeof buf - 1] = '\0';
 309           bp = _itoa (ref->st_value, &buf[sizeof buf - 1], 16, 0);
 310           while (&buf[sizeof buf - 1] - bp < sizeof loadbase * 2)
 311             *--bp = '0';
 312           _dl_sysdep_message (_dl_argv[i], " found at 0x", bp, NULL);
 313           buf[sizeof buf - 1] = '\0';
 314           bp = _itoa (loadbase, &buf[sizeof buf - 1], 16, 0);
 315           while (&buf[sizeof buf - 1] - bp < sizeof loadbase * 2)
 316             *--bp = '0';
 317           _dl_sysdep_message (" in object at 0x", bp, "\n", NULL);
 318         }
 319
 320       _exit (0);
 321     }
 322
 323   lazy = !_dl_secure && *(getenv ("LD_BIND_NOW") ?: "") == '\0';
 324
 325   {
 326     /* Now we have all the objects loaded.  Relocate them all except for
 327        the dynamic linker itself.  We do this in reverse order so that copy
 328        relocs of earlier objects overwrite the data written by later
 329        objects.  We do not re-relocate the dynamic linker itself in this
 330        loop because that could result in the GOT entries for functions we
 331        call being changed, and that would break us.  It is safe to relocate
 332        the dynamic linker out of order because it has no copy relocs (we
 333        know that because it is self-contained).  */
 334
 335     l = _dl_loaded;
 336     while (l->l_next)
 337       l = l->l_next;
 338     do
 339       {
 340         if (l != &_dl_rtld_map)
 341           {
 342             _dl_relocate_object (l, _dl_object_relocation_scope (l), lazy);
 343             *_dl_global_scope_end = NULL;
 344           }
 345         l = l->l_prev;
 346       } while (l);
 347
 348     /* Do any necessary cleanups for the startup OS interface code.
 349        We do these now so that no calls are made after rtld re-relocation
 350        which might be resolved to different functions than we expect.
 351        We cannot do this before relocating the other objects because
 352        _dl_relocate_object might need to call `mprotect' for DT_TEXTREL.  */
 353     _dl_sysdep_start_cleanup ();
 354
 355     if (_dl_rtld_map.l_opencount > 0)
 356       /* There was an explicit ref to the dynamic linker as a shared lib.
 357          Re-relocate ourselves with user-controlled symbol definitions.  */
 358       _dl_relocate_object (&_dl_rtld_map, &_dl_default_scope[2], 0);
 359   }
 360
 361   {
 362     /* Initialize _r_debug.  */
 363     struct r_debug *r = _dl_debug_initialize (_dl_rtld_map.l_addr);
 364
 365     l = _dl_loaded;
 366     if (l->l_info[DT_DEBUG])
 367       /* There is a DT_DEBUG entry in the dynamic section.  Fill it in
 368          with the run-time address of the r_debug structure  */
 369       l->l_info[DT_DEBUG]->d_un.d_ptr = (ElfW(Addr)) r;
 370
 371     /* Notify the debugger that all objects are now mapped in.  */
 372     r->r_state = RT_ADD;
 373     _dl_debug_state ();
 374   }
 375
 376   if (_dl_rtld_map.l_info[DT_INIT])
 377     {
 378       /* Call the initializer for the compatibility version of the
 379          dynamic linker.  There is no additional initialization
 380          required for the ABI-compliant dynamic linker.  */
 381
 382       (*(void (*) (void)) (_dl_rtld_map.l_addr +
 383                            _dl_rtld_map.l_info[DT_INIT]->d_un.d_ptr)) ();
 384
 385       /* Clear the field so a future dlopen won't run it again.  */
 386       _dl_rtld_map.l_info[DT_INIT] = NULL;
 387     }
 388
 389   /* Once we return, _dl_sysdep_start will invoke
 390      the DT_INIT functions and then *USER_ENTRY.  */
 391 }