LCOV - code coverage report
Current view: top level - libdwfl - link_map.c (source / functions) Hit Total Coverage
Test: elfutils-0.189 Lines: 305 470 64.9 %
Date: 2023-08-29 13:46:25 Functions: 8 10 80.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 244 428 57.0 %

           Branch data     Line data    Source code
       1                 :            : /* Report modules by examining dynamic linker data structures.
       2                 :            :    Copyright (C) 2008-2016 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 "libdwflP.h"
      32                 :            : #include "memory-access.h"
      33                 :            : #include "system.h"
      34                 :            : 
      35                 :            : #include <fcntl.h>
      36                 :            : 
      37                 :            : /* This element is always provided and always has a constant value.
      38                 :            :    This makes it an easy thing to scan for to discern the format.  */
      39                 :            : #define PROBE_TYPE      AT_PHENT
      40                 :            : #define PROBE_VAL32     sizeof (Elf32_Phdr)
      41                 :            : #define PROBE_VAL64     sizeof (Elf64_Phdr)
      42                 :            : 
      43                 :            : 
      44                 :            : static inline bool
      45                 :        207 : do_check64 (const char *a64, uint_fast8_t *elfdata)
      46                 :            : {
      47                 :            :   /* The AUXV pointer might not even be naturally aligned for 64-bit
      48                 :            :      data, because note payloads in a core file are not aligned.  */
      49                 :        207 :   const char *typep = a64 + offsetof (Elf64_auxv_t, a_type);
      50                 :        207 :   uint64_t type = read_8ubyte_unaligned_noncvt (typep);
      51                 :        207 :   const char *valp = a64 + offsetof (Elf64_auxv_t, a_un.a_val);
      52                 :        207 :   uint64_t val = read_8ubyte_unaligned_noncvt (valp);
      53                 :            : 
      54         [ +  + ]:        207 :   if (type == BE64 (PROBE_TYPE)
      55         [ +  - ]:          4 :       && val == BE64 (PROBE_VAL64))
      56                 :            :     {
      57                 :          4 :       *elfdata = ELFDATA2MSB;
      58                 :          4 :       return true;
      59                 :            :     }
      60                 :            : 
      61                 :        203 :   if (type == LE64 (PROBE_TYPE)
      62         [ +  + ]:        203 :       && val == LE64 (PROBE_VAL64))
      63                 :            :     {
      64                 :         23 :       *elfdata = ELFDATA2LSB;
      65                 :         23 :       return true;
      66                 :            :     }
      67                 :            : 
      68                 :            :   return false;
      69                 :            : }
      70                 :            : 
      71                 :            : static inline bool
      72                 :        355 : do_check32 (const char *a32, uint_fast8_t *elfdata)
      73                 :            : {
      74                 :            :   /* The AUXV pointer might not even be naturally aligned for 32-bit
      75                 :            :      data, because note payloads in a core file are not aligned.  */
      76                 :        355 :   const char *typep = a32 + offsetof (Elf32_auxv_t, a_type);
      77                 :        355 :   uint32_t type = read_4ubyte_unaligned_noncvt (typep);
      78                 :        355 :   const char *valp = a32 + offsetof (Elf32_auxv_t, a_un.a_val);
      79                 :        355 :   uint32_t val = read_4ubyte_unaligned_noncvt (valp);
      80                 :            : 
      81         [ +  + ]:        355 :   if (type == BE32 (PROBE_TYPE)
      82         [ +  - ]:          3 :       && val == BE32 (PROBE_VAL32))
      83                 :            :     {
      84                 :          3 :       *elfdata = ELFDATA2MSB;
      85                 :          3 :       return true;
      86                 :            :     }
      87                 :            : 
      88                 :        352 :   if (type == LE32 (PROBE_TYPE)
      89         [ +  + ]:        352 :       && val == LE32 (PROBE_VAL32))
      90                 :            :     {
      91                 :          4 :       *elfdata = ELFDATA2LSB;
      92                 :          4 :       return true;
      93                 :            :     }
      94                 :            : 
      95                 :            :   return false;
      96                 :            : }
      97                 :            : 
      98                 :            : /* Examine an auxv data block and determine its format.
      99                 :            :    Return true iff we figured it out.  */
     100                 :            : static bool
     101                 :         34 : auxv_format_probe (const void *auxv, size_t size,
     102                 :            :                    uint_fast8_t *elfclass, uint_fast8_t *elfdata)
     103                 :            : {
     104         [ +  - ]:        207 :   for (size_t i = 0; i < size / sizeof (Elf64_auxv_t); ++i)
     105                 :            :     {
     106         [ +  + ]:        207 :       if (do_check64 (auxv + i * sizeof (Elf64_auxv_t), elfdata))
     107                 :            :         {
     108                 :         27 :           *elfclass = ELFCLASS64;
     109                 :         27 :           return true;
     110                 :            :         }
     111                 :            : 
     112         [ +  + ]:        180 :       if (do_check32 (auxv + (i * 2) * sizeof (Elf32_auxv_t), elfdata)
     113         [ +  + ]:        175 :           || do_check32 (auxv + (i * 2 + 1) * sizeof (Elf32_auxv_t), elfdata))
     114                 :            :         {
     115                 :          7 :           *elfclass = ELFCLASS32;
     116                 :          7 :           return true;
     117                 :            :         }
     118                 :            :     }
     119                 :            : 
     120                 :            :   return false;
     121                 :            : }
     122                 :            : 
     123                 :            : /* This is a Dwfl_Memory_Callback that wraps another memory callback.
     124                 :            :    If the underlying callback cannot fill the data, then this will
     125                 :            :    fall back to fetching data from module files.  */
     126                 :            : 
     127                 :            : struct integrated_memory_callback
     128                 :            : {
     129                 :            :   Dwfl_Memory_Callback *memory_callback;
     130                 :            :   void *memory_callback_arg;
     131                 :            :   void *buffer;
     132                 :            : };
     133                 :            : 
     134                 :            : static bool
     135                 :        438 : integrated_memory_callback (Dwfl *dwfl, int ndx,
     136                 :            :                                void **buffer, size_t *buffer_available,
     137                 :            :                                GElf_Addr vaddr,
     138                 :            :                                size_t minread,
     139                 :            :                                void *arg)
     140                 :            : {
     141                 :        438 :   struct integrated_memory_callback *info = arg;
     142                 :            : 
     143         [ +  + ]:        438 :   if (ndx == -1)
     144                 :            :     {
     145                 :            :       /* Called for cleanup.  */
     146         [ +  + ]:        205 :       if (info->buffer != NULL)
     147                 :            :         {
     148                 :            :           /* The last probe buffer came from the underlying callback.
     149                 :            :              Let it do its cleanup.  */
     150         [ -  + ]:        193 :           assert (*buffer == info->buffer); /* XXX */
     151                 :        193 :           *buffer = info->buffer;
     152                 :        193 :           info->buffer = NULL;
     153                 :        193 :           return (*info->memory_callback) (dwfl, ndx, buffer, buffer_available,
     154                 :            :                                            vaddr, minread,
     155                 :            :                                            info->memory_callback_arg);
     156                 :            :         }
     157                 :         12 :       *buffer = NULL;
     158                 :         12 :       *buffer_available = 0;
     159                 :         12 :       return false;
     160                 :            :     }
     161                 :            : 
     162         [ -  + ]:        233 :   if (*buffer != NULL)
     163                 :            :     /* For a final-read request, we only use the underlying callback.  */
     164                 :          0 :     return (*info->memory_callback) (dwfl, ndx, buffer, buffer_available,
     165                 :            :                                      vaddr, minread, info->memory_callback_arg);
     166                 :            : 
     167                 :            :   /* Let the underlying callback try to fill this request.  */
     168         [ +  + ]:        233 :   if ((*info->memory_callback) (dwfl, ndx, &info->buffer, buffer_available,
     169                 :            :                                 vaddr, minread, info->memory_callback_arg))
     170                 :            :     {
     171                 :        193 :       *buffer = info->buffer;
     172                 :        193 :       return true;
     173                 :            :     }
     174                 :            : 
     175                 :            :   /* Now look for module text covering this address.  */
     176                 :            : 
     177                 :         40 :   Dwfl_Module *mod;
     178                 :         40 :   (void) INTUSE(dwfl_addrsegment) (dwfl, vaddr, &mod);
     179         [ +  - ]:         40 :   if (mod == NULL)
     180                 :            :     return false;
     181                 :            : 
     182                 :          0 :   Dwarf_Addr bias;
     183                 :          0 :   Elf_Scn *scn = INTUSE(dwfl_module_address_section) (mod, &vaddr, &bias);
     184         [ #  # ]:          0 :   if (unlikely (scn == NULL))
     185                 :            :     {
     186                 :            : #if 0 // XXX would have to handle ndx=-1 cleanup calls passed down.
     187                 :            :       /* If we have no sections we can try to fill it from the module file
     188                 :            :          based on its phdr mappings.  */
     189                 :            :       if (likely (mod->e_type != ET_REL) && mod->main.elf != NULL)
     190                 :            :         return INTUSE(dwfl_elf_phdr_memory_callback)
     191                 :            :           (dwfl, 0, buffer, buffer_available,
     192                 :            :            vaddr - mod->main.bias, minread, mod->main.elf);
     193                 :            : #endif
     194                 :            :       return false;
     195                 :            :     }
     196                 :            : 
     197                 :          0 :   Elf_Data *data = elf_rawdata (scn, NULL);
     198         [ #  # ]:          0 :   if (unlikely (data == NULL))
     199                 :            :     // XXX throw error?
     200                 :            :     return false;
     201                 :            : 
     202         [ #  # ]:          0 :   if (unlikely (data->d_size < vaddr))
     203                 :            :     return false;
     204                 :            : 
     205                 :            :   /* Provide as much data as we have.  */
     206                 :          0 :   void *contents = data->d_buf + vaddr;
     207                 :          0 :   size_t avail = data->d_size - vaddr;
     208         [ #  # ]:          0 :   if (unlikely (avail < minread))
     209                 :            :     return false;
     210                 :            : 
     211                 :            :   /* If probing for a string, make sure it's terminated.  */
     212   [ #  #  #  # ]:          0 :   if (minread == 0 && unlikely (memchr (contents, '\0', avail) == NULL))
     213                 :            :     return false;
     214                 :            : 
     215                 :            :   /* We have it! */
     216                 :          0 :   *buffer = contents;
     217                 :          0 :   *buffer_available = avail;
     218                 :          0 :   return true;
     219                 :            : }
     220                 :            : 
     221                 :            : static size_t
     222                 :        151 : addrsize (uint_fast8_t elfclass)
     223                 :            : {
     224                 :        151 :   return elfclass * 4;
     225                 :            : }
     226                 :            : 
     227                 :            : struct memory_closure
     228                 :            : {
     229                 :            :   Dwfl *dwfl;
     230                 :            :   Dwfl_Memory_Callback *callback;
     231                 :            :   void *arg;
     232                 :            : };
     233                 :            : 
     234                 :            : static inline int
     235                 :        281 : release_buffer (struct memory_closure *closure,
     236                 :            :                 void **buffer, size_t *buffer_available, int result)
     237                 :            : {
     238         [ +  + ]:        281 :   if (*buffer != NULL)
     239                 :        193 :     (*closure->callback) (closure->dwfl, -1, buffer, buffer_available, 0, 0,
     240                 :            :                           closure->arg);
     241                 :            : 
     242                 :        281 :   return result;
     243                 :            : }
     244                 :            : 
     245                 :            : static inline bool
     246                 :        130 : read_addrs (struct memory_closure *closure,
     247                 :            :             uint_fast8_t elfclass, uint_fast8_t elfdata,
     248                 :            :             void **buffer, size_t *buffer_available,
     249                 :            :             GElf_Addr vaddr, GElf_Addr *read_vaddr,
     250                 :            :             size_t n, GElf_Addr *addrs /* [4] */)
     251                 :            : {
     252                 :        130 :   size_t nb = n * addrsize (elfclass); /* Address words -> bytes to read.  */
     253                 :        130 :   Dwfl *dwfl = closure->dwfl;
     254                 :            : 
     255                 :            :   /* Read a new buffer if the old one doesn't cover these words.  */
     256         [ +  + ]:        130 :   if (*buffer == NULL
     257         [ +  + ]:         73 :       || vaddr < *read_vaddr
     258         [ +  + ]:         35 :       || nb > *buffer_available
     259         [ +  + ]:         22 :       || vaddr - (*read_vaddr) > *buffer_available - nb)
     260                 :            :     {
     261                 :        111 :       release_buffer (closure, buffer, buffer_available, 0);
     262                 :            : 
     263                 :        111 :       *read_vaddr = vaddr;
     264                 :        111 :       int segndx = INTUSE(dwfl_addrsegment) (dwfl, vaddr, NULL);
     265         [ +  - ]:        111 :       if (unlikely (segndx < 0)
     266         [ -  + ]:        111 :           || unlikely (! (*closure->callback) (dwfl, segndx,
     267                 :            :                                                buffer, buffer_available,
     268                 :            :                                                vaddr, nb, closure->arg)))
     269                 :          0 :         return true;
     270                 :            :     }
     271                 :            : 
     272                 :        130 :   unsigned char *addr = vaddr - (*read_vaddr) + (*buffer);
     273                 :            : 
     274         [ +  + ]:        130 :   if (elfclass == ELFCLASS32)
     275                 :            :     {
     276         [ +  + ]:         14 :       if (elfdata == ELFDATA2MSB)
     277         [ +  + ]:         32 :         for (size_t i = 0; i < n; ++i)
     278                 :         25 :           addrs[i] = BE32 (read_4ubyte_unaligned_noncvt (addr + i * 4));
     279                 :            :       else
     280         [ +  + ]:         32 :         for (size_t i = 0; i < n; ++i)
     281                 :         25 :           addrs[i] = LE32 (read_4ubyte_unaligned_noncvt (addr + i * 4));
     282                 :            :     }
     283                 :            :   else
     284                 :            :     {
     285         [ +  + ]:        116 :       if (elfdata == ELFDATA2MSB)
     286         [ +  + ]:         24 :         for (size_t i = 0; i < n; ++i)
     287                 :         18 :           addrs[i] = BE64 (read_8ubyte_unaligned_noncvt (addr + i * 8));
     288                 :            :       else
     289         [ +  + ]:        499 :         for (size_t i = 0; i < n; ++i)
     290                 :        389 :           addrs[i] = LE64 (read_8ubyte_unaligned_noncvt (addr + i * 8));
     291                 :            :     }
     292                 :            : 
     293                 :            :   return false;
     294                 :            : }
     295                 :            : 
     296                 :            : /* Report a module for each struct link_map in the linked list at r_map
     297                 :            :    in the struct r_debug at R_DEBUG_VADDR.  For r_debug_info description
     298                 :            :    see dwfl_link_map_report in libdwflP.h.  If R_DEBUG_INFO is not NULL then no
     299                 :            :    modules get added to DWFL, caller has to add them from filled in
     300                 :            :    R_DEBUG_INFO.
     301                 :            : 
     302                 :            :    For each link_map entry, if an existing module resides at its address,
     303                 :            :    this just modifies that module's name and suggested file name.  If
     304                 :            :    no such module exists, this calls dwfl_report_elf on the l_name string.
     305                 :            : 
     306                 :            :    Returns the number of modules found, or -1 for errors.  */
     307                 :            : 
     308                 :            : static int
     309                 :         21 : report_r_debug (uint_fast8_t elfclass, uint_fast8_t elfdata,
     310                 :            :                 Dwfl *dwfl, GElf_Addr r_debug_vaddr,
     311                 :            :                 Dwfl_Memory_Callback *memory_callback,
     312                 :            :                 void *memory_callback_arg,
     313                 :            :                 struct r_debug_info *r_debug_info)
     314                 :            : {
     315                 :            :   /* Skip r_version, to aligned r_map field.  */
     316                 :         21 :   GElf_Addr read_vaddr = r_debug_vaddr + addrsize (elfclass);
     317                 :            : 
     318                 :         21 :   void *buffer = NULL;
     319                 :         21 :   size_t buffer_available = 0;
     320                 :         21 :   GElf_Addr addrs[4];
     321                 :         21 :   struct memory_closure memory_closure = { dwfl, memory_callback,
     322                 :            :                                            memory_callback_arg };
     323         [ -  + ]:         21 :   if (unlikely (read_addrs (&memory_closure, elfclass, elfdata,
     324                 :            :                             &buffer, &buffer_available, read_vaddr, &read_vaddr,
     325                 :            :                             1, addrs)))
     326                 :          0 :     return release_buffer (&memory_closure, &buffer, &buffer_available, -1);
     327                 :            : 
     328                 :         21 :   GElf_Addr next = addrs[0];
     329                 :            : 
     330                 :         21 :   Dwfl_Module **lastmodp = &dwfl->modulelist;
     331                 :         21 :   int result = 0;
     332                 :            : 
     333                 :            :   /* There can't be more elements in the link_map list than there are
     334                 :            :      segments.  A segment is created for each PT_LOAD and there can be
     335                 :            :      up to 5 per module (-z separate-code, tends to create four LOAD
     336                 :            :      segments, gold has -z text-unlikely-segment, which might result
     337                 :            :      in creating that number of load segments) DWFL->lookup_elts is
     338                 :            :      probably twice the number of modules, so that multiplied by max
     339                 :            :      PT_LOADs is certainly above the upper bound.  If we iterate too
     340                 :            :      many times, there must be a loop in the pointers due to link_map
     341                 :            :      clobberation.  */
     342                 :            : #define MAX_PT_LOAD 5
     343                 :         21 :   size_t iterations = 0;
     344   [ +  +  +  - ]:        130 :   while (next != 0 && ++iterations < dwfl->lookup_elts * MAX_PT_LOAD)
     345                 :            :     {
     346         [ -  + ]:        109 :       if (read_addrs (&memory_closure, elfclass, elfdata,
     347                 :            :                       &buffer, &buffer_available, next, &read_vaddr,
     348                 :            :                       4, addrs))
     349                 :          0 :         return release_buffer (&memory_closure, &buffer, &buffer_available, -1);
     350                 :            : 
     351                 :            :       /* Unused: l_addr is the difference between the address in memory
     352                 :            :          and the ELF file when the core was created. We need to
     353                 :            :          recalculate the difference below because the ELF file we use
     354                 :            :          might be differently pre-linked.  */
     355                 :            :       // GElf_Addr l_addr = addrs[0];
     356                 :        109 :       GElf_Addr l_name = addrs[1];
     357                 :        109 :       GElf_Addr l_ld = addrs[2];
     358                 :        109 :       next = addrs[3];
     359                 :            : 
     360                 :            :       /* If a clobbered or truncated memory image has no useful pointer,
     361                 :            :          just skip this element.  */
     362         [ +  + ]:        109 :       if (l_ld == 0)
     363                 :          1 :         continue;
     364                 :            : 
     365                 :            :       /* Fetch the string at the l_name address.  */
     366                 :        108 :       const char *name = NULL;
     367         [ +  - ]:        108 :       if (buffer != NULL
     368         [ +  + ]:        108 :           && read_vaddr <= l_name
     369         [ +  + ]:         14 :           && l_name + 1 - read_vaddr < buffer_available
     370                 :          1 :           && memchr (l_name - read_vaddr + buffer, '\0',
     371         [ -  + ]:          1 :                      buffer_available - (l_name - read_vaddr)) != NULL)
     372                 :            :         name = l_name - read_vaddr + buffer;
     373                 :            :       else
     374                 :            :         {
     375                 :        107 :           release_buffer (&memory_closure, &buffer, &buffer_available, 0);
     376                 :        107 :           read_vaddr = l_name;
     377                 :        107 :           int segndx = INTUSE(dwfl_addrsegment) (dwfl, l_name, NULL);
     378         [ +  - ]:        107 :           if (likely (segndx >= 0)
     379         [ +  + ]:        107 :               && (*memory_callback) (dwfl, segndx,
     380                 :            :                                      &buffer, &buffer_available,
     381                 :            :                                      l_name, 0, memory_callback_arg))
     382                 :         67 :             name = buffer;
     383                 :            :         }
     384                 :            : 
     385   [ -  +  -  + ]:         68 :       if (name != NULL && name[0] == '\0')
     386                 :         40 :         name = NULL;
     387                 :            : 
     388         [ +  + ]:        108 :       if (iterations == 1
     389         [ +  + ]:         19 :           && dwfl->user_core != NULL
     390         [ -  + ]:         16 :           && dwfl->user_core->executable_for_core != NULL)
     391                 :        108 :         name = dwfl->user_core->executable_for_core;
     392                 :            : 
     393                 :        108 :       struct r_debug_info_module *r_debug_info_module = NULL;
     394         [ +  - ]:        108 :       if (r_debug_info != NULL)
     395                 :            :         {
     396                 :            :           /* Save link map information about valid shared library (or
     397                 :            :              executable) which has not been found on disk.  */
     398         [ +  + ]:        108 :           const char *name1 = name == NULL ? "" : name;
     399                 :        108 :           r_debug_info_module = malloc (sizeof (*r_debug_info_module)
     400                 :        108 :                                         + strlen (name1) + 1);
     401         [ -  + ]:        108 :           if (unlikely (r_debug_info_module == NULL))
     402                 :          0 :             release_buffer (&memory_closure, &buffer,
     403                 :            :                             &buffer_available, result);
     404                 :        108 :           r_debug_info_module->fd = -1;
     405                 :        108 :           r_debug_info_module->elf = NULL;
     406                 :        108 :           r_debug_info_module->l_ld = l_ld;
     407                 :        108 :           r_debug_info_module->start = 0;
     408                 :        108 :           r_debug_info_module->end = 0;
     409                 :        108 :           r_debug_info_module->disk_file_has_build_id = false;
     410                 :        108 :           strcpy (r_debug_info_module->name, name1);
     411                 :        108 :           r_debug_info_module->next = r_debug_info->module;
     412                 :        108 :           r_debug_info->module = r_debug_info_module;
     413                 :            :         }
     414                 :            : 
     415                 :        108 :       Dwfl_Module *mod = NULL;
     416         [ +  + ]:        108 :       if (name != NULL)
     417                 :            :         {
     418                 :            :           /* This code is mostly inlined dwfl_report_elf.  */
     419                 :            :           // XXX hook for sysroot
     420                 :         84 :           int fd = open (name, O_RDONLY);
     421         [ +  + ]:         84 :           if (fd >= 0)
     422                 :            :             {
     423                 :         30 :               Elf *elf;
     424                 :         30 :               Dwfl_Error error = __libdw_open_file (&fd, &elf, true, false);
     425                 :         30 :               GElf_Addr elf_dynamic_vaddr;
     426         [ -  + ]:         30 :               if (error == DWFL_E_NOERROR
     427         [ -  + ]:         30 :                   && __libdwfl_dynamic_vaddr_get (elf, &elf_dynamic_vaddr))
     428                 :            :                 {
     429                 :         30 :                   const void *build_id_bits;
     430                 :         30 :                   GElf_Addr build_id_elfaddr;
     431                 :         30 :                   int build_id_len;
     432                 :         30 :                   bool valid = true;
     433                 :            : 
     434         [ +  + ]:         30 :                   if (__libdwfl_find_elf_build_id (NULL, elf, &build_id_bits,
     435                 :            :                                                    &build_id_elfaddr,
     436                 :            :                                                    &build_id_len) > 0
     437         [ +  - ]:         27 :                       && build_id_elfaddr != 0)
     438                 :            :                     {
     439         [ +  - ]:         27 :                       if (r_debug_info_module != NULL)
     440                 :         27 :                         r_debug_info_module->disk_file_has_build_id = true;
     441                 :         27 :                       GElf_Addr build_id_vaddr = (build_id_elfaddr
     442                 :         27 :                                                   - elf_dynamic_vaddr + l_ld);
     443                 :            : 
     444                 :         27 :                       release_buffer (&memory_closure, &buffer,
     445                 :            :                                       &buffer_available, 0);
     446                 :         27 :                       int segndx = INTUSE(dwfl_addrsegment) (dwfl,
     447                 :            :                                                              build_id_vaddr,
     448                 :            :                                                              NULL);
     449         [ +  + ]:         27 :                       if (! (*memory_callback) (dwfl, segndx,
     450                 :            :                                                 &buffer, &buffer_available,
     451                 :            :                                                 build_id_vaddr, build_id_len,
     452                 :            :                                                 memory_callback_arg))
     453                 :            :                         {
     454                 :            :                           /* File has valid build-id which cannot be read from
     455                 :            :                              memory.  This happens for core files without bit 4
     456                 :            :                              (0x10) set in Linux /proc/PID/coredump_filter.  */
     457                 :            :                         }
     458                 :            :                       else
     459                 :            :                         {
     460         [ -  + ]:         15 :                           if (memcmp (build_id_bits, buffer, build_id_len) != 0)
     461                 :            :                             /* File has valid build-id which does not match
     462                 :            :                                the one in memory.  */
     463                 :          0 :                             valid = false;
     464                 :         15 :                           release_buffer (&memory_closure, &buffer,
     465                 :            :                                           &buffer_available, 0);
     466                 :            : 
     467                 :            :                         }
     468                 :            :                     }
     469                 :            : 
     470         [ -  + ]:         15 :                   if (valid)
     471                 :            :                     {
     472                 :            :                       // It is like l_addr but it handles differently prelinked
     473                 :            :                       // files at core dumping vs. core loading time.
     474                 :         30 :                       GElf_Addr base = l_ld - elf_dynamic_vaddr;
     475         [ -  + ]:         30 :                       if (r_debug_info_module == NULL)
     476                 :            :                         {
     477                 :            :                           // XXX hook for sysroot
     478                 :          0 :                           mod = __libdwfl_report_elf (dwfl, basename (name),
     479                 :            :                                                       name, fd, elf, base,
     480                 :            :                                                       true, true);
     481         [ #  # ]:          0 :                           if (mod != NULL)
     482                 :            :                             {
     483                 :          0 :                               elf = NULL;
     484                 :          0 :                               fd = -1;
     485                 :            :                             }
     486                 :            :                         }
     487         [ -  + ]:         30 :                       else if (__libdwfl_elf_address_range (elf, base, true,
     488                 :            :                                                             true, NULL, NULL,
     489                 :            :                                                     &r_debug_info_module->start,
     490                 :            :                                                     &r_debug_info_module->end,
     491                 :            :                                                             NULL, NULL))
     492                 :            :                         {
     493                 :         30 :                           r_debug_info_module->elf = elf;
     494                 :         30 :                           r_debug_info_module->fd = fd;
     495                 :         30 :                           elf = NULL;
     496                 :         30 :                           fd = -1;
     497                 :            :                         }
     498                 :            :                     }
     499         [ -  + ]:         30 :                   if (elf != NULL)
     500                 :          0 :                     elf_end (elf);
     501         [ -  + ]:         30 :                   if (fd != -1)
     502                 :          0 :                     close (fd);
     503                 :            :                 }
     504                 :            :             }
     505                 :            :         }
     506                 :            : 
     507         [ +  - ]:        108 :       if (mod != NULL)
     508                 :            :         {
     509                 :          0 :           ++result;
     510                 :            : 
     511                 :            :           /* Move this module to the end of the list, so that we end
     512                 :            :              up with a list in the same order as the link_map chain.  */
     513         [ #  # ]:          0 :           if (mod->next != NULL)
     514                 :            :             {
     515         [ #  # ]:          0 :               if (*lastmodp != mod)
     516                 :            :                 {
     517                 :            :                   lastmodp = &dwfl->modulelist;
     518         [ #  # ]:          0 :                   while (*lastmodp != mod)
     519                 :          0 :                     lastmodp = &(*lastmodp)->next;
     520                 :            :                 }
     521                 :          0 :               *lastmodp = mod->next;
     522                 :          0 :               mod->next = NULL;
     523         [ #  # ]:          0 :               while (*lastmodp != NULL)
     524                 :          0 :                 lastmodp = &(*lastmodp)->next;
     525                 :          0 :               *lastmodp = mod;
     526                 :            :             }
     527                 :            : 
     528                 :          0 :           lastmodp = &mod->next;
     529                 :            :         }
     530                 :            :     }
     531                 :            : 
     532                 :         21 :   return release_buffer (&memory_closure, &buffer, &buffer_available, result);
     533                 :            : }
     534                 :            : 
     535                 :            : static GElf_Addr
     536                 :          0 : consider_executable (Dwfl_Module *mod, GElf_Addr at_phdr, GElf_Addr at_entry,
     537                 :            :                      uint_fast8_t *elfclass, uint_fast8_t *elfdata,
     538                 :            :                      Dwfl_Memory_Callback *memory_callback,
     539                 :            :                      void *memory_callback_arg)
     540                 :            : {
     541                 :          0 :   GElf_Ehdr ehdr;
     542         [ #  # ]:          0 :   if (unlikely (gelf_getehdr (mod->main.elf, &ehdr) == NULL))
     543                 :            :     return 0;
     544                 :            : 
     545         [ #  # ]:          0 :   if (at_entry != 0)
     546                 :            :     {
     547                 :            :       /* If we have an AT_ENTRY value, reject this executable if
     548                 :            :          its entry point address could not have supplied that.  */
     549                 :            : 
     550         [ #  # ]:          0 :       if (ehdr.e_entry == 0)
     551                 :            :         return 0;
     552                 :            : 
     553         [ #  # ]:          0 :       if (mod->e_type == ET_EXEC)
     554                 :            :         {
     555         [ #  # ]:          0 :           if (ehdr.e_entry != at_entry)
     556                 :            :             return 0;
     557                 :            :         }
     558                 :            :       else
     559                 :            :         {
     560                 :            :           /* It could be a PIE.  */
     561                 :          0 :         }
     562                 :            :     }
     563                 :            : 
     564                 :            :   // XXX this could be saved in the file cache: phdr vaddr, DT_DEBUG d_val vaddr
     565                 :            :   /* Find the vaddr of the DT_DEBUG's d_ptr.  This is the memory
     566                 :            :      address where &r_debug was written at runtime.  */
     567                 :          0 :   GElf_Xword align = mod->dwfl->segment_align;
     568                 :          0 :   GElf_Addr d_val_vaddr = 0;
     569                 :          0 :   size_t phnum;
     570         [ #  # ]:          0 :   if (elf_getphdrnum (mod->main.elf, &phnum) != 0)
     571                 :            :     return 0;
     572                 :            : 
     573         [ #  # ]:          0 :   for (size_t i = 0; i < phnum; ++i)
     574                 :            :     {
     575                 :          0 :       GElf_Phdr phdr_mem;
     576                 :          0 :       GElf_Phdr *phdr = gelf_getphdr (mod->main.elf, i, &phdr_mem);
     577         [ #  # ]:          0 :       if (phdr == NULL)
     578                 :            :         break;
     579                 :            : 
     580   [ #  #  #  # ]:          0 :       if (phdr->p_align > 1 && (align == 0 || phdr->p_align < align))
     581                 :          0 :         align = phdr->p_align;
     582                 :            : 
     583         [ #  # ]:          0 :       if (at_phdr != 0
     584         [ #  # ]:          0 :           && phdr->p_type == PT_LOAD
     585         [ #  # ]:          0 :           && (phdr->p_offset & -align) == (ehdr.e_phoff & -align))
     586                 :            :         {
     587                 :            :           /* This is the segment that would map the phdrs.
     588                 :            :              If we have an AT_PHDR value, reject this executable
     589                 :            :              if its phdr mapping could not have supplied that.  */
     590         [ #  # ]:          0 :           if (mod->e_type == ET_EXEC)
     591                 :            :             {
     592         [ #  # ]:          0 :               if (ehdr.e_phoff - phdr->p_offset + phdr->p_vaddr != at_phdr)
     593                 :          0 :                 return 0;
     594                 :            :             }
     595                 :            :           else
     596                 :            :             {
     597                 :            :               /* It could be a PIE.  If the AT_PHDR value and our
     598                 :            :                  phdr address don't match modulo ALIGN, then this
     599                 :            :                  could not have been the right PIE.  */
     600                 :          0 :               if (((ehdr.e_phoff - phdr->p_offset + phdr->p_vaddr) & -align)
     601         [ #  # ]:          0 :                   != (at_phdr & -align))
     602                 :            :                 return 0;
     603                 :            : 
     604                 :            :               /* Calculate the bias applied to the PIE's p_vaddr values.  */
     605                 :          0 :               GElf_Addr bias = (at_phdr - (ehdr.e_phoff - phdr->p_offset
     606                 :          0 :                                            + phdr->p_vaddr));
     607                 :            : 
     608                 :            :               /* Final sanity check: if we have an AT_ENTRY value,
     609                 :            :                  reject this PIE unless its biased e_entry matches.  */
     610   [ #  #  #  # ]:          0 :               if (at_entry != 0 && at_entry != ehdr.e_entry + bias)
     611                 :            :                 return 0;
     612                 :            : 
     613                 :            :               /* If we're changing the module's address range,
     614                 :            :                  we've just invalidated the module lookup table.  */
     615         [ #  # ]:          0 :               GElf_Addr mod_bias = dwfl_adjusted_address (mod, 0);
     616         [ #  # ]:          0 :               if (bias != mod_bias)
     617                 :            :                 {
     618                 :          0 :                   mod->low_addr -= mod_bias;
     619                 :          0 :                   mod->high_addr -= mod_bias;
     620                 :          0 :                   mod->low_addr += bias;
     621                 :          0 :                   mod->high_addr += bias;
     622                 :            : 
     623                 :          0 :                   free (mod->dwfl->lookup_module);
     624                 :          0 :                   mod->dwfl->lookup_module = NULL;
     625                 :            :                 }
     626                 :            :             }
     627                 :            :         }
     628                 :            : 
     629         [ #  # ]:          0 :       if (phdr->p_type == PT_DYNAMIC)
     630                 :            :         {
     631                 :          0 :           Elf_Data *data = elf_getdata_rawchunk (mod->main.elf, phdr->p_offset,
     632                 :            :                                                  phdr->p_filesz, ELF_T_DYN);
     633         [ #  # ]:          0 :           if (data == NULL)
     634                 :          0 :             continue;
     635                 :          0 :           const size_t entsize = gelf_fsize (mod->main.elf,
     636                 :            :                                              ELF_T_DYN, 1, EV_CURRENT);
     637                 :          0 :           const size_t n = data->d_size / entsize;
     638         [ #  # ]:          0 :           for (size_t j = 0; j < n; ++j)
     639                 :            :             {
     640                 :          0 :               GElf_Dyn dyn_mem;
     641                 :          0 :               GElf_Dyn *dyn = gelf_getdyn (data, j, &dyn_mem);
     642   [ #  #  #  # ]:          0 :               if (dyn != NULL && dyn->d_tag == DT_DEBUG)
     643                 :            :                 {
     644                 :          0 :                   d_val_vaddr = phdr->p_vaddr + entsize * j + entsize / 2;
     645                 :          0 :                   break;
     646                 :            :                 }
     647                 :            :             }
     648                 :            :         }
     649                 :            :     }
     650                 :            : 
     651         [ #  # ]:          0 :   if (d_val_vaddr != 0)
     652                 :            :     {
     653                 :            :       /* Now we have the final address from which to read &r_debug.  */
     654                 :          0 :       d_val_vaddr = dwfl_adjusted_address (mod, d_val_vaddr);
     655                 :            : 
     656                 :          0 :       void *buffer = NULL;
     657                 :          0 :       size_t buffer_available = addrsize (ehdr.e_ident[EI_CLASS]);
     658                 :            : 
     659                 :          0 :       int segndx = INTUSE(dwfl_addrsegment) (mod->dwfl, d_val_vaddr, NULL);
     660                 :            : 
     661         [ #  # ]:          0 :       if ((*memory_callback) (mod->dwfl, segndx,
     662                 :            :                               &buffer, &buffer_available,
     663                 :            :                               d_val_vaddr, buffer_available,
     664                 :            :                               memory_callback_arg))
     665                 :            :         {
     666                 :          0 :           const union
     667                 :            :           {
     668                 :            :             Elf32_Addr a32;
     669                 :            :             Elf64_Addr a64;
     670                 :          0 :           } *u = buffer;
     671                 :            : 
     672                 :          0 :           GElf_Addr vaddr;
     673         [ #  # ]:          0 :           if (ehdr.e_ident[EI_CLASS] == ELFCLASS32)
     674                 :          0 :             vaddr = (ehdr.e_ident[EI_DATA] == ELFDATA2MSB
     675         [ #  # ]:          0 :                      ? BE32 (u->a32) : LE32 (u->a32));
     676                 :            :           else
     677                 :          0 :             vaddr = (ehdr.e_ident[EI_DATA] == ELFDATA2MSB
     678         [ #  # ]:          0 :                      ? BE64 (u->a64) : LE64 (u->a64));
     679                 :            : 
     680                 :          0 :           (*memory_callback) (mod->dwfl, -1, &buffer, &buffer_available, 0, 0,
     681                 :            :                               memory_callback_arg);
     682                 :            : 
     683         [ #  # ]:          0 :           if (*elfclass == ELFCLASSNONE)
     684                 :          0 :             *elfclass = ehdr.e_ident[EI_CLASS];
     685         [ #  # ]:          0 :           else if (*elfclass != ehdr.e_ident[EI_CLASS])
     686                 :          0 :             return 0;
     687                 :            : 
     688         [ #  # ]:          0 :           if (*elfdata == ELFDATANONE)
     689                 :          0 :             *elfdata = ehdr.e_ident[EI_DATA];
     690         [ #  # ]:          0 :           else if (*elfdata != ehdr.e_ident[EI_DATA])
     691                 :            :             return 0;
     692                 :            : 
     693                 :          0 :           return vaddr;
     694                 :            :         }
     695                 :            :     }
     696                 :            : 
     697                 :            :   return 0;
     698                 :            : }
     699                 :            : 
     700                 :            : /* Try to find an existing executable module with a DT_DEBUG.  */
     701                 :            : static GElf_Addr
     702                 :          0 : find_executable (Dwfl *dwfl, GElf_Addr at_phdr, GElf_Addr at_entry,
     703                 :            :                  uint_fast8_t *elfclass, uint_fast8_t *elfdata,
     704                 :            :                  Dwfl_Memory_Callback *memory_callback,
     705                 :            :                  void *memory_callback_arg)
     706                 :            : {
     707         [ #  # ]:          0 :   for (Dwfl_Module *mod = dwfl->modulelist; mod != NULL; mod = mod->next)
     708         [ #  # ]:          0 :     if (mod->main.elf != NULL)
     709                 :            :       {
     710                 :          0 :         GElf_Addr r_debug_vaddr = consider_executable (mod, at_phdr, at_entry,
     711                 :            :                                                        elfclass, elfdata,
     712                 :            :                                                        memory_callback,
     713                 :            :                                                        memory_callback_arg);
     714         [ #  # ]:          0 :         if (r_debug_vaddr != 0)
     715                 :          0 :           return r_debug_vaddr;
     716                 :            :       }
     717                 :            : 
     718                 :            :   return 0;
     719                 :            : }
     720                 :            : 
     721                 :            : 
     722                 :            : int
     723                 :         34 : dwfl_link_map_report (Dwfl *dwfl, const void *auxv, size_t auxv_size,
     724                 :            :                       Dwfl_Memory_Callback *memory_callback,
     725                 :            :                       void *memory_callback_arg,
     726                 :            :                       struct r_debug_info *r_debug_info)
     727                 :            : {
     728                 :         34 :   GElf_Addr r_debug_vaddr = 0;
     729                 :            : 
     730                 :         34 :   uint_fast8_t elfclass = ELFCLASSNONE;
     731                 :         34 :   uint_fast8_t elfdata = ELFDATANONE;
     732         [ +  - ]:         34 :   if (likely (auxv != NULL)
     733         [ +  - ]:         34 :       && likely (auxv_format_probe (auxv, auxv_size, &elfclass, &elfdata)))
     734                 :            :     {
     735                 :         34 :       GElf_Addr entry = 0;
     736                 :         34 :       GElf_Addr phdr = 0;
     737                 :         34 :       GElf_Xword phent = 0;
     738                 :         34 :       GElf_Xword phnum = 0;
     739                 :            : 
     740                 :            : #define READ_AUXV32(ptr)        read_4ubyte_unaligned_noncvt (ptr)
     741                 :            : #define READ_AUXV64(ptr)        read_8ubyte_unaligned_noncvt (ptr)
     742                 :            : #define AUXV_SCAN(NN, BL) do                                            \
     743                 :            :         {                                                               \
     744                 :            :           const Elf##NN##_auxv_t *av = auxv;                            \
     745                 :            :           for (size_t i = 0; i < auxv_size / sizeof av[0]; ++i)         \
     746                 :            :             {                                                           \
     747                 :            :               const char *typep = auxv + i * sizeof (Elf##NN##_auxv_t); \
     748                 :            :               typep += offsetof (Elf##NN##_auxv_t, a_type);             \
     749                 :            :               uint##NN##_t type = READ_AUXV##NN (typep);                \
     750                 :            :               const char *valp = auxv + i * sizeof (Elf##NN##_auxv_t);  \
     751                 :            :               valp += offsetof (Elf##NN##_auxv_t, a_un.a_val);          \
     752                 :            :               uint##NN##_t val = BL##NN (READ_AUXV##NN (valp));         \
     753                 :            :               if (type == BL##NN (AT_ENTRY))                            \
     754                 :            :                 entry = val;                                            \
     755                 :            :               else if (type == BL##NN (AT_PHDR))                        \
     756                 :            :                 phdr = val;                                             \
     757                 :            :               else if (type == BL##NN (AT_PHNUM))                       \
     758                 :            :                 phnum = val;                                            \
     759                 :            :               else if (type == BL##NN (AT_PHENT))                       \
     760                 :            :                 phent = val;                                            \
     761                 :            :               else if (type == BL##NN (AT_PAGESZ))                      \
     762                 :            :                 {                                                       \
     763                 :            :                   if (val > 1                                           \
     764                 :            :                       && (dwfl->segment_align == 0                      \
     765                 :            :                           || val < dwfl->segment_align))                \
     766                 :            :                     dwfl->segment_align = val;                          \
     767                 :            :                 }                                                       \
     768                 :            :             }                                                           \
     769                 :            :         }                                                               \
     770                 :            :       while (0)
     771                 :            : 
     772         [ +  + ]:         34 :       if (elfclass == ELFCLASS32)
     773                 :            :         {
     774         [ +  + ]:          7 :           if (elfdata == ELFDATA2MSB)
     775   [ +  +  +  +  :         73 :             AUXV_SCAN (32, BE);
          +  +  +  +  +  
          +  -  +  +  -  
             +  -  +  + ]
     776                 :            :           else
     777   [ +  +  +  +  :         83 :             AUXV_SCAN (32, LE);
          +  +  +  +  +  
          +  -  +  +  -  
             +  -  +  + ]
     778                 :            :         }
     779                 :            :       else
     780                 :            :         {
     781         [ +  + ]:         27 :           if (elfdata == ELFDATA2MSB)
     782   [ +  +  +  +  :         91 :             AUXV_SCAN (64, BE);
          +  +  +  +  +  
          +  -  +  +  -  
             +  -  +  + ]
     783                 :            :           else
     784   [ +  +  +  +  :        467 :             AUXV_SCAN (64, LE);
          +  +  +  +  +  
          +  -  +  +  -  
             +  -  +  + ]
     785                 :            :         }
     786                 :            : 
     787                 :            :       /* If we found the phdr dimensions, search phdrs for PT_DYNAMIC.  */
     788                 :         34 :       GElf_Addr dyn_vaddr = 0;
     789                 :         34 :       GElf_Xword dyn_filesz = 0;
     790                 :         34 :       GElf_Addr dyn_bias = (GElf_Addr) -1;
     791                 :            : 
     792         [ +  - ]:         34 :       if (phdr != 0 && phnum != 0
     793   [ +  +  -  + ]:         34 :           && ((elfclass == ELFCLASS32 && phent == sizeof (Elf32_Phdr))
     794   [ +  -  +  - ]:         27 :               || (elfclass == ELFCLASS64 && phent == sizeof (Elf64_Phdr))))
     795                 :            :         {
     796                 :         34 :           Dwfl_Module *phdr_mod;
     797                 :         34 :           int phdr_segndx = INTUSE(dwfl_addrsegment) (dwfl, phdr, &phdr_mod);
     798                 :         34 :           Elf_Data in =
     799                 :            :             {
     800                 :            :               .d_type = ELF_T_PHDR,
     801                 :            :               .d_version = EV_CURRENT,
     802                 :         34 :               .d_size = phnum * phent,
     803                 :            :               .d_buf = NULL
     804                 :            :             };
     805                 :         34 :           bool in_ok = (*memory_callback) (dwfl, phdr_segndx, &in.d_buf,
     806                 :            :                                            &in.d_size, phdr, phnum * phent,
     807                 :            :                                            memory_callback_arg);
     808                 :         34 :           bool in_from_exec = false;
     809         [ +  + ]:         34 :           if (! in_ok
     810         [ +  - ]:          2 :               && dwfl->user_core != NULL
     811         [ +  - ]:          2 :               && dwfl->user_core->executable_for_core != NULL)
     812                 :            :             {
     813                 :            :               /* AUXV -> PHDR -> DYNAMIC
     814                 :            :                  Both AUXV and DYNAMIC should be always present in a core file.
     815                 :            :                  PHDR may be missing in core file, try to read it from
     816                 :            :                  EXECUTABLE_FOR_CORE to find where DYNAMIC is located in the
     817                 :            :                  core file.  */
     818                 :            : 
     819                 :          2 :               int fd = open (dwfl->user_core->executable_for_core, O_RDONLY);
     820                 :          2 :               Elf *elf;
     821                 :          2 :               Dwfl_Error error = DWFL_E_ERRNO;
     822         [ +  - ]:          2 :               if (fd != -1)
     823                 :          2 :                 error = __libdw_open_file (&fd, &elf, true, false);
     824         [ -  + ]:          2 :               if (error != DWFL_E_NOERROR)
     825                 :            :                 {
     826                 :          0 :                   __libdwfl_seterrno (error);
     827                 :          0 :                   return false;
     828                 :            :                 }
     829                 :          2 :               GElf_Ehdr ehdr_mem, *ehdr = gelf_getehdr (elf, &ehdr_mem);
     830         [ -  + ]:          2 :               if (ehdr == NULL)
     831                 :            :                 {
     832                 :          0 :                   elf_end (elf);
     833                 :          0 :                   close (fd);
     834                 :          0 :                   __libdwfl_seterrno (DWFL_E_LIBELF);
     835                 :          0 :                   return false;
     836                 :            :                 }
     837                 :          2 :               size_t e_phnum;
     838         [ -  + ]:          2 :               if (elf_getphdrnum (elf, &e_phnum) != 0)
     839                 :            :                 {
     840                 :          0 :                   elf_end (elf);
     841                 :          0 :                   close (fd);
     842                 :          0 :                   __libdwfl_seterrno (DWFL_E_LIBELF);
     843                 :          0 :                   return false;
     844                 :            :                 }
     845   [ +  -  -  + ]:          2 :               if (e_phnum != phnum || ehdr->e_phentsize != phent)
     846                 :            :                 {
     847                 :          0 :                   elf_end (elf);
     848                 :          0 :                   close (fd);
     849                 :          0 :                   __libdwfl_seterrno (DWFL_E_BADELF);
     850                 :          0 :                   return false;
     851                 :            :                 }
     852                 :          2 :               off_t off = ehdr->e_phoff;
     853         [ -  + ]:          2 :               assert (in.d_buf == NULL);
     854                 :            :               /* Note this in the !in_ok path.  That means memory_callback
     855                 :            :                  failed.  But the callback might still have reset the d_size
     856                 :            :                  value (to zero).  So explicitly set it here again.  */
     857         [ -  + ]:          2 :               if (unlikely (phnum > SIZE_MAX / phent))
     858                 :            :                 {
     859                 :          0 :                   __libdwfl_seterrno (DWFL_E_NOMEM);
     860                 :          0 :                   return false;
     861                 :            :                 }
     862                 :          2 :               in.d_size = phnum * phent;
     863                 :          2 :               in.d_buf = malloc (in.d_size);
     864         [ -  + ]:          2 :               if (unlikely (in.d_buf == NULL))
     865                 :            :                 {
     866                 :          0 :                   elf_end (elf);
     867                 :          0 :                   close (fd);
     868                 :          0 :                   __libdwfl_seterrno (DWFL_E_NOMEM);
     869                 :          0 :                   return false;
     870                 :            :                 }
     871                 :          2 :               ssize_t nread = pread_retry (fd, in.d_buf, in.d_size, off);
     872                 :          2 :               elf_end (elf);
     873                 :          2 :               close (fd);
     874         [ -  + ]:          2 :               if (nread != (ssize_t) in.d_size)
     875                 :            :                 {
     876                 :          0 :                   free (in.d_buf);
     877                 :          0 :                   __libdwfl_seterrno (DWFL_E_ERRNO);
     878                 :          0 :                   return false;
     879                 :            :                 }
     880                 :          2 :               in_ok = true;
     881                 :          2 :               in_from_exec = true;
     882                 :            :             }
     883                 :          2 :           if (in_ok)
     884                 :            :             {
     885         [ -  + ]:         34 :               if (unlikely (phnum > SIZE_MAX / phent))
     886                 :            :                 {
     887                 :          0 :                   __libdwfl_seterrno (DWFL_E_NOMEM);
     888                 :          0 :                   return false;
     889                 :            :                 }
     890                 :         34 :               size_t nbytes = phnum * phent;
     891                 :            :               /* We can only process as many bytes/phnum as there are
     892                 :            :                  in in.d_size. The data might have been truncated.  */
     893         [ -  + ]:         34 :               if (nbytes > in.d_size)
     894                 :            :                 {
     895                 :          0 :                   nbytes = in.d_size;
     896                 :          0 :                   phnum = nbytes / phent;
     897         [ #  # ]:          0 :                   if (phnum == 0)
     898                 :            :                     {
     899                 :          0 :                       __libdwfl_seterrno (DWFL_E_BADELF);
     900                 :          0 :                       return false;
     901                 :            :                     }
     902                 :            :                 }
     903                 :         34 :               void *buf = malloc (nbytes);
     904                 :         34 :               Elf32_Phdr (*p32)[phnum] = buf;
     905                 :         34 :               Elf64_Phdr (*p64)[phnum] = buf;
     906         [ -  + ]:         34 :               if (unlikely (buf == NULL))
     907                 :            :                 {
     908                 :          0 :                   __libdwfl_seterrno (DWFL_E_NOMEM);
     909                 :          0 :                   return false;
     910                 :            :                 }
     911                 :         34 :               Elf_Data out =
     912                 :            :                 {
     913                 :            :                   .d_type = ELF_T_PHDR,
     914                 :            :                   .d_version = EV_CURRENT,
     915                 :            :                   .d_size = nbytes,
     916                 :            :                   .d_buf = buf
     917                 :            :                 };
     918         [ +  + ]:         34 :               if (in.d_size > out.d_size)
     919                 :            :                 {
     920                 :         32 :                   in.d_size = out.d_size;
     921                 :         32 :                   phnum = in.d_size / phent;
     922         [ -  + ]:         32 :                   if (phnum == 0)
     923                 :            :                     {
     924                 :          0 :                       free (buf);
     925                 :          0 :                       __libdwfl_seterrno (DWFL_E_BADELF);
     926                 :          0 :                       return false;
     927                 :            :                     }
     928                 :            :                 }
     929                 :         34 :               bool is32 = (elfclass == ELFCLASS32);
     930                 :         68 :               size_t phdr_align = (is32
     931                 :            :                                    ? __alignof__ (Elf32_Phdr)
     932         [ +  + ]:         34 :                                    : __alignof__ (Elf64_Phdr));
     933         [ +  + ]:         34 :               if (!in_from_exec
     934         [ -  + ]:         32 :                   && ((uintptr_t) in.d_buf & (phdr_align - 1)) != 0)
     935                 :            :                 {
     936                 :          0 :                   memcpy (out.d_buf, in.d_buf, in.d_size);
     937                 :          0 :                   in.d_buf = out.d_buf;
     938                 :            :                 }
     939   [ +  +  +  - ]:         61 :               if (likely ((elfclass == ELFCLASS32
     940                 :            :                            ? elf32_xlatetom : elf64_xlatetom)
     941                 :            :                           (&out, &in, elfdata) != NULL))
     942                 :            :                 {
     943         [ +  + ]:        183 :                   for (size_t i = 0; i < phnum; ++i)
     944                 :            :                     {
     945                 :        340 :                       GElf_Word type = (is32
     946                 :            :                                         ? (*p32)[i].p_type
     947         [ +  + ]:        170 :                                         : (*p64)[i].p_type);
     948                 :        340 :                       GElf_Addr vaddr = (is32
     949                 :         37 :                                          ? (*p32)[i].p_vaddr
     950         [ +  + ]:        170 :                                          : (*p64)[i].p_vaddr);
     951                 :        340 :                       GElf_Xword filesz = (is32
     952                 :         37 :                                            ? (*p32)[i].p_filesz
     953         [ +  + ]:        170 :                                            : (*p64)[i].p_filesz);
     954                 :            : 
     955         [ +  + ]:        170 :                       if (type == PT_PHDR)
     956                 :            :                         {
     957         [ +  - ]:         21 :                           if (dyn_bias == (GElf_Addr) -1
     958                 :            :                               /* Do a sanity check on the putative address.  */
     959                 :         21 :                               && ((vaddr & (dwfl->segment_align - 1))
     960         [ +  - ]:         21 :                                   == (phdr & (dwfl->segment_align - 1))))
     961                 :            :                             {
     962                 :         21 :                               dyn_bias = phdr - vaddr;
     963         [ +  - ]:         21 :                               if (dyn_vaddr != 0)
     964                 :            :                                 break;
     965                 :            :                             }
     966                 :            : 
     967                 :            :                         }
     968         [ +  + ]:        149 :                       else if (type == PT_DYNAMIC)
     969                 :            :                         {
     970                 :         21 :                           dyn_vaddr = vaddr;
     971                 :         21 :                           dyn_filesz = filesz;
     972         [ -  + ]:         21 :                           if (dyn_bias != (GElf_Addr) -1)
     973                 :            :                             break;
     974                 :            :                         }
     975                 :            :                     }
     976                 :            :                 }
     977                 :            : 
     978         [ +  + ]:         34 :               if (in_from_exec)
     979                 :          2 :                 free (in.d_buf);
     980                 :            :               else
     981                 :         32 :                 (*memory_callback) (dwfl, -1, &in.d_buf, &in.d_size, 0, 0,
     982                 :            :                                     memory_callback_arg);
     983                 :         34 :               free (buf);
     984                 :            :             }
     985                 :            :           else
     986                 :            :             /* We could not read the executable's phdrs from the
     987                 :            :                memory image.  If we have a presupplied executable,
     988                 :            :                we can still use the AT_PHDR and AT_ENTRY values to
     989                 :            :                verify it, and to adjust its bias if it's a PIE.
     990                 :            : 
     991                 :            :                If there was an ET_EXEC module presupplied that contains
     992                 :            :                the AT_PHDR address, then we only consider that one.
     993                 :            :                We'll either accept it if its phdr location and e_entry
     994                 :            :                make sense or reject it if they don't.  If there is no
     995                 :            :                presupplied ET_EXEC, then look for a presupplied module,
     996                 :            :                which might be a PIE (ET_DYN) that needs its bias adjusted.  */
     997                 :          0 :             r_debug_vaddr = ((phdr_mod == NULL
     998         [ #  # ]:          0 :                               || phdr_mod->main.elf == NULL
     999         [ #  # ]:          0 :                               || phdr_mod->e_type != ET_EXEC)
    1000                 :          0 :                              ? find_executable (dwfl, phdr, entry,
    1001                 :            :                                                 &elfclass, &elfdata,
    1002                 :            :                                                 memory_callback,
    1003                 :            :                                                 memory_callback_arg)
    1004         [ #  # ]:          0 :                              : consider_executable (phdr_mod, phdr, entry,
    1005                 :            :                                                     &elfclass, &elfdata,
    1006                 :            :                                                     memory_callback,
    1007                 :            :                                                     memory_callback_arg));
    1008                 :            :         }
    1009                 :            : 
    1010                 :            :       /* If we found PT_DYNAMIC, search it for DT_DEBUG.  */
    1011         [ +  + ]:         34 :       if (dyn_filesz != 0)
    1012                 :            :         {
    1013         [ +  - ]:         21 :           if (dyn_bias != (GElf_Addr) -1)
    1014                 :         21 :             dyn_vaddr += dyn_bias;
    1015                 :            : 
    1016                 :         21 :           Elf_Data in =
    1017                 :            :             {
    1018                 :            :               .d_type = ELF_T_DYN,
    1019                 :            :               .d_version = EV_CURRENT,
    1020                 :            :               .d_size = dyn_filesz,
    1021                 :            :               .d_buf = NULL
    1022                 :            :             };
    1023                 :         21 :           int dyn_segndx = dwfl_addrsegment (dwfl, dyn_vaddr, NULL);
    1024         [ +  - ]:         21 :           if ((*memory_callback) (dwfl, dyn_segndx, &in.d_buf, &in.d_size,
    1025                 :            :                                   dyn_vaddr, dyn_filesz, memory_callback_arg))
    1026                 :            :             {
    1027                 :         42 :               size_t entsize = (elfclass == ELFCLASS32
    1028         [ +  + ]:         21 :                                 ? sizeof (Elf32_Dyn) : sizeof (Elf64_Dyn));
    1029         [ -  + ]:         21 :               if (unlikely (dyn_filesz > SIZE_MAX / entsize))
    1030                 :            :                 {
    1031                 :          0 :                   __libdwfl_seterrno (DWFL_E_NOMEM);
    1032                 :          0 :                   return false;
    1033                 :            :                 }
    1034                 :            :               /* We can only process as many bytes as there are in
    1035                 :            :                  in.d_size. The data might have been truncated.  */
    1036                 :         21 :               if (dyn_filesz > in.d_size)
    1037                 :            :                 dyn_filesz = in.d_size;
    1038         [ -  + ]:         21 :               if (dyn_filesz / entsize == 0)
    1039                 :            :                 {
    1040                 :          0 :                   __libdwfl_seterrno (DWFL_E_BADELF);
    1041                 :          0 :                   return false;
    1042                 :            :                 }
    1043                 :         21 :               void *buf = malloc (dyn_filesz);
    1044         [ -  + ]:         21 :               if (unlikely (buf == NULL))
    1045                 :            :                 {
    1046                 :          0 :                   __libdwfl_seterrno (DWFL_E_NOMEM);
    1047                 :          0 :                   return false;
    1048                 :            :                 }
    1049                 :         21 :               Elf_Data out =
    1050                 :            :                 {
    1051                 :            :                   .d_type = ELF_T_DYN,
    1052                 :            :                   .d_version = EV_CURRENT,
    1053                 :            :                   .d_size = dyn_filesz,
    1054                 :            :                   .d_buf = buf
    1055                 :            :                 };
    1056         [ +  - ]:         21 :               if (in.d_size > out.d_size)
    1057                 :         21 :                 in.d_size = out.d_size;
    1058                 :         42 :               size_t dyn_align = (elfclass == ELFCLASS32
    1059                 :            :                                   ? __alignof__ (Elf32_Dyn)
    1060         [ +  + ]:         21 :                                   : __alignof__ (Elf64_Dyn));
    1061         [ -  + ]:         21 :               if (((uintptr_t) in.d_buf & (dyn_align - 1)) != 0)
    1062                 :            :                 {
    1063                 :          0 :                   memcpy (out.d_buf, in.d_buf, in.d_size);
    1064                 :          0 :                   in.d_buf = out.d_buf;
    1065                 :            :                 }
    1066   [ +  +  +  - ]:         40 :               if (likely ((elfclass == ELFCLASS32
    1067                 :            :                            ? elf32_xlatetom : elf64_xlatetom)
    1068                 :            :                           (&out, &in, elfdata) != NULL))
    1069                 :            :                 {
    1070                 :            :                   /* We are looking for DT_DEBUG.  */
    1071         [ +  + ]:         21 :                   if (elfclass == ELFCLASS32)
    1072                 :            :                     {
    1073                 :          2 :                       Elf32_Dyn (*d32)[dyn_filesz / sizeof (Elf32_Dyn)] = buf;
    1074                 :          2 :                       size_t n = dyn_filesz / sizeof (Elf32_Dyn);
    1075         [ +  - ]:         28 :                       for (size_t i = 0; i < n; ++i)
    1076         [ +  + ]:         28 :                         if ((*d32)[i].d_tag == DT_DEBUG)
    1077                 :            :                           {
    1078                 :          2 :                             r_debug_vaddr = (*d32)[i].d_un.d_val;
    1079                 :          2 :                             break;
    1080                 :            :                           }
    1081                 :            :                     }
    1082                 :            :                   else
    1083                 :            :                     {
    1084                 :         19 :                       Elf64_Dyn (*d64)[dyn_filesz / sizeof (Elf64_Dyn)] = buf;
    1085                 :         19 :                       size_t n = dyn_filesz / sizeof (Elf64_Dyn);
    1086         [ +  - ]:        258 :                       for (size_t i = 0; i < n; ++i)
    1087         [ +  + ]:        258 :                         if ((*d64)[i].d_tag == DT_DEBUG)
    1088                 :            :                           {
    1089                 :         19 :                             r_debug_vaddr = (*d64)[i].d_un.d_val;
    1090                 :         19 :                             break;
    1091                 :            :                           }
    1092                 :            :                     }
    1093                 :            :                 }
    1094                 :            : 
    1095                 :         21 :               (*memory_callback) (dwfl, -1, &in.d_buf, &in.d_size, 0, 0,
    1096                 :            :                                   memory_callback_arg);
    1097                 :         21 :               free (buf);
    1098                 :            :             }
    1099                 :            :         }
    1100                 :            :     }
    1101                 :            :   else
    1102                 :            :     /* We have to look for a presupplied executable file to determine
    1103                 :            :        the vaddr of its dynamic section and DT_DEBUG therein.  */
    1104                 :          0 :     r_debug_vaddr = find_executable (dwfl, 0, 0, &elfclass, &elfdata,
    1105                 :            :                                      memory_callback, memory_callback_arg);
    1106                 :            : 
    1107         [ +  + ]:         34 :   if (r_debug_vaddr == 0)
    1108                 :            :     return 0;
    1109                 :            : 
    1110                 :            :   /* For following pointers from struct link_map, we will use an
    1111                 :            :      integrated memory access callback that can consult module text
    1112                 :            :      elided from the core file.  This is necessary when the l_name
    1113                 :            :      pointer for the dynamic linker's own entry is a pointer into the
    1114                 :            :      executable's .interp section.  */
    1115                 :         21 :   struct integrated_memory_callback mcb =
    1116                 :            :     {
    1117                 :            :       .memory_callback = memory_callback,
    1118                 :            :       .memory_callback_arg = memory_callback_arg
    1119                 :            :     };
    1120                 :            : 
    1121                 :            :   /* Now we can follow the dynamic linker's library list.  */
    1122                 :         21 :   return report_r_debug (elfclass, elfdata, dwfl, r_debug_vaddr,
    1123                 :            :                          &integrated_memory_callback, &mcb, r_debug_info);
    1124                 :            : }
    1125                 :            : INTDEF (dwfl_link_map_report)

Generated by: LCOV version 1.16