bfd/elfcore.h

   1 /* ELF core file support for BFD.
   2    Copyright 1995, 1996, 1997, 1998, 2000, 2001, 2002, 2003, 2005, 2007,
   3    2008, 2010 Free Software Foundation, Inc.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 char*
  23 elf_core_file_failing_command (bfd *abfd)
  24 {
  25   return elf_tdata (abfd)->core_command;
  26 }
  27
  28 int
  29 elf_core_file_failing_signal (bfd *abfd)
  30 {
  31   return elf_tdata (abfd)->core_signal;
  32 }
  33
  34 bfd_boolean
  35 elf_core_file_matches_executable_p (bfd *core_bfd, bfd *exec_bfd)
  36 {
  37   char* corename;
  38
  39   /* xvecs must match if both are ELF files for the same target.  */
  40
  41   if (core_bfd->xvec != exec_bfd->xvec)
  42     {
  43       bfd_set_error (bfd_error_system_call);
  44       return FALSE;
  45     }
  46
  47   /* See if the name in the corefile matches the executable name.  */
  48   corename = elf_tdata (core_bfd)->core_program;
  49   if (corename != NULL)
  50     {
  51       const char* execname = strrchr (exec_bfd->filename, '/');
  52
  53       execname = execname ? execname + 1 : exec_bfd->filename;
  54
  55       if (strcmp (execname, corename) != 0)
  56         return FALSE;
  57     }
  58
  59   return TRUE;
  60 }
  61
  62 /*  Core files are simply standard ELF formatted files that partition
  63     the file using the execution view of the file (program header table)
  64     rather than the linking view.  In fact, there is no section header
  65     table in a core file.
  66
  67     The process status information (including the contents of the general
  68     register set) and the floating point register set are stored in a
  69     segment of type PT_NOTE.  We handcraft a couple of extra bfd sections
  70     that allow standard bfd access to the general registers (.reg) and the
  71     floating point registers (.reg2).  */
  72
  73 const bfd_target *
  74 elf_core_file_p (bfd *abfd)
  75 {
  76   Elf_External_Ehdr x_ehdr;     /* Elf file header, external form.  */
  77   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form.  */
  78   Elf_Internal_Phdr *i_phdrp;   /* Elf program header, internal form.  */
  79   unsigned int phindex;
  80   const struct elf_backend_data *ebd;
  81   struct bfd_preserve preserve;
  82   bfd_size_type amt;
  83
  84   preserve.marker = NULL;
  85
  86   /* Read in the ELF header in external format.  */
  87   if (bfd_bread (&x_ehdr, sizeof (x_ehdr), abfd) != sizeof (x_ehdr))
  88     {
  89       if (bfd_get_error () != bfd_error_system_call)
  90         goto wrong;
  91       else
  92         goto fail;
  93     }
  94
  95   /* Check the magic number.  */
  96   if (! elf_file_p (&x_ehdr))
  97     goto wrong;
  98
  99   /* FIXME: Check EI_VERSION here !  */
 100
 101   /* Check the address size ("class").  */
 102   if (x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
 103     goto wrong;
 104
 105   /* Check the byteorder.  */
 106   switch (x_ehdr.e_ident[EI_DATA])
 107     {
 108     case ELFDATA2MSB:           /* Big-endian.  */
 109       if (! bfd_big_endian (abfd))
 110         goto wrong;
 111       break;
 112     case ELFDATA2LSB:           /* Little-endian.  */
 113       if (! bfd_little_endian (abfd))
 114         goto wrong;
 115       break;
 116     default:
 117       goto wrong;
 118     }
 119
 120   if (!bfd_preserve_save (abfd, &preserve))
 121     goto fail;
 122
 123   /* Give abfd an elf_obj_tdata.  */
 124   if (! (*abfd->xvec->_bfd_set_format[bfd_core]) (abfd))
 125     goto fail;
 126   preserve.marker = elf_tdata (abfd);
 127
 128   /* Swap in the rest of the header, now that we have the byte order.  */
 129   i_ehdrp = elf_elfheader (abfd);
 130   elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
 131
 132 #if DEBUG & 1
 133   elf_debug_file (i_ehdrp);
 134 #endif
 135
 136   ebd = get_elf_backend_data (abfd);
 137
 138   /* Check that the ELF e_machine field matches what this particular
 139      BFD format expects.  */
 140
 141   if (ebd->elf_machine_code != i_ehdrp->e_machine
 142       && (ebd->elf_machine_alt1 == 0
 143           || i_ehdrp->e_machine != ebd->elf_machine_alt1)
 144       && (ebd->elf_machine_alt2 == 0
 145           || i_ehdrp->e_machine != ebd->elf_machine_alt2))
 146     {
 147       const bfd_target * const *target_ptr;
 148
 149       if (ebd->elf_machine_code != EM_NONE)
 150         goto wrong;
 151
 152       /* This is the generic ELF target.  Let it match any ELF target
 153          for which we do not have a specific backend.  */
 154
 155       for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++)
 156         {
 157           const struct elf_backend_data *back;
 158
 159           if ((*target_ptr)->flavour != bfd_target_elf_flavour)
 160             continue;
 161           back = xvec_get_elf_backend_data (*target_ptr);
 162           if (back->s->arch_size != ARCH_SIZE)
 163             continue;
 164           if (back->elf_machine_code == i_ehdrp->e_machine
 165               || (back->elf_machine_alt1 != 0
 166                   && i_ehdrp->e_machine == back->elf_machine_alt1)
 167               || (back->elf_machine_alt2 != 0
 168                   && i_ehdrp->e_machine == back->elf_machine_alt2))
 169             {
 170               /* target_ptr is an ELF backend which matches this
 171                  object file, so reject the generic ELF target.  */
 172               goto wrong;
 173             }
 174         }
 175     }
 176
 177   /* If there is no program header, or the type is not a core file, then
 178      we are hosed.  */
 179   if (i_ehdrp->e_phoff == 0 || i_ehdrp->e_type != ET_CORE)
 180     goto wrong;
 181
 182   /* Does BFD's idea of the phdr size match the size
 183      recorded in the file? */
 184   if (i_ehdrp->e_phentsize != sizeof (Elf_External_Phdr))
 185     goto wrong;
 186
 187   /* If the program header count is PN_XNUM(0xffff), the actual
 188      count is in the first section header.  */
 189   if (i_ehdrp->e_shoff != 0 && i_ehdrp->e_phnum == PN_XNUM)
 190     {
 191       Elf_External_Shdr x_shdr;
 192       Elf_Internal_Shdr i_shdr;
 193       bfd_signed_vma where = i_ehdrp->e_shoff;
 194
 195       if (where != (file_ptr) where)
 196         goto wrong;
 197
 198       /* Seek to the section header table in the file.  */
 199       if (bfd_seek (abfd, (file_ptr) where, SEEK_SET) != 0)
 200         goto fail;
 201
 202       /* Read the first section header at index 0, and convert to internal
 203          form.  */
 204       if (bfd_bread (&x_shdr, sizeof (x_shdr), abfd) != sizeof (x_shdr))
 205         goto fail;
 206       elf_swap_shdr_in (abfd, &x_shdr, &i_shdr);
 207
 208       if (i_shdr.sh_info != 0)
 209         {
 210           i_ehdrp->e_phnum = i_shdr.sh_info;
 211           if (i_ehdrp->e_phnum != i_shdr.sh_info)
 212             goto wrong;
 213         }
 214     }
 215
 216   /* Sanity check that we can read all of the program headers.
 217      It ought to be good enough to just read the last one.  */
 218   if (i_ehdrp->e_phnum > 1)
 219     {
 220       Elf_External_Phdr x_phdr;
 221       Elf_Internal_Phdr i_phdr;
 222       bfd_signed_vma where;
 223
 224       /* Check that we don't have a totally silly number of
 225          program headers.  */
 226       if (i_ehdrp->e_phnum > (unsigned int) -1 / sizeof (x_phdr)
 227           || i_ehdrp->e_phnum > (unsigned int) -1 / sizeof (i_phdr))
 228         goto wrong;
 229
 230       where = i_ehdrp->e_phoff + (i_ehdrp->e_phnum - 1) * sizeof (x_phdr);
 231       if (where != (file_ptr) where)
 232         goto wrong;
 233       if ((bfd_size_type) where <= i_ehdrp->e_phoff)
 234         goto wrong;
 235
 236       if (bfd_seek (abfd, (file_ptr) where, SEEK_SET) != 0)
 237         goto fail;
 238       if (bfd_bread (&x_phdr, sizeof (x_phdr), abfd) != sizeof (x_phdr))
 239         goto fail;
 240     }
 241
 242   /* Move to the start of the program headers.  */
 243   if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_phoff, SEEK_SET) != 0)
 244     goto wrong;
 245
 246   /* Allocate space for the program headers.  */
 247   amt = sizeof (*i_phdrp) * i_ehdrp->e_phnum;
 248   i_phdrp = (Elf_Internal_Phdr *) bfd_alloc (abfd, amt);
 249   if (!i_phdrp)
 250     goto fail;
 251
 252   elf_tdata (abfd)->phdr = i_phdrp;
 253
 254   /* Read and convert to internal form.  */
 255   for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
 256     {
 257       Elf_External_Phdr x_phdr;
 258
 259       if (bfd_bread (&x_phdr, sizeof (x_phdr), abfd) != sizeof (x_phdr))
 260         goto fail;
 261
 262       elf_swap_phdr_in (abfd, &x_phdr, i_phdrp + phindex);
 263     }
 264
 265   /* Set the machine architecture.  Do this before processing the
 266      program headers since we need to know the architecture type
 267      when processing the notes of some systems' core files.  */
 268   if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0)
 269       /* It's OK if this fails for the generic target.  */
 270       && ebd->elf_machine_code != EM_NONE)
 271     goto fail;
 272
 273   /* Let the backend double check the format and override global
 274      information.  We do this before processing the program headers
 275      to allow the correct machine (as opposed to just the default
 276      machine) to be set, making it possible for grok_prstatus and
 277      grok_psinfo to rely on the mach setting.  */
 278   if (ebd->elf_backend_object_p != NULL
 279       && ! ebd->elf_backend_object_p (abfd))
 280     goto wrong;
 281
 282   /* Process each program header.  */
 283   for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
 284     if (! bfd_section_from_phdr (abfd, i_phdrp + phindex, (int) phindex))
 285       goto fail;
 286
 287   /* Check for core truncation.  */
 288   {
 289     bfd_size_type high = 0;
 290     struct stat statbuf;
 291     for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
 292       {
 293         Elf_Internal_Phdr *p = i_phdrp + phindex;
 294         if (p->p_filesz)
 295           {
 296             bfd_size_type current = p->p_offset + p->p_filesz;
 297             if (high < current)
 298               high = current;
 299           }
 300       }
 301     if (bfd_stat (abfd, &statbuf) == 0)
 302       {
 303         if ((bfd_size_type) statbuf.st_size < high)
 304           {
 305             (*_bfd_error_handler)
 306               (_("Warning: %B is truncated: expected core file "
 307                  "size >= %lu, found: %lu."),
 308                abfd, (unsigned long) high, (unsigned long) statbuf.st_size);
 309           }
 310       }
 311   }
 312
 313   /* Save the entry point from the ELF header.  */
 314   bfd_get_start_address (abfd) = i_ehdrp->e_entry;
 315
 316   bfd_preserve_finish (abfd, &preserve);
 317   return abfd->xvec;
 318
 319 wrong:
 320   /* There is way too much undoing of half-known state here.  The caller,
 321      bfd_check_format_matches, really shouldn't iterate on live bfd's to
 322      check match/no-match like it does.  We have to rely on that a call to
 323      bfd_default_set_arch_mach with the previously known mach, undoes what
 324      was done by the first bfd_default_set_arch_mach (with mach 0) here.
 325      For this to work, only elf-data and the mach may be changed by the
 326      target-specific elf_backend_object_p function.  Note that saving the
 327      whole bfd here and restoring it would be even worse; the first thing
 328      you notice is that the cached bfd file position gets out of sync.  */
 329   bfd_set_error (bfd_error_wrong_format);
 330
 331 fail:
 332   if (preserve.marker != NULL)
 333     bfd_preserve_restore (abfd, &preserve);
 334   return NULL;
 335 }