LCOV - code coverage report
Current view: top level - elfutils/libdwfl - core-file.c (source / functions) Hit Total Coverage
Test: lcov.out Lines: 106 161 65.8 %
Date: 2013-03-08 Functions: 7 8 87.5 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 72 157 45.9 %

           Branch data     Line data    Source code
       1                 :            : /* Core file handling.
       2                 :            :    Copyright (C) 2008-2010 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 <config.h>
      30                 :            : #include "../libelf/libelfP.h"        /* For NOTE_ALIGN.  */
      31                 :            : #undef  _
      32                 :            : #include "libdwflP.h"
      33                 :            : #include <gelf.h>
      34                 :            : 
      35                 :            : #include <sys/param.h>
      36                 :            : #include <unistd.h>
      37                 :            : #include <endian.h>
      38                 :            : #include <byteswap.h>
      39                 :            : #include "system.h"
      40                 :            : 
      41                 :            : 
      42                 :            : /* This is a prototype of what a new libelf interface might be.
      43                 :            :    This implementation is pessimal for non-mmap cases and should
      44                 :            :    be replaced by more diddling inside libelf internals.  */
      45                 :            : static Elf *
      46                 :          7 : elf_begin_rand (Elf *parent, loff_t offset, loff_t size, loff_t *next)
      47                 :            : {
      48         [ +  - ]:          7 :   if (parent == NULL)
      49                 :            :     return NULL;
      50                 :            : 
      51                 :            :   /* On failure return, we update *NEXT to point back at OFFSET.  */
      52                 :          0 :   inline Elf *fail (int error)
      53                 :            :   {
      54         [ #  # ]:          0 :     if (next != NULL)
      55                 :          0 :       *next = offset;
      56                 :            :     //__libelf_seterrno (error);
      57                 :          0 :     __libdwfl_seterrno (DWFL_E (LIBELF, error));
      58                 :          0 :     return NULL;
      59                 :            :   }
      60                 :            : 
      61 [ +  - ][ +  + ]:          7 :   loff_t min = (parent->kind == ELF_K_ELF ?
                 [ #  # ]
      62                 :          7 :                 (parent->class == ELFCLASS32
      63                 :            :                  ? sizeof (Elf32_Ehdr) : sizeof (Elf64_Ehdr))
      64                 :            :                 : parent->kind == ELF_K_AR ? SARMAG
      65                 :            :                 : 0);
      66                 :            : 
      67         [ +  - ]:          7 :   if (unlikely (offset < min)
      68         [ -  + ]:          7 :       || unlikely (offset >= (loff_t) parent->maximum_size))
      69                 :          0 :     return fail (ELF_E_RANGE);
      70                 :            : 
      71                 :            :   /* For an archive, fetch just the size field
      72                 :            :      from the archive header to override SIZE.  */
      73         [ -  + ]:          7 :   if (parent->kind == ELF_K_AR)
      74                 :            :     {
      75                 :          0 :       struct ar_hdr h = { .ar_size = "" };
      76                 :            : 
      77         [ #  # ]:          0 :       if (unlikely (parent->maximum_size - offset < sizeof h))
      78                 :          0 :         return fail (ELF_E_RANGE);
      79                 :            : 
      80         [ #  # ]:          0 :       if (parent->map_address != NULL)
      81                 :          0 :         memcpy (h.ar_size, parent->map_address + parent->start_offset + offset,
      82                 :            :                 sizeof h.ar_size);
      83         [ #  # ]:          0 :       else if (unlikely (pread_retry (parent->fildes,
      84                 :            :                                       h.ar_size, sizeof (h.ar_size),
      85                 :            :                                       parent->start_offset + offset
      86                 :            :                                       + offsetof (struct ar_hdr, ar_size))
      87                 :            :                          != sizeof (h.ar_size)))
      88                 :          0 :         return fail (ELF_E_READ_ERROR);
      89                 :            : 
      90                 :          0 :       offset += sizeof h;
      91                 :            : 
      92                 :            :       char *endp;
      93                 :          0 :       size = strtoll (h.ar_size, &endp, 10);
      94         [ #  # ]:          0 :       if (unlikely (endp == h.ar_size)
      95         [ #  # ]:          0 :           || unlikely ((loff_t) parent->maximum_size - offset < size))
      96                 :          0 :         return fail (ELF_E_INVALID_ARCHIVE);
      97                 :            :     }
      98                 :            : 
      99         [ -  + ]:          7 :   if (unlikely ((loff_t) parent->maximum_size - offset < size))
     100                 :          0 :     return fail (ELF_E_RANGE);
     101                 :            : 
     102                 :            :   /* Even if we fail at this point, update *NEXT to point past the file.  */
     103         [ -  + ]:          7 :   if (next != NULL)
     104                 :          0 :     *next = offset + size;
     105                 :            : 
     106         [ -  + ]:          7 :   if (unlikely (offset == 0)
     107         [ #  # ]:          0 :       && unlikely (size == (loff_t) parent->maximum_size))
     108                 :          0 :     return elf_clone (parent, parent->cmd);
     109                 :            : 
     110                 :            :   /* Note the image is guaranteed live only as long as PARENT
     111                 :            :      lives.  Using elf_memory is quite suboptimal if the whole
     112                 :            :      file is not mmap'd.  We really should have something like
     113                 :            :      a generalization of the archive support.  */
     114                 :          7 :   Elf_Data *data = elf_getdata_rawchunk (parent, offset, size, ELF_T_BYTE);
     115         [ +  - ]:          7 :   if (data == NULL)
     116                 :            :     return NULL;
     117         [ -  + ]:          7 :   assert ((loff_t) data->d_size == size);
     118                 :          7 :   return elf_memory (data->d_buf, size);
     119                 :            : }
     120                 :            : 
     121                 :            : 
     122                 :            : int
     123                 :          6 : dwfl_report_core_segments (Dwfl *dwfl, Elf *elf, size_t phnum, GElf_Phdr *notes)
     124                 :            : {
     125         [ +  - ]:          6 :   if (unlikely (dwfl == NULL))
     126                 :            :     return -1;
     127                 :            : 
     128                 :          6 :   int result = 0;
     129                 :            : 
     130         [ +  - ]:          6 :   if (notes != NULL)
     131                 :          6 :     notes->p_type = PT_NULL;
     132                 :            : 
     133         [ +  + ]:        104 :   for (size_t ndx = 0; result >= 0 && ndx < phnum; ++ndx)
     134                 :            :     {
     135                 :            :       GElf_Phdr phdr_mem;
     136                 :         98 :       GElf_Phdr *phdr = gelf_getphdr (elf, ndx, &phdr_mem);
     137         [ -  + ]:         98 :       if (unlikely (phdr == NULL))
     138                 :            :         {
     139                 :          0 :           __libdwfl_seterrno (DWFL_E_LIBELF);
     140                 :            :           return -1;
     141                 :            :         }
     142      [ +  +  - ]:         98 :       switch (phdr->p_type)
     143                 :            :         {
     144                 :            :         case PT_LOAD:
     145                 :         92 :           result = dwfl_report_segment (dwfl, ndx, phdr, 0, NULL);
     146                 :         92 :           break;
     147                 :            : 
     148                 :            :         case PT_NOTE:
     149         [ +  - ]:          6 :           if (notes != NULL)
     150                 :            :             {
     151                 :          6 :               *notes = *phdr;
     152                 :          6 :               notes = NULL;
     153                 :            :             }
     154                 :            :           break;
     155                 :            :         }
     156                 :            :     }
     157                 :            : 
     158                 :            :   return result;
     159                 :            : }
     160                 :            : 
     161                 :            : /* Never read more than this much without mmap.  */
     162                 :            : #define MAX_EAGER_COST  8192
     163                 :            : 
     164                 :            : static bool
     165                 :         18 : core_file_read_eagerly (Dwfl_Module *mod,
     166                 :            :                         void **userdata __attribute__ ((unused)),
     167                 :            :                         const char *name __attribute__ ((unused)),
     168                 :            :                         Dwarf_Addr start __attribute__ ((unused)),
     169                 :            :                         void **buffer, size_t *buffer_available,
     170                 :            :                         GElf_Off cost, GElf_Off worthwhile,
     171                 :            :                         GElf_Off whole,
     172                 :            :                         GElf_Off contiguous __attribute__ ((unused)),
     173                 :            :                         void *arg, Elf **elfp)
     174                 :            : {
     175                 :         18 :   Elf *core = arg;
     176                 :            : 
     177         [ +  + ]:         18 :   if (whole <= *buffer_available)
     178                 :            :     {
     179                 :            :       /* All there ever was, we already have on hand.  */
     180                 :            : 
     181         [ -  + ]:          7 :       if (core->map_address == NULL)
     182                 :            :         {
     183                 :            :           /* We already malloc'd the buffer.  */
     184                 :          0 :           *elfp = elf_memory (*buffer, whole);
     185         [ #  # ]:          0 :           if (unlikely (*elfp == NULL))
     186                 :            :             return false;
     187                 :            : 
     188                 :          0 :           (*elfp)->flags |= ELF_F_MALLOCED;
     189                 :          0 :           *buffer = NULL;
     190                 :          0 :           *buffer_available = 0;
     191                 :          0 :           return true;
     192                 :            :         }
     193                 :            : 
     194                 :            :       /* We can use the image inside the core file directly.  */
     195                 :          7 :       *elfp = elf_begin_rand (core, *buffer - core->map_address, whole, NULL);
     196                 :          7 :       *buffer = NULL;
     197                 :          7 :       *buffer_available = 0;
     198                 :          7 :       return *elfp != NULL;
     199                 :            :     }
     200                 :            : 
     201                 :            :   /* We don't have the whole file.
     202                 :            :      Figure out if this is better than nothing.  */
     203                 :            : 
     204         [ +  + ]:         11 :   if (worthwhile == 0)
     205                 :            :     /* Caller doesn't think so.  */
     206                 :            :     return false;
     207                 :            : 
     208                 :            :   /*
     209                 :            :     XXX would like to fall back to partial file via memory
     210                 :            :     when build id find_elf fails
     211                 :            :     also, link_map name may give file name from disk better than partial here
     212                 :            :     requires find_elf hook re-doing the magic to fall back if no file found
     213                 :            :   */
     214                 :            : 
     215         [ -  + ]:         10 :   if (mod->build_id_len > 0)
     216                 :            :     /* There is a build ID that could help us find the whole file,
     217                 :            :        which might be more useful than what we have.
     218                 :            :        We'll just rely on that.  */
     219                 :            :     return false;
     220                 :            : 
     221         [ #  # ]:          0 :   if (core->map_address != NULL)
     222                 :            :     /* It's cheap to get, so get it.  */
     223                 :            :     return true;
     224                 :            : 
     225                 :            :   /* Only use it if there isn't too much to be read.  */
     226                 :         18 :   return cost <= MAX_EAGER_COST;
     227                 :            : }
     228                 :            : 
     229                 :            : bool
     230                 :        232 : dwfl_elf_phdr_memory_callback (Dwfl *dwfl, int ndx,
     231                 :            :                                void **buffer, size_t *buffer_available,
     232                 :            :                                GElf_Addr vaddr,
     233                 :            :                                size_t minread,
     234                 :            :                                void *arg)
     235                 :            : {
     236                 :        232 :   Elf *elf = arg;
     237                 :            : 
     238         [ +  + ]:        232 :   if (ndx == -1)
     239                 :            :     {
     240                 :            :       /* Called for cleanup.  */
     241         [ -  + ]:        106 :       if (elf->map_address == NULL)
     242                 :          0 :         free (*buffer);
     243                 :        106 :       *buffer = NULL;
     244                 :        106 :       *buffer_available = 0;
     245                 :            :       return false;
     246                 :            :     }
     247                 :            : 
     248         [ +  - ]:        132 :   const GElf_Off align = dwfl->segment_align ?: 1;
     249                 :            :   GElf_Phdr phdr;
     250                 :            : 
     251                 :            :   do
     252         [ +  - ]:        132 :     if (unlikely (gelf_getphdr (elf, ndx++, &phdr) == NULL))
     253                 :            :       return false;
     254                 :        132 :   while (phdr.p_type != PT_LOAD
     255 [ +  + ][ -  + ]:        132 :          || ((phdr.p_vaddr + phdr.p_memsz + align - 1) & -align) <= vaddr);
     256                 :            : 
     257                 :        126 :   GElf_Off start = vaddr - phdr.p_vaddr + phdr.p_offset;
     258                 :            :   GElf_Off end;
     259                 :            :   GElf_Addr end_vaddr;
     260                 :            : 
     261                 :        224 :   inline void update_end ()
     262                 :            :   {
     263                 :        224 :     end = (phdr.p_offset + phdr.p_filesz + align - 1) & -align;
     264                 :        224 :     end_vaddr = (phdr.p_vaddr + phdr.p_memsz + align - 1) & -align;
     265                 :        224 :   }
     266                 :            : 
     267                 :        126 :   update_end ();
     268                 :            : 
     269                 :            :   /* Use following contiguous segments to get towards SIZE.  */
     270                 :        354 :   inline bool more (size_t size)
     271                 :            :   {
     272 [ +  + ][ +  + ]:        926 :     while (end <= start || end - start < size)
     273                 :            :       {
     274         [ +  + ]:        218 :         if (phdr.p_filesz < phdr.p_memsz)
     275                 :            :           /* This segment is truncated, so no following one helps us.  */
     276                 :            :           return false;
     277                 :            : 
     278         [ +  - ]:        170 :         if (unlikely (gelf_getphdr (elf, ndx++, &phdr) == NULL))
     279                 :            :           return false;
     280                 :            : 
     281         [ +  - ]:        170 :         if (phdr.p_type == PT_LOAD)
     282                 :            :           {
     283         [ +  - ]:        170 :             if (phdr.p_offset > end
     284         [ +  + ]:        170 :                 || phdr.p_vaddr > end_vaddr)
     285                 :            :               /* It's discontiguous!  */
     286                 :            :               return false;
     287                 :            : 
     288                 :        452 :             update_end ();
     289                 :            :           }
     290                 :            :       }
     291                 :            :     return true;
     292                 :            :   }
     293                 :            : 
     294                 :            :   /* We need at least this much.  */
     295         [ +  + ]:        126 :   if (! more (minread))
     296                 :            :     return false;
     297                 :            : 
     298                 :            :   /* See how much more we can get of what the caller wants.  */
     299                 :        114 :   (void) more (*buffer_available);
     300                 :            : 
     301                 :            :   /* If it's already on hand anyway, use as much as there is.  */
     302         [ +  - ]:        114 :   if (elf->map_address != NULL)
     303                 :        114 :     (void) more (elf->maximum_size - start);
     304                 :            : 
     305                 :            :   /* Make sure we don't look past the end of the actual file,
     306                 :            :      even if the headers tell us to.  */
     307         [ -  + ]:        114 :   if (unlikely (end > elf->maximum_size))
     308                 :          0 :     end = elf->maximum_size;
     309                 :            : 
     310                 :            :   /* If the file is too small, there is nothing at all to get.  */
     311         [ +  - ]:        114 :   if (unlikely (start >= end))
     312                 :            :     return false;
     313                 :            : 
     314         [ +  - ]:        114 :   if (elf->map_address != NULL)
     315                 :            :     {
     316                 :        114 :       void *contents = elf->map_address + elf->start_offset + start;
     317                 :        114 :       size_t size = end - start;
     318                 :            : 
     319         [ +  + ]:        114 :       if (minread == 0)         /* String mode.  */
     320                 :            :         {
     321                 :          9 :           const void *eos = memchr (contents, '\0', size);
     322 [ +  + ][ +  - ]:          9 :           if (unlikely (eos == NULL) || unlikely (eos == contents))
     323                 :            :             return false;
     324                 :          8 :           size = eos + 1 - contents;
     325                 :            :         }
     326                 :            : 
     327         [ +  - ]:        113 :       if (*buffer == NULL)
     328                 :            :         {
     329                 :        113 :           *buffer = contents;
     330                 :        113 :           *buffer_available = size;
     331                 :            :         }
     332                 :            :       else
     333                 :            :         {
     334                 :          0 :           *buffer_available = MIN (size, *buffer_available);
     335                 :          0 :           memcpy (*buffer, contents, *buffer_available);
     336                 :            :         }
     337                 :            :     }
     338                 :            :   else
     339                 :            :     {
     340                 :          0 :       void *into = *buffer;
     341         [ #  # ]:          0 :       if (*buffer == NULL)
     342                 :            :         {
     343 [ #  # ][ #  # ]:          0 :           *buffer_available = MIN (minread ?: 512,
                 [ #  # ]
     344                 :            :                                    MAX (4096, MIN (end - start,
     345                 :            :                                                    *buffer_available)));
     346                 :          0 :           into = malloc (*buffer_available);
     347         [ #  # ]:          0 :           if (unlikely (into == NULL))
     348                 :            :             {
     349                 :          0 :               __libdwfl_seterrno (DWFL_E_NOMEM);
     350                 :            :               return false;
     351                 :            :             }
     352                 :            :         }
     353                 :            : 
     354                 :          0 :       ssize_t nread = pread_retry (elf->fildes, into, *buffer_available, start);
     355         [ #  # ]:          0 :       if (nread < (ssize_t) minread)
     356                 :            :         {
     357         [ #  # ]:          0 :           if (into != *buffer)
     358                 :          0 :             free (into);
     359         [ #  # ]:          0 :           if (nread < 0)
     360                 :          0 :             __libdwfl_seterrno (DWFL_E_ERRNO);
     361                 :            :           return false;
     362                 :            :         }
     363                 :            : 
     364         [ #  # ]:          0 :       if (minread == 0)         /* String mode.  */
     365                 :            :         {
     366                 :          0 :           const void *eos = memchr (into, '\0', nread);
     367 [ #  # ][ #  # ]:          0 :           if (unlikely (eos == NULL) || unlikely (eos == into))
     368                 :            :             {
     369         [ #  # ]:          0 :               if (*buffer == NULL)
     370                 :          0 :                 free (into);
     371                 :            :               return false;
     372                 :            :             }
     373                 :          0 :           nread = eos + 1 - into;
     374                 :            :         }
     375                 :            : 
     376         [ #  # ]:          0 :       if (*buffer == NULL)
     377                 :          0 :         *buffer = into;
     378                 :        232 :       *buffer_available = nread;
     379                 :            :     }
     380                 :            : 
     381                 :            :   return true;
     382                 :            : }
     383                 :            : 
     384                 :            : int
     385                 :          6 : dwfl_core_file_report (Dwfl *dwfl, Elf *elf)
     386                 :            : {
     387                 :            :   size_t phnum;
     388         [ -  + ]:          6 :   if (unlikely (elf_getphdrnum (elf, &phnum) != 0))
     389                 :            :     {
     390                 :          0 :       __libdwfl_seterrno (DWFL_E_LIBELF);
     391                 :            :       return -1;
     392                 :            :     }
     393                 :            : 
     394                 :            :   /* First report each PT_LOAD segment.  */
     395                 :            :   GElf_Phdr notes_phdr;
     396                 :          6 :   int ndx = dwfl_report_core_segments (dwfl, elf, phnum, &notes_phdr);
     397         [ +  - ]:          6 :   if (unlikely (ndx <= 0))
     398                 :            :     return ndx;
     399                 :            : 
     400                 :            :   /* Now sniff segment contents for modules.  */
     401                 :            :   int sniffed = 0;
     402                 :            :   ndx = 0;
     403                 :            :   do
     404                 :            :     {
     405                 :         68 :       int seg = dwfl_segment_report_module (dwfl, ndx, NULL,
     406                 :            :                                             &dwfl_elf_phdr_memory_callback, elf,
     407                 :            :                                             core_file_read_eagerly, elf);
     408         [ +  - ]:         68 :       if (unlikely (seg < 0))
     409                 :            :         return seg;
     410         [ +  + ]:         68 :       if (seg > ndx)
     411                 :            :         {
     412                 :         18 :           ndx = seg;
     413                 :         18 :           ++sniffed;
     414                 :            :         }
     415                 :            :       else
     416                 :         50 :         ++ndx;
     417                 :            :     }
     418         [ +  + ]:         68 :   while (ndx < (int) phnum);
     419                 :            : 
     420                 :            :   /* Next, we should follow the chain from DT_DEBUG.  */
     421                 :            : 
     422                 :          6 :   const void *auxv = NULL;
     423                 :          6 :   size_t auxv_size = 0;
     424         [ +  - ]:          6 :   if (likely (notes_phdr.p_type == PT_NOTE))
     425                 :            :     {
     426                 :            :       /* PT_NOTE -> NT_AUXV -> AT_PHDR -> PT_DYNAMIC -> DT_DEBUG */
     427                 :            : 
     428                 :          6 :       Elf_Data *notes = elf_getdata_rawchunk (elf,
     429                 :          6 :                                               notes_phdr.p_offset,
     430                 :            :                                               notes_phdr.p_filesz,
     431                 :            :                                               ELF_T_NHDR);
     432         [ +  - ]:          6 :       if (likely (notes != NULL))
     433                 :            :         {
     434                 :            :           size_t pos = 0;
     435                 :            :           GElf_Nhdr nhdr;
     436                 :            :           size_t name_pos;
     437                 :            :           size_t desc_pos;
     438         [ +  - ]:         24 :           while ((pos = gelf_getnote (notes, pos, &nhdr,
     439                 :            :                                       &name_pos, &desc_pos)) > 0)
     440         [ +  + ]:         18 :             if (nhdr.n_type == NT_AUXV
     441         [ +  - ]:          6 :                 && nhdr.n_namesz == sizeof "CORE"
     442         [ +  - ]:          6 :                 && !memcmp (notes->d_buf + name_pos, "CORE", sizeof "CORE"))
     443                 :            :               {
     444                 :          6 :                 auxv = notes->d_buf + desc_pos;
     445                 :          6 :                 auxv_size = nhdr.n_descsz;
     446                 :         18 :                 break;
     447                 :            :               }
     448                 :            :         }
     449                 :            :     }
     450                 :            : 
     451                 :            :   /* Now we have NT_AUXV contents.  From here on this processing could be
     452                 :            :      used for a live process with auxv read from /proc.  */
     453                 :            : 
     454                 :          6 :   int listed = dwfl_link_map_report (dwfl, auxv, auxv_size,
     455                 :            :                                      dwfl_elf_phdr_memory_callback, elf);
     456                 :            : 
     457                 :            :   /* We return the number of modules we found if we found any.
     458                 :            :      If we found none, we return -1 instead of 0 if there was an
     459                 :            :      error rather than just nothing found.  If link_map handling
     460                 :            :      failed, we still have the sniffed modules.  */
     461         [ +  - ]:          6 :   return sniffed == 0 || listed > sniffed ? listed : sniffed;
     462                 :            : }
     463                 :            : INTDEF (dwfl_core_file_report)

Generated by: LCOV version 1.9