libdwfl/offline.c

   1 /* Recover relocatibility for addresses computed from debug information.
   2    Copyright (C) 2005-2009, 2012 Red Hat, Inc.
   3    This file is part of elfutils.
   4
   5    This file is free software; you can redistribute it and/or modify
   6    it under the terms of either
   7
   8      * the GNU Lesser General Public License as published by the Free
   9        Software Foundation; either version 3 of the License, or (at
  10        your option) any later version
  11
  12    or
  13
  14      * the GNU General Public License as published by the Free
  15        Software Foundation; either version 2 of the License, or (at
  16        your option) any later version
  17
  18    or both in parallel, as here.
  19
  20    elfutils is distributed in the hope that it will be useful, but
  21    WITHOUT ANY WARRANTY; without even the implied warranty of
  22    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  23    General Public License for more details.
  24
  25    You should have received copies of the GNU General Public License and
  26    the GNU Lesser General Public License along with this program.  If
  27    not, see <http://www.gnu.org/licenses/>.  */
  28
  29 #include "libdwflP.h"
  30 #include <fcntl.h>
  31 #include <unistd.h>
  32
  33 /* Since dwfl_report_elf lays out the sections already, this will only be
  34    called when the section headers of the debuginfo file are being
  35    consulted instead, or for the section placed at 0.  With binutils
  36    strip-to-debug, the symbol table is in the debuginfo file and relocation
  37    looks there.  */
  38 int
  39 dwfl_offline_section_address (Dwfl_Module *mod,
  40                               void **userdata __attribute__ ((unused)),
  41                               const char *modname __attribute__ ((unused)),
  42                               Dwarf_Addr base __attribute__ ((unused)),
  43                               const char *secname __attribute__ ((unused)),
  44                               Elf32_Word shndx,
  45                               const GElf_Shdr *shdr __attribute__ ((unused)),
  46                               Dwarf_Addr *addr)
  47 {
  48   assert (mod->e_type == ET_REL);
  49   assert (shdr->sh_addr == 0);
  50   assert (shdr->sh_flags & SHF_ALLOC);
  51   assert (shndx != 0);
  52
  53   if (mod->debug.elf == NULL)
  54     /* We are only here because sh_addr is zero even though layout is complete.
  55        The first section in the first file under -e is placed at 0.  */
  56     return 0;
  57
  58   /* The section numbers might not match between the two files.
  59      The best we can rely on is the order of SHF_ALLOC sections.  */
  60
  61   Elf_Scn *ourscn = elf_getscn (mod->debug.elf, shndx);
  62   Elf_Scn *scn = NULL;
  63   uint_fast32_t skip_alloc = 0;
  64   while ((scn = elf_nextscn (mod->debug.elf, scn)) != ourscn)
  65     {
  66       assert (scn != NULL);
  67       GElf_Shdr shdr_mem;
  68       GElf_Shdr *sh = gelf_getshdr (scn, &shdr_mem);
  69       if (unlikely (sh == NULL))
  70         return -1;
  71       if (sh->sh_flags & SHF_ALLOC)
  72         ++skip_alloc;
  73     }
  74
  75   scn = NULL;
  76   while ((scn = elf_nextscn (mod->main.elf, scn)) != NULL)
  77     {
  78       GElf_Shdr shdr_mem;
  79       GElf_Shdr *main_shdr = gelf_getshdr (scn, &shdr_mem);
  80       if (unlikely (main_shdr == NULL))
  81         return -1;
  82       if ((main_shdr->sh_flags & SHF_ALLOC) && skip_alloc-- == 0)
  83         {
  84           assert (main_shdr->sh_flags == shdr->sh_flags);
  85           *addr = main_shdr->sh_addr;
  86           return 0;
  87         }
  88     }
  89
  90   /* This should never happen.  */
  91   return -1;
  92 }
  93 INTDEF (dwfl_offline_section_address)
  94
  95 /* Forward declarations.  */
  96 static Dwfl_Module *process_elf (Dwfl *dwfl, const char *name,
  97                                  const char *file_name, int fd, Elf *elf);
  98 static Dwfl_Module *process_archive (Dwfl *dwfl, const char *name,
  99                                      const char *file_name, int fd, Elf *elf,
 100                                      int (*predicate) (const char *module,
 101                                                        const char *file));
 102
 103 /* Report one module for an ELF file, or many for an archive.
 104    Always consumes ELF and FD.  */
 105 static Dwfl_Module *
 106 process_file (Dwfl *dwfl, const char *name, const char *file_name, int fd,
 107               Elf *elf, int (*predicate) (const char *module,
 108                                           const char *file))
 109 {
 110   switch (elf_kind (elf))
 111     {
 112     default:
 113     case ELF_K_NONE:
 114       __libdwfl_seterrno (elf == NULL ? DWFL_E_LIBELF : DWFL_E_BADELF);
 115       return NULL;
 116
 117     case ELF_K_ELF:
 118       return process_elf (dwfl, name, file_name, fd, elf);
 119
 120     case ELF_K_AR:
 121       return process_archive (dwfl, name, file_name, fd, elf, predicate);
 122     }
 123 }
 124
 125 /* Report the open ELF file as a module.  Always consumes ELF and FD.  */
 126 static Dwfl_Module *
 127 process_elf (Dwfl *dwfl, const char *name, const char *file_name, int fd,
 128              Elf *elf)
 129 {
 130   Dwfl_Module *mod = __libdwfl_report_elf (dwfl, name, file_name, fd, elf,
 131                                            dwfl->offline_next_address, true,
 132                                            false);
 133   if (mod != NULL)
 134     {
 135       /* If this is an ET_EXEC file with fixed addresses, the address range
 136          it consumed may or may not intersect with the arbitrary range we
 137          will use for relocatable modules.  Make sure we always use a free
 138          range for the offline allocations.  If this module did use
 139          offline_next_address, it may have rounded it up for the module's
 140          alignment requirements.  */
 141       if ((dwfl->offline_next_address >= mod->low_addr
 142            || mod->low_addr - dwfl->offline_next_address < OFFLINE_REDZONE)
 143           && dwfl->offline_next_address < mod->high_addr + OFFLINE_REDZONE)
 144         dwfl->offline_next_address = mod->high_addr + OFFLINE_REDZONE;
 145
 146       /* Don't keep the file descriptor around.  */
 147       if (mod->main.fd != -1 && elf_cntl (mod->main.elf, ELF_C_FDREAD) == 0)
 148         {
 149           close (mod->main.fd);
 150           mod->main.fd = -1;
 151         }
 152     }
 153
 154   return mod;
 155 }
 156
 157 /* Always consumes MEMBER.  Returns elf_next result on success.
 158    For errors returns ELF_C_NULL with *MOD set to null.  */
 159 static Elf_Cmd
 160 process_archive_member (Dwfl *dwfl, const char *name, const char *file_name,
 161                         int (*predicate) (const char *module, const char *file),
 162                         int fd, Elf *member, Dwfl_Module **mod)
 163 {
 164   const Elf_Arhdr *h = elf_getarhdr (member);
 165   if (unlikely (h == NULL))
 166     {
 167       __libdwfl_seterrno (DWFL_E_LIBELF);
 168     fail:
 169       elf_end (member);
 170       *mod = NULL;
 171       return ELF_C_NULL;
 172     }
 173
 174   if (!strcmp (h->ar_name, "/") || !strcmp (h->ar_name, "//")
 175       || !strcmp (h->ar_name, "/SYM64/"))
 176     {
 177     skip:;
 178       /* Skip this and go to the next.  */
 179       Elf_Cmd result = elf_next (member);
 180       elf_end (member);
 181       return result;
 182     }
 183
 184   char *member_name;
 185   if (unlikely (asprintf (&member_name, "%s(%s)", file_name, h->ar_name) < 0))
 186     {
 187     nomem:
 188       __libdwfl_seterrno (DWFL_E_NOMEM);
 189       elf_end (member);
 190       *mod = NULL;
 191       return ELF_C_NULL;
 192     }
 193
 194   char *module_name = NULL;
 195   if (name == NULL || name[0] == '\0')
 196     name = h->ar_name;
 197   else if (unlikely (asprintf (&module_name, "%s:%s", name, h->ar_name) < 0))
 198     {
 199       free (member_name);
 200       goto nomem;
 201     }
 202   else
 203     name = module_name;
 204
 205   if (predicate != NULL)
 206     {
 207       /* Let the predicate decide whether to use this one.  */
 208       int want = (*predicate) (name, member_name);
 209       if (want <= 0)
 210         {
 211           free (member_name);
 212           free (module_name);
 213           if (unlikely (want < 0))
 214             {
 215               __libdwfl_seterrno (DWFL_E_CB);
 216               goto fail;
 217             }
 218           goto skip;
 219         }
 220     }
 221
 222   /* We let __libdwfl_report_elf cache the fd in mod->main.fd,
 223      though it's the same fd for all the members.
 224      On module teardown we will close it only on the last Elf reference.  */
 225   *mod = process_file (dwfl, name, member_name, fd, member, predicate);
 226   free (member_name);
 227   free (module_name);
 228
 229   if (*mod == NULL)             /* process_file called elf_end.  */
 230     return ELF_C_NULL;
 231
 232   /* Advance the archive-reading offset for the next iteration.  */
 233   return elf_next (member);
 234 }
 235
 236 /* Report each member of the archive as its own module.  */
 237 static Dwfl_Module *
 238 process_archive (Dwfl *dwfl, const char *name, const char *file_name, int fd,
 239                  Elf *archive,
 240                  int (*predicate) (const char *module, const char *file))
 241
 242 {
 243   Dwfl_Module *mod = NULL;
 244   Elf *member = elf_begin (fd, ELF_C_READ_MMAP_PRIVATE, archive);
 245   if (unlikely (member == NULL)) /* Empty archive.  */
 246     {
 247       __libdwfl_seterrno (DWFL_E_BADELF);
 248       return NULL;
 249     }
 250
 251   while (process_archive_member (dwfl, name, file_name, predicate,
 252                                  fd, member, &mod) != ELF_C_NULL)
 253     member = elf_begin (fd, ELF_C_READ_MMAP_PRIVATE, archive);
 254
 255   /* We can drop the archive Elf handle even if we're still using members
 256      in live modules.  When the last module's elf_end on a member returns
 257      zero, that module will close FD.  If no modules survived the predicate,
 258      we are all done with the file right here.  */
 259   if (mod != NULL               /* If no modules, caller will clean up.  */
 260       && elf_end (archive) == 0)
 261     close (fd);
 262
 263   return mod;
 264 }
 265
 266 Dwfl_Module *
 267 internal_function
 268 __libdwfl_report_offline (Dwfl *dwfl, const char *name,
 269                           const char *file_name, int fd, bool closefd,
 270                           int (*predicate) (const char *module,
 271                                             const char *file))
 272 {
 273   Elf *elf;
 274   Dwfl_Error error = __libdw_open_file (&fd, &elf, closefd, true);
 275   if (error != DWFL_E_NOERROR)
 276     {
 277       __libdwfl_seterrno (error);
 278       return NULL;
 279     }
 280   Dwfl_Module *mod = process_file (dwfl, name, file_name, fd, elf, predicate);
 281   if (mod == NULL)
 282     {
 283       elf_end (elf);
 284       if (closefd)
 285         close (fd);
 286     }
 287   return mod;
 288 }
 289
 290 Dwfl_Module *
 291 dwfl_report_offline (Dwfl *dwfl, const char *name,
 292                      const char *file_name, int fd)
 293 {
 294   if (dwfl == NULL)
 295     return NULL;
 296
 297   bool closefd = false;
 298   if (fd < 0)
 299     {
 300       closefd = true;
 301       fd = open (file_name, O_RDONLY);
 302       if (fd < 0)
 303         {
 304           __libdwfl_seterrno (DWFL_E_ERRNO);
 305           return NULL;
 306         }
 307     }
 308
 309   return __libdwfl_report_offline (dwfl, name, file_name, fd, closefd, NULL);
 310 }
 311 INTDEF (dwfl_report_offline)