libdwfl/link_map.c

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