LCOV - code coverage report
Current view: top level - libdwfl - core-file.c (source / functions) Hit Total Coverage
Test: elfutils-0.189 Lines: 179 267 67.0 %
Date: 2023-04-14 15:57:06 Functions: 9 9 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 105 215 48.8 %

           Branch data     Line data    Source code
       1                 :            : /* Core file handling.
       2                 :            :    Copyright (C) 2008-2010, 2013, 2015 Red Hat, Inc.
       3                 :            :    Copyright (C) 2021 Mark J. Wielaard <mark@klomp.org>
       4                 :            :    This file is part of elfutils.
       5                 :            : 
       6                 :            :    This file is free software; you can redistribute it and/or modify
       7                 :            :    it under the terms of either
       8                 :            : 
       9                 :            :      * the GNU Lesser General Public License as published by the Free
      10                 :            :        Software Foundation; either version 3 of the License, or (at
      11                 :            :        your option) any later version
      12                 :            : 
      13                 :            :    or
      14                 :            : 
      15                 :            :      * the GNU General Public License as published by the Free
      16                 :            :        Software Foundation; either version 2 of the License, or (at
      17                 :            :        your option) any later version
      18                 :            : 
      19                 :            :    or both in parallel, as here.
      20                 :            : 
      21                 :            :    elfutils is distributed in the hope that it will be useful, but
      22                 :            :    WITHOUT ANY WARRANTY; without even the implied warranty of
      23                 :            :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      24                 :            :    General Public License for more details.
      25                 :            : 
      26                 :            :    You should have received copies of the GNU General Public License and
      27                 :            :    the GNU Lesser General Public License along with this program.  If
      28                 :            :    not, see <http://www.gnu.org/licenses/>.  */
      29                 :            : 
      30                 :            : #include <config.h>
      31                 :            : #include "libelfP.h"  /* For NOTE_ALIGN.  */
      32                 :            : #include "libdwflP.h"
      33                 :            : #include <gelf.h>
      34                 :            : 
      35                 :            : /* On failure return, we update *NEXT to point back at OFFSET.  */
      36                 :            : static inline Elf *
      37                 :          0 : do_fail (int error, off_t *next, off_t offset)
      38                 :            : {
      39                 :          0 :     if (next != NULL)
      40                 :          0 :       *next = offset;
      41                 :            :     //__libelf_seterrno (error);
      42                 :          0 :     __libdwfl_seterrno (DWFL_E (LIBELF, error));
      43                 :          0 :     return NULL;
      44                 :            : }
      45                 :            : 
      46                 :            : #define fail(error) do_fail (error, next, offset)
      47                 :            : 
      48                 :            : /* This is a prototype of what a new libelf interface might be.
      49                 :            :    This implementation is pessimal for non-mmap cases and should
      50                 :            :    be replaced by more diddling inside libelf internals.  */
      51                 :            : static Elf *
      52                 :         34 : elf_begin_rand (Elf *parent, off_t offset, off_t size, off_t *next)
      53                 :            : {
      54         [ +  - ]:         34 :   if (parent == NULL)
      55                 :            :     return NULL;
      56                 :            : 
      57                 :         68 :   off_t min = (parent->kind == ELF_K_ELF ?
      58                 :         34 :                 (parent->class == ELFCLASS32
      59                 :            :                  ? sizeof (Elf32_Ehdr) : sizeof (Elf64_Ehdr))
      60   [ +  -  +  +  :         34 :                 : parent->kind == ELF_K_AR ? SARMAG
                   -  - ]
      61                 :            :                 : 0);
      62                 :            : 
      63         [ +  - ]:         34 :   if (unlikely (offset < min)
      64         [ -  + ]:         34 :       || unlikely (offset >= (off_t) parent->maximum_size))
      65         [ #  # ]:          0 :     return fail (ELF_E_RANGE);
      66                 :            : 
      67                 :            :   /* For an archive, fetch just the size field
      68                 :            :      from the archive header to override SIZE.  */
      69         [ -  + ]:         34 :   if (parent->kind == ELF_K_AR)
      70                 :            :     {
      71                 :            :       /* File size, in ASCII decimal, right-padded with ASCII spaces.
      72                 :            :          Max 10 characters. Not zero terminated. So make this ar_size
      73                 :            :          array one larger and explicitly zero terminate it.  As needed
      74                 :            :          for strtoll.  */
      75                 :            :       #define AR_SIZE_CHARS 10
      76                 :          0 :       char ar_size[AR_SIZE_CHARS + 1];
      77                 :          0 :       ar_size[AR_SIZE_CHARS] = '\0';
      78                 :            : 
      79         [ #  # ]:          0 :       if (unlikely (parent->maximum_size - offset < sizeof (struct ar_hdr)))
      80         [ #  # ]:          0 :         return fail (ELF_E_RANGE);
      81                 :            : 
      82         [ #  # ]:          0 :       if (parent->map_address != NULL)
      83                 :          0 :         memcpy (ar_size, parent->map_address + parent->start_offset + offset,
      84                 :            :                 AR_SIZE_CHARS);
      85         [ #  # ]:          0 :       else if (unlikely (pread_retry (parent->fildes,
      86                 :            :                                       ar_size, AR_SIZE_CHARS,
      87                 :            :                                       parent->start_offset + offset
      88                 :            :                                       + offsetof (struct ar_hdr, ar_size))
      89                 :            :                          != AR_SIZE_CHARS))
      90         [ #  # ]:          0 :         return fail (ELF_E_READ_ERROR);
      91                 :            : 
      92                 :          0 :       offset += sizeof (struct ar_hdr);
      93                 :            : 
      94                 :          0 :       char *endp;
      95                 :          0 :       size = strtoll (ar_size, &endp, 10);
      96         [ #  # ]:          0 :       if (unlikely (endp == ar_size)
      97         [ #  # ]:          0 :           || unlikely ((off_t) parent->maximum_size - offset < size))
      98         [ #  # ]:          0 :         return fail (ELF_E_INVALID_ARCHIVE);
      99                 :            :     }
     100                 :            : 
     101         [ -  + ]:         34 :   if (unlikely ((off_t) parent->maximum_size - offset < size))
     102         [ #  # ]:          0 :     return fail (ELF_E_RANGE);
     103                 :            : 
     104                 :            :   /* Even if we fail at this point, update *NEXT to point past the file.  */
     105         [ -  + ]:         34 :   if (next != NULL)
     106                 :          0 :     *next = offset + size;
     107                 :            : 
     108         [ -  + ]:         34 :   if (unlikely (offset == 0)
     109         [ #  # ]:          0 :       && unlikely (size == (off_t) parent->maximum_size))
     110                 :          0 :     return elf_clone (parent, parent->cmd);
     111                 :            : 
     112                 :            :   /* Note the image is guaranteed live only as long as PARENT
     113                 :            :      lives.  Using elf_memory is quite suboptimal if the whole
     114                 :            :      file is not mmap'd.  We really should have something like
     115                 :            :      a generalization of the archive support.  */
     116                 :         34 :   Elf_Data *data = elf_getdata_rawchunk (parent, offset, size, ELF_T_BYTE);
     117         [ +  - ]:         34 :   if (data == NULL)
     118                 :            :     return NULL;
     119         [ -  + ]:         34 :   assert ((off_t) data->d_size == size);
     120                 :         34 :   return elf_memory (data->d_buf, size);
     121                 :            : }
     122                 :            : 
     123                 :            : 
     124                 :            : int
     125                 :         34 : dwfl_report_core_segments (Dwfl *dwfl, Elf *elf, size_t phnum, GElf_Phdr *notes)
     126                 :            : {
     127         [ +  - ]:         34 :   if (unlikely (dwfl == NULL))
     128                 :            :     return -1;
     129                 :            : 
     130                 :         34 :   int result = 0;
     131                 :            : 
     132         [ +  - ]:         34 :   if (notes != NULL)
     133                 :         34 :     notes->p_type = PT_NULL;
     134                 :            : 
     135         [ +  + ]:        691 :   for (size_t ndx = 0; result >= 0 && ndx < phnum; ++ndx)
     136                 :            :     {
     137                 :        657 :       GElf_Phdr phdr_mem;
     138                 :        657 :       GElf_Phdr *phdr = gelf_getphdr (elf, ndx, &phdr_mem);
     139         [ -  + ]:        657 :       if (unlikely (phdr == NULL))
     140                 :            :         {
     141                 :          0 :           __libdwfl_seterrno (DWFL_E_LIBELF);
     142                 :          0 :           return -1;
     143                 :            :         }
     144      [ +  +  - ]:        657 :       switch (phdr->p_type)
     145                 :            :         {
     146                 :        623 :         case PT_LOAD:
     147                 :        623 :           result = dwfl_report_segment (dwfl, ndx, phdr, 0, NULL);
     148                 :        623 :           break;
     149                 :            : 
     150                 :         34 :         case PT_NOTE:
     151         [ +  - ]:         34 :           if (notes != NULL)
     152                 :            :             {
     153                 :         34 :               *notes = *phdr;
     154                 :         34 :               notes = NULL;
     155                 :            :             }
     156                 :            :           break;
     157                 :            :         }
     158                 :        657 :     }
     159                 :            : 
     160                 :            :   return result;
     161                 :            : }
     162                 :            : 
     163                 :            : /* Never read more than this much without mmap.  */
     164                 :            : #define MAX_EAGER_COST  8192
     165                 :            : 
     166                 :            : /* Dwfl_Module_Callback passed to and called by dwfl_segment_report_module
     167                 :            :    to read in a segment as ELF image directly if possible or indicate an
     168                 :            :    attempt must be made to read in the while segment right now.  */
     169                 :            : static bool
     170                 :        115 : core_file_read_eagerly (Dwfl_Module *mod,
     171                 :            :                         void **userdata __attribute__ ((unused)),
     172                 :            :                         const char *name __attribute__ ((unused)),
     173                 :            :                         Dwarf_Addr start __attribute__ ((unused)),
     174                 :            :                         void **buffer, size_t *buffer_available,
     175                 :            :                         GElf_Off cost, GElf_Off worthwhile,
     176                 :            :                         GElf_Off whole,
     177                 :            :                         GElf_Off contiguous __attribute__ ((unused)),
     178                 :            :                         void *arg, Elf **elfp)
     179                 :            : {
     180                 :        115 :   Elf *core = arg;
     181                 :            : 
     182                 :            :   /* The available buffer is often the whole segment when the core file
     183                 :            :      was mmap'd if used together with the dwfl_elf_phdr_memory_callback.
     184                 :            :      Which means that if it is complete we can just construct the whole
     185                 :            :      ELF image right now without having to read in anything more.  */
     186         [ +  + ]:        115 :   if (whole <= *buffer_available)
     187                 :            :     {
     188                 :            :       /* All there ever was, we already have on hand.  */
     189                 :            : 
     190         [ -  + ]:         34 :       if (core->map_address == NULL)
     191                 :            :         {
     192                 :            :           /* We already malloc'd the buffer.  */
     193                 :          0 :           *elfp = elf_memory (*buffer, whole);
     194         [ #  # ]:          0 :           if (unlikely (*elfp == NULL))
     195                 :            :             return false;
     196                 :            : 
     197                 :          0 :           (*elfp)->flags |= ELF_F_MALLOCED;
     198                 :          0 :           *buffer = NULL;
     199                 :          0 :           *buffer_available = 0;
     200                 :          0 :           return true;
     201                 :            :         }
     202                 :            : 
     203                 :            :       /* We can use the image inside the core file directly.  */
     204                 :         34 :       *elfp = elf_begin_rand (core, *buffer - core->map_address, whole, NULL);
     205                 :         34 :       *buffer = NULL;
     206                 :         34 :       *buffer_available = 0;
     207                 :         34 :       return *elfp != NULL;
     208                 :            :     }
     209                 :            : 
     210                 :            :   /* We don't have the whole file.  Which either means the core file
     211                 :            :      wasn't mmap'd, but needs to still be read in, or that the segment
     212                 :            :      is truncated.  Figure out if this is better than nothing.  */
     213                 :            : 
     214         [ +  + ]:         81 :   if (worthwhile == 0)
     215                 :            :     /* Caller doesn't think so.  */
     216                 :            :     return false;
     217                 :            : 
     218                 :            :   /*
     219                 :            :     XXX would like to fall back to partial file via memory
     220                 :            :     when build id find_elf fails
     221                 :            :     also, link_map name may give file name from disk better than partial here
     222                 :            :     requires find_elf hook re-doing the magic to fall back if no file found
     223                 :            :   */
     224                 :            : 
     225   [ +  +  -  + ]:         69 :   if (whole > MAX_EAGER_COST && mod->build_id_len > 0)
     226                 :            :     /* We can't cheaply read the whole file here, so we'd
     227                 :            :        be using a partial file.  But there is a build ID that could
     228                 :            :        help us find the whole file, which might be more useful than
     229                 :            :        what we have.  We'll just rely on that.  */
     230                 :            :     return false;
     231                 :            : 
     232                 :            :   /* The file is either small (most likely the vdso) or big and incomplete,
     233                 :            :      but we don't have a build-id.  */
     234                 :            : 
     235         [ -  + ]:          3 :   if (core->map_address != NULL)
     236                 :            :     /* It's cheap to get, so get it.  */
     237                 :            :     return true;
     238                 :            : 
     239                 :            :   /* Only use it if there isn't too much to be read.  */
     240                 :          0 :   return cost <= MAX_EAGER_COST;
     241                 :            : }
     242                 :            : 
     243                 :            : static inline void
     244                 :       1103 : update_end (GElf_Phdr *pphdr, const GElf_Off align,
     245                 :            :             GElf_Off *pend, GElf_Addr *pend_vaddr)
     246                 :            : {
     247                 :       1103 :   *pend = (pphdr->p_offset + pphdr->p_filesz + align - 1) & -align;
     248                 :       1103 :   *pend_vaddr = (pphdr->p_vaddr + pphdr->p_memsz + align - 1) & -align;
     249                 :       1103 : }
     250                 :            : 
     251                 :            : /* Use following contiguous segments to get towards SIZE.  */
     252                 :            : static inline bool
     253                 :       2149 : do_more (size_t size, GElf_Phdr *pphdr, const GElf_Off align,
     254                 :            :          Elf *elf, GElf_Off start, int *pndx,
     255                 :            :          GElf_Off *pend, GElf_Addr *pend_vaddr)
     256                 :            : {
     257   [ +  +  +  + ]:       4644 :   while (*pend <= start || *pend - start < size)
     258                 :            :     {
     259         [ +  + ]:       1066 :       if (pphdr->p_filesz < pphdr->p_memsz)
     260                 :            :         /* This segment is truncated, so no following one helps us.  */
     261                 :            :         return false;
     262                 :            : 
     263         [ +  - ]:        883 :       if (unlikely (gelf_getphdr (elf, (*pndx)++, pphdr) == NULL))
     264                 :            :         return false;
     265                 :            : 
     266         [ +  - ]:        883 :       if (pphdr->p_type == PT_LOAD)
     267                 :            :         {
     268         [ +  - ]:        883 :           if (pphdr->p_offset > *pend
     269         [ +  + ]:        883 :               || pphdr->p_vaddr > *pend_vaddr)
     270                 :            :             /* It's discontiguous!  */
     271                 :            :             return false;
     272                 :            : 
     273                 :        346 :           update_end (pphdr, align, pend, pend_vaddr);
     274                 :            :         }
     275                 :            :     }
     276                 :            :   return true;
     277                 :            : }
     278                 :            : 
     279                 :            : #define more(size) do_more (size, &phdr, align, elf, start, &ndx, &end, &end_vaddr)
     280                 :            : 
     281                 :            : bool
     282                 :       1415 : dwfl_elf_phdr_memory_callback (Dwfl *dwfl, int ndx,
     283                 :            :                                void **buffer, size_t *buffer_available,
     284                 :            :                                GElf_Addr vaddr,
     285                 :            :                                size_t minread,
     286                 :            :                                void *arg)
     287                 :            : {
     288                 :       1415 :   Elf *elf = arg;
     289                 :            : 
     290         [ +  + ]:       1415 :   if (ndx == -1)
     291                 :            :     {
     292                 :            :       /* Called for cleanup.  */
     293         [ -  + ]:        658 :       if (elf->map_address == NULL)
     294                 :          0 :         free (*buffer);
     295                 :        658 :       *buffer = NULL;
     296                 :        658 :       *buffer_available = 0;
     297                 :        658 :       return false;
     298                 :            :     }
     299                 :            : 
     300                 :        757 :   const GElf_Off align = dwfl->segment_align ?: 1;
     301                 :        791 :   GElf_Phdr phdr;
     302                 :            : 
     303                 :        791 :   do
     304         [ +  - ]:        791 :     if (unlikely (gelf_getphdr (elf, ndx++, &phdr) == NULL))
     305                 :            :       return false;
     306                 :        791 :   while (phdr.p_type != PT_LOAD
     307   [ +  +  -  + ]:        791 :          || ((phdr.p_vaddr + phdr.p_memsz + align - 1) & -align) <= vaddr);
     308                 :            : 
     309                 :        757 :   GElf_Off start = vaddr - phdr.p_vaddr + phdr.p_offset;
     310                 :        757 :   GElf_Off end;
     311                 :        757 :   GElf_Addr end_vaddr;
     312                 :            : 
     313                 :        757 :   update_end (&phdr, align, &end, &end_vaddr);
     314                 :            : 
     315                 :            :   /* We need at least this much.  */
     316         [ +  + ]:        757 :   if (! more (minread))
     317                 :            :     return false;
     318                 :            : 
     319                 :            :   /* See how much more we can get of what the caller wants.  */
     320                 :        696 :   (void) more (*buffer_available);
     321                 :            : 
     322                 :            :   /* If it's already on hand anyway, use as much as there is.  */
     323   [ +  -  +  - ]:        696 :   if (elf->map_address != NULL && start < elf->maximum_size)
     324                 :        696 :     (void) more (elf->maximum_size - start);
     325                 :            : 
     326                 :            :   /* Make sure we don't look past the end of the actual file,
     327                 :            :      even if the headers tell us to.  */
     328         [ -  + ]:        696 :   if (unlikely (end > elf->maximum_size))
     329                 :          0 :     end = elf->maximum_size;
     330                 :            : 
     331                 :            :   /* If the file is too small, there is nothing at all to get.  */
     332         [ +  - ]:        696 :   if (unlikely (start >= end))
     333                 :            :     return false;
     334                 :            : 
     335         [ +  - ]:        696 :   if (end - start < minread)
     336                 :            :     return false;
     337                 :            : 
     338         [ +  - ]:        696 :   if (elf->map_address != NULL)
     339                 :            :     {
     340                 :        696 :       void *contents = elf->map_address + elf->start_offset + start;
     341                 :        696 :       size_t size = end - start;
     342                 :            : 
     343         [ +  + ]:        696 :       if (minread == 0)         /* String mode.  */
     344                 :            :         {
     345                 :         67 :           const void *eos = memchr (contents, '\0', size);
     346   [ +  -  +  - ]:         67 :           if (unlikely (eos == NULL) || unlikely (eos == contents))
     347                 :            :             return false;
     348                 :         67 :           size = eos + 1 - contents;
     349                 :            :         }
     350                 :            : 
     351         [ +  + ]:        696 :       if (*buffer == NULL)
     352                 :            :         {
     353                 :        692 :           *buffer = contents;
     354                 :        692 :           *buffer_available = size;
     355                 :            :         }
     356                 :            :       else
     357                 :            :         {
     358                 :          4 :           *buffer_available = MIN (size, *buffer_available);
     359                 :          4 :           memcpy (*buffer, contents, *buffer_available);
     360                 :            :         }
     361                 :            :     }
     362                 :            :   else
     363                 :            :     {
     364                 :          0 :       void *into = *buffer;
     365         [ #  # ]:          0 :       if (*buffer == NULL)
     366                 :            :         {
     367         [ #  # ]:          0 :           *buffer_available = MIN (minread ?: 512,
     368                 :            :                                    MAX (4096, MIN (end - start,
     369                 :            :                                                    *buffer_available)));
     370                 :          0 :           into = malloc (*buffer_available);
     371         [ #  # ]:          0 :           if (unlikely (into == NULL))
     372                 :            :             {
     373                 :          0 :               __libdwfl_seterrno (DWFL_E_NOMEM);
     374                 :          0 :               return false;
     375                 :            :             }
     376                 :            :         }
     377                 :            : 
     378                 :          0 :       ssize_t nread = pread_retry (elf->fildes, into, *buffer_available, start);
     379         [ #  # ]:          0 :       if (nread < (ssize_t) minread)
     380                 :            :         {
     381         [ #  # ]:          0 :           if (into != *buffer)
     382                 :          0 :             free (into);
     383         [ #  # ]:          0 :           if (nread < 0)
     384                 :          0 :             __libdwfl_seterrno (DWFL_E_ERRNO);
     385                 :          0 :           return false;
     386                 :            :         }
     387                 :            : 
     388         [ #  # ]:          0 :       if (minread == 0)         /* String mode.  */
     389                 :            :         {
     390                 :          0 :           const void *eos = memchr (into, '\0', nread);
     391   [ #  #  #  # ]:          0 :           if (unlikely (eos == NULL) || unlikely (eos == into))
     392                 :            :             {
     393         [ #  # ]:          0 :               if (*buffer == NULL)
     394                 :          0 :                 free (into);
     395                 :          0 :               return false;
     396                 :            :             }
     397                 :          0 :           nread = eos + 1 - into;
     398                 :            :         }
     399                 :            : 
     400         [ #  # ]:          0 :       if (*buffer == NULL)
     401                 :          0 :         *buffer = into;
     402                 :          0 :       *buffer_available = nread;
     403                 :            :     }
     404                 :            : 
     405                 :            :   return true;
     406                 :            : }
     407                 :            : 
     408                 :            : /* Free the contents of R_DEBUG_INFO without the R_DEBUG_INFO memory itself.  */
     409                 :            : 
     410                 :            : static void
     411                 :         34 : clear_r_debug_info (struct r_debug_info *r_debug_info)
     412                 :            : {
     413         [ +  + ]:        142 :   while (r_debug_info->module != NULL)
     414                 :            :     {
     415                 :        108 :       struct r_debug_info_module *module = r_debug_info->module;
     416                 :        108 :       r_debug_info->module = module->next;
     417                 :        108 :       elf_end (module->elf);
     418         [ -  + ]:        108 :       if (module->fd != -1)
     419                 :          0 :         close (module->fd);
     420                 :        108 :       free (module);
     421                 :            :     }
     422                 :         34 : }
     423                 :            : 
     424                 :            : bool
     425                 :            : internal_function
     426                 :         48 : __libdwfl_dynamic_vaddr_get (Elf *elf, GElf_Addr *vaddrp)
     427                 :            : {
     428                 :         48 :   size_t phnum;
     429         [ +  - ]:         48 :   if (unlikely (elf_getphdrnum (elf, &phnum) != 0))
     430                 :            :     return false;
     431         [ +  - ]:        232 :   for (size_t i = 0; i < phnum; ++i)
     432                 :            :     {
     433                 :        232 :       GElf_Phdr phdr_mem;
     434                 :        232 :       GElf_Phdr *phdr = gelf_getphdr (elf, i, &phdr_mem);
     435         [ +  - ]:        232 :       if (unlikely (phdr == NULL))
     436                 :         48 :         return false;
     437         [ +  + ]:        232 :       if (phdr->p_type == PT_DYNAMIC)
     438                 :            :         {
     439                 :         48 :           *vaddrp = phdr->p_vaddr;
     440                 :         48 :           return true;
     441                 :            :         }
     442                 :            :     }
     443                 :            :   return false;
     444                 :            : }
     445                 :            : 
     446                 :            : NEW_VERSION (dwfl_core_file_report, ELFUTILS_0.158)
     447                 :            : int
     448                 :         34 : dwfl_core_file_report (Dwfl *dwfl, Elf *elf, const char *executable)
     449                 :            : {
     450                 :         34 :   size_t phnum;
     451         [ -  + ]:         34 :   if (unlikely (elf_getphdrnum (elf, &phnum) != 0))
     452                 :            :     {
     453                 :          0 :       __libdwfl_seterrno (DWFL_E_LIBELF);
     454                 :          0 :       return -1;
     455                 :            :     }
     456                 :            : 
     457                 :         34 :   bool cleanup_user_core = false;
     458         [ -  + ]:         34 :   if (dwfl->user_core != NULL)
     459                 :          0 :     free (dwfl->user_core->executable_for_core);
     460         [ +  + ]:         34 :   if (executable == NULL)
     461                 :            :     {
     462         [ -  + ]:          4 :       if (dwfl->user_core != NULL)
     463                 :          0 :         dwfl->user_core->executable_for_core = NULL;
     464                 :            :     }
     465                 :            :   else
     466                 :            :     {
     467         [ +  - ]:         30 :       if (dwfl->user_core == NULL)
     468                 :            :         {
     469                 :         30 :           cleanup_user_core = true;
     470                 :         30 :           dwfl->user_core = calloc (1, sizeof (struct Dwfl_User_Core));
     471         [ -  + ]:         30 :           if (dwfl->user_core == NULL)
     472                 :            :             {
     473                 :          0 :               __libdwfl_seterrno (DWFL_E_NOMEM);
     474                 :          0 :               return -1;
     475                 :            :             }
     476                 :         30 :           dwfl->user_core->fd = -1;
     477                 :            :         }
     478                 :         30 :       dwfl->user_core->executable_for_core = strdup (executable);
     479         [ -  + ]:         30 :       if (dwfl->user_core->executable_for_core == NULL)
     480                 :            :         {
     481         [ #  # ]:          0 :           if (cleanup_user_core)
     482                 :            :             {
     483                 :          0 :               free (dwfl->user_core);
     484                 :          0 :               dwfl->user_core = NULL;
     485                 :            :             }
     486                 :          0 :           __libdwfl_seterrno (DWFL_E_NOMEM);
     487                 :          0 :           return -1;
     488                 :            :         }
     489                 :            :     }
     490                 :            : 
     491                 :            :   /* First report each PT_LOAD segment.  */
     492                 :         34 :   GElf_Phdr notes_phdr;
     493                 :         34 :   int ndx = dwfl_report_core_segments (dwfl, elf, phnum, &notes_phdr);
     494         [ -  + ]:         34 :   if (unlikely (ndx <= 0))
     495                 :            :     {
     496         [ #  # ]:          0 :       if (cleanup_user_core)
     497                 :            :         {
     498                 :          0 :           free (dwfl->user_core->executable_for_core);
     499                 :          0 :           free (dwfl->user_core);
     500                 :          0 :           dwfl->user_core = NULL;
     501                 :            :         }
     502                 :          0 :       return ndx;
     503                 :            :     }
     504                 :            : 
     505                 :            :   /* Next, we should follow the chain from DT_DEBUG.  */
     506                 :            : 
     507                 :         34 :   const void *auxv = NULL;
     508                 :         34 :   const void *note_file = NULL;
     509                 :         34 :   size_t auxv_size = 0;
     510                 :         34 :   size_t note_file_size = 0;
     511         [ +  - ]:         34 :   if (likely (notes_phdr.p_type == PT_NOTE))
     512                 :            :     {
     513                 :            :       /* PT_NOTE -> NT_AUXV -> AT_PHDR -> PT_DYNAMIC -> DT_DEBUG */
     514                 :            : 
     515                 :        102 :       Elf_Data *notes = elf_getdata_rawchunk (elf,
     516                 :         34 :                                               notes_phdr.p_offset,
     517                 :            :                                               notes_phdr.p_filesz,
     518         [ +  - ]:         34 :                                               (notes_phdr.p_align == 8
     519                 :            :                                                ? ELF_T_NHDR8
     520                 :            :                                                : ELF_T_NHDR));
     521         [ +  - ]:         34 :       if (likely (notes != NULL))
     522                 :            :         {
     523                 :            :           size_t pos = 0;
     524                 :            :           GElf_Nhdr nhdr;
     525                 :            :           size_t name_pos;
     526                 :            :           size_t desc_pos;
     527         [ +  + ]:        263 :           while ((pos = gelf_getnote (notes, pos, &nhdr,
     528                 :            :                                       &name_pos, &desc_pos)) > 0)
     529         [ +  + ]:        229 :             if (nhdr.n_namesz == sizeof "CORE"
     530         [ +  - ]:        188 :                 && !memcmp (notes->d_buf + name_pos, "CORE", sizeof "CORE"))
     531                 :            :               {
     532         [ +  + ]:        188 :                 if (nhdr.n_type == NT_AUXV)
     533                 :            :                   {
     534                 :         34 :                     auxv = notes->d_buf + desc_pos;
     535                 :         34 :                     auxv_size = nhdr.n_descsz;
     536                 :            :                   }
     537         [ +  + ]:        188 :                 if (nhdr.n_type == NT_FILE)
     538                 :            :                   {
     539                 :         22 :                     note_file = notes->d_buf + desc_pos;
     540                 :         22 :                     note_file_size = nhdr.n_descsz;
     541                 :            :                   }
     542                 :            :               }
     543                 :            :         }
     544                 :            :     }
     545                 :            : 
     546                 :            :   /* Now we have NT_AUXV contents.  From here on this processing could be
     547                 :            :      used for a live process with auxv read from /proc.  */
     548                 :            : 
     549                 :         34 :   struct r_debug_info r_debug_info;
     550                 :         34 :   memset (&r_debug_info, 0, sizeof r_debug_info);
     551                 :         34 :   int retval = dwfl_link_map_report (dwfl, auxv, auxv_size,
     552                 :            :                                      dwfl_elf_phdr_memory_callback, elf,
     553                 :            :                                      &r_debug_info);
     554                 :         34 :   int listed = retval > 0 ? retval : 0;
     555                 :            : 
     556                 :            :   /* Now sniff segment contents for modules hinted by information gathered
     557                 :            :      from DT_DEBUG.  */
     558                 :            : 
     559                 :         34 :   ndx = 0;
     560                 :        395 :   do
     561                 :            :     {
     562                 :        395 :       int seg = dwfl_segment_report_module (dwfl, ndx, NULL,
     563                 :            :                                             &dwfl_elf_phdr_memory_callback, elf,
     564                 :            :                                             core_file_read_eagerly, elf,
     565                 :            :                                             elf->maximum_size,
     566                 :            :                                             note_file, note_file_size,
     567                 :            :                                             &r_debug_info);
     568         [ -  + ]:        395 :       if (unlikely (seg < 0))
     569                 :            :         {
     570                 :          0 :           clear_r_debug_info (&r_debug_info);
     571                 :          0 :           return seg;
     572                 :            :         }
     573         [ +  + ]:        395 :       if (seg > ndx)
     574                 :            :         {
     575                 :        116 :           ndx = seg;
     576                 :        116 :           ++listed;
     577                 :            :         }
     578                 :            :       else
     579                 :        279 :         ++ndx;
     580                 :            :     }
     581         [ +  + ]:        395 :   while (ndx < (int) phnum);
     582                 :            : 
     583                 :            :   /* Now report the modules from dwfl_link_map_report which were not filtered
     584                 :            :      out by dwfl_segment_report_module.  */
     585                 :            : 
     586                 :         34 :   Dwfl_Module **lastmodp = &dwfl->modulelist;
     587         [ +  + ]:        150 :   while (*lastmodp != NULL)
     588                 :        116 :     lastmodp = &(*lastmodp)->next;
     589                 :         34 :   for (struct r_debug_info_module *module = r_debug_info.module;
     590         [ +  + ]:        142 :        module != NULL; module = module->next)
     591                 :            :     {
     592         [ +  + ]:        108 :       if (module->elf == NULL)
     593                 :         90 :         continue;
     594                 :         18 :       GElf_Addr file_dynamic_vaddr;
     595         [ -  + ]:         18 :       if (! __libdwfl_dynamic_vaddr_get (module->elf, &file_dynamic_vaddr))
     596                 :          0 :         continue;
     597                 :         18 :       Dwfl_Module *mod;
     598                 :         18 :       mod = __libdwfl_report_elf (dwfl, basename (module->name), module->name,
     599                 :            :                                   module->fd, module->elf,
     600                 :         18 :                                   module->l_ld - file_dynamic_vaddr,
     601                 :            :                                   true, true);
     602         [ -  + ]:         18 :       if (mod == NULL)
     603                 :          0 :         continue;
     604                 :         18 :       ++listed;
     605                 :         18 :       module->elf = NULL;
     606                 :         18 :       module->fd = -1;
     607                 :            :       /* Move this module to the end of the list, so that we end
     608                 :            :          up with a list in the same order as the link_map chain.  */
     609         [ -  + ]:         18 :       if (mod->next != NULL)
     610                 :            :         {
     611         [ #  # ]:          0 :           if (*lastmodp != mod)
     612                 :            :             {
     613                 :            :               lastmodp = &dwfl->modulelist;
     614         [ #  # ]:          0 :               while (*lastmodp != mod)
     615                 :          0 :                 lastmodp = &(*lastmodp)->next;
     616                 :            :             }
     617                 :          0 :           *lastmodp = mod->next;
     618                 :          0 :           mod->next = NULL;
     619         [ #  # ]:          0 :           while (*lastmodp != NULL)
     620                 :          0 :             lastmodp = &(*lastmodp)->next;
     621                 :          0 :           *lastmodp = mod;
     622                 :            :         }
     623                 :         18 :       lastmodp = &mod->next;
     624                 :            :     }
     625                 :            : 
     626                 :         34 :   clear_r_debug_info (&r_debug_info);
     627                 :            : 
     628                 :            :   /* We return the number of modules we found if we found any.
     629                 :            :      If we found none, we return -1 instead of 0 if there was an
     630                 :            :      error rather than just nothing found.  */
     631         [ +  - ]:         34 :   return listed > 0 ? listed : retval;
     632                 :            : }
     633                 :            : NEW_INTDEF (dwfl_core_file_report)
     634                 :            : 
     635                 :            : #ifdef SYMBOL_VERSIONING
     636                 :            : int _compat_without_executable_dwfl_core_file_report (Dwfl *dwfl, Elf *elf);
     637                 :            : COMPAT_VERSION_NEWPROTO (dwfl_core_file_report, ELFUTILS_0.146,
     638                 :            :                          without_executable)
     639                 :            : 
     640                 :            : int
     641                 :            : _compat_without_executable_dwfl_core_file_report (Dwfl *dwfl, Elf *elf)
     642                 :            : {
     643                 :            :   return dwfl_core_file_report (dwfl, elf, NULL);
     644                 :            : }
     645                 :            : #endif

Generated by: LCOV version 1.14