LCOV - code coverage report
Current view: top level - libdwfl - link_map.c (source / functions) Hit Total Coverage
Test: elfutils-0.191 Lines: 312 478 65.3 %
Date: 2024-07-23 19:52:03 Functions: 8 10 80.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 252 436 57.8 %

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

Generated by: LCOV version 1.16