/* Next, we should follow the chain from DT_DEBUG. */
const void *auxv = NULL;
+ const void *note_file = NULL;
size_t auxv_size = 0;
+ size_t note_file_size = 0;
if (likely (notes_phdr.p_type == PT_NOTE))
{
/* PT_NOTE -> NT_AUXV -> AT_PHDR -> PT_DYNAMIC -> DT_DEBUG */
size_t desc_pos;
while ((pos = gelf_getnote (notes, pos, &nhdr,
&name_pos, &desc_pos)) > 0)
- if (nhdr.n_type == NT_AUXV
- && nhdr.n_namesz == sizeof "CORE"
+ if (nhdr.n_namesz == sizeof "CORE"
&& !memcmp (notes->d_buf + name_pos, "CORE", sizeof "CORE"))
{
- auxv = notes->d_buf + desc_pos;
- auxv_size = nhdr.n_descsz;
- break;
+ if (nhdr.n_type == NT_AUXV)
+ {
+ auxv = notes->d_buf + desc_pos;
+ auxv_size = nhdr.n_descsz;
+ }
+ if (nhdr.n_type == NT_FILE)
+ {
+ note_file = notes->d_buf + desc_pos;
+ note_file_size = nhdr.n_descsz;
+ }
}
}
}
int seg = dwfl_segment_report_module (dwfl, ndx, NULL,
&dwfl_elf_phdr_memory_callback, elf,
core_file_read_eagerly, elf,
+ note_file, note_file_size,
&r_debug_info);
if (unlikely (seg < 0))
{
#include "../libelf/libelfP.h" /* For NOTE_ALIGN. */
#undef _
#include "libdwflP.h"
+#include "common.h"
#include <elf.h>
#include <gelf.h>
#include <alloca.h>
#include <endian.h>
#include <unistd.h>
+#include <fcntl.h>
/* A good size for the initial read from memory, if it's not too costly.
return ndx;
}
+/* Return whether there is SZ bytes available at PTR till END.
+ Function comes from src/readelf.c . */
+
+static bool
+buf_has_data (const void *ptr, const void *end, size_t sz)
+{
+ return ptr < end && (size_t) (end - ptr) >= sz;
+}
+
+/* Read SZ bytes into *RETP from *PTRP (limited by END) in format E32.
+ Function comes from src/readelf.c . */
+
+static bool
+buf_read_ulong (const Elf32_Ehdr *e32, size_t sz,
+ const void **ptrp, const void *end, uint64_t *retp)
+{
+ if (! buf_has_data (*ptrp, end, sz))
+ return false;
+
+ union
+ {
+ uint64_t u64;
+ uint32_t u32;
+ } u;
+
+ memcpy (&u, *ptrp, sz);
+ (*ptrp) += sz;
+
+ if (retp == NULL)
+ return true;
+
+ if (MY_ELFDATA != e32->e_ident[EI_DATA])
+ {
+ if (sz == 4)
+ CONVERT (u.u32);
+ else
+ CONVERT (u.u64);
+ }
+ if (sz == 4)
+ *retp = u.u32;
+ else
+ *retp = u.u64;
+ return true;
+}
+
+/* Try to find matching entry for module from address MODULE_START to
+ MODULE_END in NT_FILE note located at NOTE_FILE of NOTE_FILE_SIZE
+ bytes in format E32. */
+
+static const char *
+handle_file_note (GElf_Addr module_start, GElf_Addr module_end,
+ const Elf32_Ehdr *e32,
+ const void *note_file, size_t note_file_size)
+{
+ if (note_file == NULL)
+ return NULL;
+
+ size_t sz;
+ switch (e32->e_ident[EI_CLASS])
+ {
+ case ELFCLASS32:
+ sz = 4;
+ break;
+ case ELFCLASS64:
+ sz = 8;
+ break;
+ default:
+ return NULL;
+ }
+
+ const void *ptr = note_file;
+ const void *end = note_file + note_file_size;
+ uint64_t count;
+ if (! buf_read_ulong (e32, sz, &ptr, end, &count))
+ return NULL;
+ if (! buf_read_ulong (e32, sz, &ptr, end, NULL)) // page_size
+ return NULL;
+
+ /* Where file names are stored. */
+ const char *fptr = ptr + 3 * count * sz;
+
+ ssize_t firstix = -1;
+ ssize_t lastix = -1;
+ for (size_t mix = 0; mix < count; mix++)
+ {
+ uint64_t mstart, mend, moffset;
+ if (! buf_read_ulong (e32, sz, &ptr, fptr, &mstart)
+ || ! buf_read_ulong (e32, sz, &ptr, fptr, &mend)
+ || ! buf_read_ulong (e32, sz, &ptr, fptr, &moffset))
+ return NULL;
+ if (mstart == module_start && moffset == 0)
+ firstix = lastix = mix;
+ if (firstix != -1 && mstart < module_end)
+ lastix = mix;
+ if (mend >= module_end)
+ break;
+ }
+ if (firstix == -1)
+ return NULL;
+
+ const char *retval = NULL;
+ for (ssize_t mix = 0; mix <= lastix; mix++)
+ {
+ const char *fnext = memchr (fptr, 0, (const char *) end - fptr);
+ if (fnext == NULL)
+ return NULL;
+ if (mix == firstix)
+ retval = fptr;
+ if (firstix < mix && mix <= lastix && strcmp (fptr, retval) != 0)
+ return NULL;
+ fptr = fnext + 1;
+ }
+ return retval;
+}
+
+/* Return true iff we are certain ELF cannot match BUILD_ID of
+ BUILD_ID_LEN bytes. Pass DISK_FILE_HAS_BUILD_ID as false if it is
+ certain ELF does not contain build-id (it is only a performance hit
+ to pass it always as true). */
+
+static bool
+invalid_elf (Elf *elf, bool disk_file_has_build_id,
+ const void *build_id, size_t build_id_len)
+{
+ if (! disk_file_has_build_id && build_id_len > 0)
+ {
+ /* Module found in segments with build-id is more reliable
+ than a module found via DT_DEBUG on disk without any
+ build-id. */
+ return true;
+ }
+ if (disk_file_has_build_id && build_id_len > 0)
+ {
+ const void *elf_build_id;
+ ssize_t elf_build_id_len;
+
+ /* If there is a build id in the elf file, check it. */
+ elf_build_id_len = INTUSE(dwelf_elf_gnu_build_id) (elf, &elf_build_id);
+ if (elf_build_id_len > 0)
+ {
+ if (build_id_len != (size_t) elf_build_id_len
+ || memcmp (build_id, elf_build_id, build_id_len) != 0)
+ return true;
+ }
+ }
+ return false;
+}
+
int
dwfl_segment_report_module (Dwfl *dwfl, int ndx, const char *name,
Dwfl_Memory_Callback *memory_callback,
void *memory_callback_arg,
Dwfl_Module_Callback *read_eagerly,
void *read_eagerly_arg,
+ const void *note_file, size_t note_file_size,
const struct r_debug_info *r_debug_info)
{
size_t segment = ndx;
void *buffer = NULL;
size_t buffer_available = INITIAL_READ;
+ Elf *elf = NULL;
+ int fd = -1;
inline int finish (void)
{
release_buffer (&buffer, &buffer_available);
+ if (elf != NULL)
+ elf_end (elf);
+ if (fd != -1)
+ close (fd);
return ndx;
}
if ((module_end > module->start && module_start < module->end)
|| dyn_vaddr == module->l_ld)
{
- bool close_elf = false;
- if (! module->disk_file_has_build_id && build_id_len > 0)
- {
- /* Module found in segments with build-id is more reliable
- than a module found via DT_DEBUG on disk without any
- build-id. */
- if (module->elf != NULL)
- close_elf = true;
- }
if (module->elf != NULL
- && module->disk_file_has_build_id && build_id_len > 0)
- {
- const void *elf_build_id;
- ssize_t elf_build_id_len;
-
- /* If there is a build id in the elf file, check it. */
- elf_build_id_len = INTUSE(dwelf_elf_gnu_build_id) (module->elf,
- &elf_build_id);
- if (elf_build_id_len > 0)
- {
- if (build_id_len != (size_t) elf_build_id_len
- || memcmp (build_id, elf_build_id, build_id_len) != 0)
- close_elf = true;
- }
- }
- if (close_elf)
+ && invalid_elf (module->elf, module->disk_file_has_build_id,
+ build_id, build_id_len))
{
elf_end (module->elf);
close (module->fd);
}
}
+ const char *file_note_name = handle_file_note (module_start, module_end,
+ &ehdr.e32,
+ note_file, note_file_size);
+ if (file_note_name)
+ {
+ name = file_note_name;
+ name_is_final = true;
+ bool invalid = false;
+ fd = open64 (name, O_RDONLY);
+ if (fd >= 0)
+ {
+ Dwfl_Error error = __libdw_open_file (&fd, &elf, true, false);
+ if (error == DWFL_E_NOERROR)
+ invalid = invalid_elf (elf, true /* disk_file_has_build_id */,
+ build_id, build_id_len);
+ }
+ if (invalid)
+ {
+ free (build_id);
+ return finish ();
+ }
+ }
+
/* Our return value now says to skip the segments contained
within the module. */
ndx = addr_segndx (dwfl, segment, module_end, true);
: dynstr_vaddr + dynstrsz - start);
const GElf_Off whole = MAX (file_trimmed_end, shdrs_end);
- Elf *elf = NULL;
- if ((*read_eagerly) (MODCB_ARGS (mod), &buffer, &buffer_available,
- cost, worthwhile, whole, contiguous,
- read_eagerly_arg, &elf)
+ if (elf == NULL
+ && (*read_eagerly) (MODCB_ARGS (mod), &buffer, &buffer_available,
+ cost, worthwhile, whole, contiguous,
+ read_eagerly_arg, &elf)
&& elf == NULL)
{
/* The caller wants to read the whole file in right now, but hasn't
{
/* Install the file in the module. */
mod->main.elf = elf;
+ elf = NULL;
+ fd = -1;
mod->main.vaddr = module_start - bias;
mod->main.address_sync = module_address_sync;
mod->main_bias = bias;
projects / thirdparty / elfutils.git / commitdiff
