src/

2007-10-04  Roland McGrath  <roland@redhat.com>

	* readelf.c (print_archive_index): New variable.
	(options, parse_opt): Accept -c/--archive-index to set it.
	(dump_archive_index): New function.
	(process_file): Take new arg WILL_PRINT_ARCHIVE_INDEX.
	Call dump_archive_index on archives if set.
	(main): Update caller.
	(any_control_option): Give it file scope, moved out of ...
	(parse_opt): ... here.

tests/
2007-10-04  Roland McGrath  <roland@redhat.com>

	* run-readelf-test4.sh: New file.
	* Makefile.am (TESTS, EXTRA_DIST): Add it.

12 files changed, 1110 insertions, 57 deletions

diff --git a/libdwfl/ChangeLog b/libdwfl/ChangeLog
index 3a99753b..454d9342 100644
--- a/libdwfl/ChangeLog
+++ b/libdwfl/ChangeLog
@@ -1,3 +1,44 @@
+2007-10-04  Roland McGrath  <roland@redhat.com>
+
+	* linux-kernel-modules.c (intuit_kernel_bounds): Take new arg NOTES,
+	fill in with vaddr of "__start_notes" symbol if found.
+	(check_notes): New function.
+	(check_kernel_notes): New function.
+	(dwfl_linux_kernel_report_kernel): Call it.
+	(check_module_notes): New function.
+	(dwfl_linux_kernel_report_modules): Call it.
+
+	* linux-kernel-modules.c (dwfl_linux_kernel_find_elf):
+	Try dwfl_build_id_find_elf first.
+
+	* linux-kernel-modules.c (report_kernel): Don't leak FD if !REPORT.
+	Set kernel module e_type to ET_DYN.
+
+2007-10-03  Roland McGrath  <roland@redhat.com>
+
+	* find-debuginfo.c (validate): New function, broken out of ...
+	(find_debuginfo_in_path): ... here.  New function, broken out of ...
+	(dwfl_standard_find_debuginfo): ... here.  Call it, after trying
+	dwfl_build_id_find_debuginfo first.
+
+	* dwfl_build_id_find_elf.c: New file.
+	* dwfl_build_id_find_debuginfo.c: New file.
+	* Makefile.am (libdwfl_a_SOURCES): Add them.
+	* libdwfl.h: Declare them.
+	* libdwflP.h: Add INTDECLs.
+
+	* dwfl_module_build_id.c: New file.
+	* dwfl_module_report_build_id.c: New file.
+	* Makefile.am (libdwfl_a_SOURCES): Add them.
+	* libdwfl.h: Declare them.
+	* libdwflP.h (struct Dwfl_Module): New members build_id_bits,
+	build_id_len, build_id_vaddr.  Declare __libdwfl_find_build_id.
+	* dwfl_module.c (__libdwfl_module_free): Free MOD->build_id_bits.
+
+	* dwfl_module_getdwarf.c (find_offsets): New function.
+	(find_dynsym): New function, calls that.
+	(find_symtab): Call it.
+
 2007-09-11  Roland McGrath  <roland@redhat.com>
 
 	* dwfl_module_addrsym.c: Prefer a later global symbol at the same
diff --git a/libdwfl/Makefile.am b/libdwfl/Makefile.am
index e5cbb979..83834cdb 100644
--- a/libdwfl/Makefile.am
+++ b/libdwfl/Makefile.am
@@ -50,11 +50,14 @@ euinclude_HEADERS = libdwfl.h
 
 libdwfl_a_SOURCES = dwfl_begin.c dwfl_end.c dwfl_error.c dwfl_version.c \
 		    dwfl_module.c dwfl_report_elf.c relocate.c \
+		    dwfl_module_build_id.c dwfl_module_report_build_id.c \
 		    derelocate.c offline.c \
 		    dwfl_module_info.c  dwfl_getmodules.c \
 		    dwfl_module_getdwarf.c dwfl_getdwarf.c \
 		    dwfl_validate_address.c \
 		    argp-std.c find-debuginfo.c \
+		    dwfl_build_id_find_elf.c \
+		    dwfl_build_id_find_debuginfo.c \
 		    linux-kernel-modules.c linux-proc-maps.c \
 		    dwfl_addrmodule.c dwfl_addrdwarf.c \
 		    cu.c dwfl_module_nextcu.c dwfl_nextcu.c dwfl_cumodule.c \
diff --git a/libdwfl/dwfl_build_id_find_debuginfo.c b/libdwfl/dwfl_build_id_find_debuginfo.c
new file mode 100644
index 00000000..97def072
--- /dev/null
+++ b/libdwfl/dwfl_build_id_find_debuginfo.c
@@ -0,0 +1,92 @@
+/* Find the debuginfo file for a module from its build ID.
+   Copyright (C) 2007 Red Hat, Inc.
+   This file is part of Red Hat elfutils.
+
+   Red Hat elfutils is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by the
+   Free Software Foundation; version 2 of the License.
+
+   Red Hat elfutils is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License along
+   with Red Hat elfutils; if not, write to the Free Software Foundation,
+   Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA.
+
+   In addition, as a special exception, Red Hat, Inc. gives You the
+   additional right to link the code of Red Hat elfutils with code licensed
+   under any Open Source Initiative certified open source license
+   (http://www.opensource.org/licenses/index.php) which requires the
+   distribution of source code with any binary distribution and to
+   distribute linked combinations of the two.  Non-GPL Code permitted under
+   this exception must only link to the code of Red Hat elfutils through
+   those well defined interfaces identified in the file named EXCEPTION
+   found in the source code files (the "Approved Interfaces").  The files
+   of Non-GPL Code may instantiate templates or use macros or inline
+   functions from the Approved Interfaces without causing the resulting
+   work to be covered by the GNU General Public License.  Only Red Hat,
+   Inc. may make changes or additions to the list of Approved Interfaces.
+   Red Hat's grant of this exception is conditioned upon your not adding
+   any new exceptions.  If you wish to add a new Approved Interface or
+   exception, please contact Red Hat.  You must obey the GNU General Public
+   License in all respects for all of the Red Hat elfutils code and other
+   code used in conjunction with Red Hat elfutils except the Non-GPL Code
+   covered by this exception.  If you modify this file, you may extend this
+   exception to your version of the file, but you are not obligated to do
+   so.  If you do not wish to provide this exception without modification,
+   you must delete this exception statement from your version and license
+   this file solely under the GPL without exception.
+
+   Red Hat elfutils is an included package of the Open Invention Network.
+   An included package of the Open Invention Network is a package for which
+   Open Invention Network licensees cross-license their patents.  No patent
+   license is granted, either expressly or impliedly, by designation as an
+   included package.  Should you wish to participate in the Open Invention
+   Network licensing program, please visit www.openinventionnetwork.com
+   <http://www.openinventionnetwork.com>.  */
+
+#include "libdwflP.h"
+#include <unistd.h>
+
+
+int
+dwfl_build_id_find_debuginfo (Dwfl_Module *mod,
+			      void **userdata __attribute__ ((unused)),
+			      const char *modname __attribute__ ((unused)),
+			      Dwarf_Addr base __attribute__ ((unused)),
+			      const char *file __attribute__ ((unused)),
+			      const char *debuglink __attribute__ ((unused)),
+			      GElf_Word crc __attribute__ ((unused)),
+			      char **debuginfo_file_name)
+{
+  int fd = -1;
+  const unsigned char *bits;
+  GElf_Addr vaddr;
+  if (INTUSE(dwfl_module_build_id) (mod, &bits, &vaddr) > 0)
+    fd = __libdwfl_open_by_build_id (mod, true, debuginfo_file_name);
+  if (fd >= 0)
+    {
+      /* We need to open an Elf handle on the file so we can check its
+	 build ID note for validation.  Backdoor the handle into the
+	 module data structure since we had to open it early anyway.  */
+      mod->debug.elf = elf_begin (fd, ELF_C_READ_MMAP_PRIVATE, NULL);
+      if (likely (__libdwfl_find_build_id (mod, false, mod->debug.elf) == 2))
+	/* Also backdoor the gratuitous flag.  */
+	mod->debug.valid = true;
+      else
+	{
+	  /* A mismatch!  */
+	  elf_end (mod->debug.elf);
+	  mod->debug.elf = NULL;
+	  close (fd);
+	  fd = -1;
+	  free (*debuginfo_file_name);
+	  *debuginfo_file_name = NULL;
+	  errno = 0;
+	}
+    }
+  return fd;
+}
+INTDEF (dwfl_build_id_find_debuginfo)
diff --git a/libdwfl/dwfl_build_id_find_elf.c b/libdwfl/dwfl_build_id_find_elf.c
new file mode 100644
index 00000000..c6215012
--- /dev/null
+++ b/libdwfl/dwfl_build_id_find_elf.c
@@ -0,0 +1,152 @@
+/* Find an ELF file for a module from its build ID.
+   Copyright (C) 2007 Red Hat, Inc.
+   This file is part of Red Hat elfutils.
+
+   Red Hat elfutils is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by the
+   Free Software Foundation; version 2 of the License.
+
+   Red Hat elfutils is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License along
+   with Red Hat elfutils; if not, write to the Free Software Foundation,
+   Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA.
+
+   In addition, as a special exception, Red Hat, Inc. gives You the
+   additional right to link the code of Red Hat elfutils with code licensed
+   under any Open Source Initiative certified open source license
+   (http://www.opensource.org/licenses/index.php) which requires the
+   distribution of source code with any binary distribution and to
+   distribute linked combinations of the two.  Non-GPL Code permitted under
+   this exception must only link to the code of Red Hat elfutils through
+   those well defined interfaces identified in the file named EXCEPTION
+   found in the source code files (the "Approved Interfaces").  The files
+   of Non-GPL Code may instantiate templates or use macros or inline
+   functions from the Approved Interfaces without causing the resulting
+   work to be covered by the GNU General Public License.  Only Red Hat,
+   Inc. may make changes or additions to the list of Approved Interfaces.
+   Red Hat's grant of this exception is conditioned upon your not adding
+   any new exceptions.  If you wish to add a new Approved Interface or
+   exception, please contact Red Hat.  You must obey the GNU General Public
+   License in all respects for all of the Red Hat elfutils code and other
+   code used in conjunction with Red Hat elfutils except the Non-GPL Code
+   covered by this exception.  If you modify this file, you may extend this
+   exception to your version of the file, but you are not obligated to do
+   so.  If you do not wish to provide this exception without modification,
+   you must delete this exception statement from your version and license
+   this file solely under the GPL without exception.
+
+   Red Hat elfutils is an included package of the Open Invention Network.
+   An included package of the Open Invention Network is a package for which
+   Open Invention Network licensees cross-license their patents.  No patent
+   license is granted, either expressly or impliedly, by designation as an
+   included package.  Should you wish to participate in the Open Invention
+   Network licensing program, please visit www.openinventionnetwork.com
+   <http://www.openinventionnetwork.com>.  */
+
+#include "libdwflP.h"
+#include <inttypes.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+
+int
+internal_function
+__libdwfl_open_by_build_id (Dwfl_Module *mod, bool debug, char **file_name)
+{
+  *file_name = NULL;
+  errno = 0;
+  if (mod->build_id_len <= 0)
+    return -1;
+
+  const size_t id_len = mod->build_id_len;
+  const uint8_t *id = mod->build_id_bits;
+
+  /* Search debuginfo_path directories' .build-id/ subdirectories.  */
+
+  char id_name[sizeof "/.build-id/" + 1 + id_len * 2 + sizeof ".debug" - 1];
+  strcpy (id_name, "/.build-id/");
+  int n = snprintf (&id_name[sizeof "/.build-id/" - 1],
+		    4, "%02" PRIx8 "/", (uint8_t) id[0]);
+  assert (n == 3);
+  for (size_t i = 1; i < id_len; ++i)
+    {
+      n = snprintf (&id_name[sizeof "/.build-id/" - 1 + 3 + (i - 1) * 2],
+		    3, "%02" PRIx8, (uint8_t) id[i]);
+      assert (n == 2);
+    }
+  if (debug)
+    strcpy (&id_name[sizeof "/.build-id/" - 1 + 3 + (id_len - 1) * 2],
+	    ".debug");
+
+  const Dwfl_Callbacks *const cb = mod->dwfl->callbacks;
+  char *path = strdupa ((cb->debuginfo_path ? *cb->debuginfo_path : NULL)
+			?: DEFAULT_DEBUGINFO_PATH);
+
+  int fd = -1;
+  char *dir;
+  while (fd < 0 && (dir = strsep (&path, ":")) != NULL)
+    {
+      if (dir[0] == '+' || dir[0] == '-')
+	++dir;
+
+      /* Only absolute directory names are useful to us.  */
+      if (dir[0] != '/')
+	continue;
+
+      size_t dirlen = strlen (dir);
+      char *name = malloc (dirlen + sizeof id_name);
+      if (unlikely (name == NULL))
+	break;
+      memcpy (mempcpy (name, dir, dirlen), id_name, sizeof id_name);
+
+      fd = TEMP_FAILURE_RETRY (open64 (name, O_RDONLY));
+      if (fd >= 0)
+	{
+	  if (*file_name != NULL)
+	    free (*file_name);
+	  *file_name = canonicalize_file_name (name);
+	  if (*file_name == NULL)
+	    {
+	      *file_name = name;
+	      name = NULL;
+	    }
+	}
+      free (name);
+    }
+
+  return fd;
+}
+
+int
+dwfl_build_id_find_elf (Dwfl_Module *mod,
+			void **userdata __attribute__ ((unused)),
+			const char *modname __attribute__ ((unused)),
+			Dwarf_Addr base __attribute__ ((unused)),
+			char **file_name, Elf **elfp)
+{
+  *elfp = NULL;
+  int fd = __libdwfl_open_by_build_id (mod, false, file_name);
+  if (fd >= 0)
+    {
+      *elfp = elf_begin (fd, ELF_C_READ_MMAP_PRIVATE, NULL);
+      if (__libdwfl_find_build_id (mod, false, *elfp) == 2)
+	/* This is a backdoor signal to short-circuit the ID refresh.  */
+	mod->main.valid = true;
+      else
+	{
+	  /* This file does not contain the ID it should!  */
+	  elf_end (*elfp);
+	  *elfp = NULL;
+	  close (fd);
+	  fd = -1;
+	  free (*file_name);
+	  *file_name = NULL;
+	}
+    }
+  return fd;
+}
+INTDEF (dwfl_build_id_find_elf)
diff --git a/libdwfl/dwfl_module.c b/libdwfl/dwfl_module.c
index b84a0a80..4cee37c2 100644
--- a/libdwfl/dwfl_module.c
+++ b/libdwfl/dwfl_module.c
@@ -103,6 +103,9 @@ __libdwfl_module_free (Dwfl_Module *mod)
     free_file (&mod->debug);
   free_file (&mod->main);
 
+  if (mod->build_id_bits != NULL)
+    free (mod->build_id_bits);
+
   free (mod->name);
   free (mod);
 }
diff --git a/libdwfl/dwfl_module_build_id.c b/libdwfl/dwfl_module_build_id.c
new file mode 100644
index 00000000..f9a6357f
--- /dev/null
+++ b/libdwfl/dwfl_module_build_id.c
@@ -0,0 +1,164 @@
+/* Return build ID information for a module.
+   Copyright (C) 2007 Red Hat, Inc.
+   This file is part of Red Hat elfutils.
+
+   Red Hat elfutils is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by the
+   Free Software Foundation; version 2 of the License.
+
+   Red Hat elfutils is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License along
+   with Red Hat elfutils; if not, write to the Free Software Foundation,
+   Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA.
+
+   In addition, as a special exception, Red Hat, Inc. gives You the
+   additional right to link the code of Red Hat elfutils with code licensed
+   under any Open Source Initiative certified open source license
+   (http://www.opensource.org/licenses/index.php) which requires the
+   distribution of source code with any binary distribution and to
+   distribute linked combinations of the two.  Non-GPL Code permitted under
+   this exception must only link to the code of Red Hat elfutils through
+   those well defined interfaces identified in the file named EXCEPTION
+   found in the source code files (the "Approved Interfaces").  The files
+   of Non-GPL Code may instantiate templates or use macros or inline
+   functions from the Approved Interfaces without causing the resulting
+   work to be covered by the GNU General Public License.  Only Red Hat,
+   Inc. may make changes or additions to the list of Approved Interfaces.
+   Red Hat's grant of this exception is conditioned upon your not adding
+   any new exceptions.  If you wish to add a new Approved Interface or
+   exception, please contact Red Hat.  You must obey the GNU General Public
+   License in all respects for all of the Red Hat elfutils code and other
+   code used in conjunction with Red Hat elfutils except the Non-GPL Code
+   covered by this exception.  If you modify this file, you may extend this
+   exception to your version of the file, but you are not obligated to do
+   so.  If you do not wish to provide this exception without modification,
+   you must delete this exception statement from your version and license
+   this file solely under the GPL without exception.
+
+   Red Hat elfutils is an included package of the Open Invention Network.
+   An included package of the Open Invention Network is a package for which
+   Open Invention Network licensees cross-license their patents.  No patent
+   license is granted, either expressly or impliedly, by designation as an
+   included package.  Should you wish to participate in the Open Invention
+   Network licensing program, please visit www.openinventionnetwork.com
+   <http://www.openinventionnetwork.com>.  */
+
+#include "libdwflP.h"
+
+static int
+found_build_id (Dwfl_Module *mod, bool set,
+		const void *bits, int len, GElf_Addr vaddr)
+{
+  if (!set)
+    /* When checking bits, we do not compare VADDR because the
+       address found in a debuginfo file may not match the main
+       file as modified by prelink.  */
+    return 1 + (mod->build_id_len == len
+		&& !memcmp (bits, mod->build_id_bits, len));
+
+  void *copy = malloc (len);
+  if (unlikely (copy == NULL))
+    {
+      __libdwfl_seterrno (DWFL_E_NOMEM);
+      return -1;
+    }
+
+  mod->build_id_bits = memcpy (copy, bits, len);
+  mod->build_id_vaddr = vaddr;
+  mod->build_id_len = len;
+  return len;
+}
+
+static int
+check_notes (Dwfl_Module *mod, bool set, Elf_Data *data, GElf_Addr data_vaddr)
+{
+  size_t pos = 0;
+  GElf_Nhdr nhdr;
+  size_t name_pos;
+  size_t desc_pos;
+  while ((pos = gelf_getnote (data, pos, &nhdr, &name_pos, &desc_pos)) > 0)
+    if (nhdr.n_type == NT_GNU_BUILD_ID
+	&& nhdr.n_namesz == sizeof "GNU" && !memcmp (data->d_buf + name_pos,
+						     "GNU", sizeof "GNU"))
+      return found_build_id (mod, set,
+			     data->d_buf + desc_pos, nhdr.n_descsz,
+			     data_vaddr == 0 ? 0 : data_vaddr + pos);
+  return 0;
+}
+
+int
+internal_function
+__libdwfl_find_build_id (Dwfl_Module *mod, bool set, Elf *elf)
+{
+  int result = 0;
+
+  Elf_Scn *scn = elf_nextscn (elf, NULL);
+
+  if (scn == NULL)
+    {
+      /* No sections, have to look for phdrs.  */
+      GElf_Ehdr ehdr_mem;
+      GElf_Ehdr *ehdr = gelf_getehdr (elf, &ehdr_mem);
+      if (unlikely (ehdr == NULL))
+	{
+	  __libdwfl_seterrno (DWFL_E_LIBELF);
+	  return -1;
+	}
+      for (uint_fast16_t i = 0; result == 0 && i < ehdr_mem.e_phnum; ++i)
+	{
+	  GElf_Phdr phdr_mem;
+	  GElf_Phdr *phdr = gelf_getphdr (elf, i, &phdr_mem);
+	  if (likely (phdr != NULL) && phdr->p_type == PT_NOTE)
+	    result = check_notes (mod, set,
+				  elf_getdata_rawchunk (elf,
+							phdr->p_offset,
+							phdr->p_filesz,
+							ELF_T_NHDR),
+				  phdr->p_vaddr + mod->main.bias);
+	}
+    }
+  else
+    do
+      {
+	GElf_Shdr shdr_mem;
+	GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
+	if (likely (shdr != NULL) && shdr->sh_type == SHT_NOTE)
+	  result = check_notes (mod, set, elf_getdata (scn, NULL),
+				(shdr->sh_flags & SHF_ALLOC)
+				? shdr->sh_addr : 0);
+      }
+    while (result == 0 && (scn = elf_nextscn (elf, scn)) != NULL);
+
+  return result;
+}
+
+int
+dwfl_module_build_id (Dwfl_Module *mod,
+		      const unsigned char **bits, GElf_Addr *vaddr)
+{
+  if (mod == NULL)
+    return -1;
+
+  if (mod->build_id_len == 0 && mod->main.elf != NULL)
+    {
+      /* We have the file, but have not examined it yet.  */
+      int result = __libdwfl_find_build_id (mod, true, mod->main.elf);
+      if (result <= 0)
+	{
+	  mod->build_id_len = -1;	/* Cache negative result.  */
+	  return result;
+	}
+    }
+
+  if (mod->build_id_len <= 0)
+    return 0;
+
+  *bits = mod->build_id_bits;
+  *vaddr = mod->build_id_vaddr;
+  return mod->build_id_len;
+}
+INTDEF (dwfl_module_build_id)
diff --git a/libdwfl/dwfl_module_getdwarf.c b/libdwfl/dwfl_module_getdwarf.c
index c0aeadd1..90c77c86 100644
--- a/libdwfl/dwfl_module_getdwarf.c
+++ b/libdwfl/dwfl_module_getdwarf.c
@@ -113,6 +113,15 @@ find_file (Dwfl_Module *mod)
 						    &mod->main.name,
 						    &mod->main.elf);
   mod->elferr = open_elf (mod, &mod->main);
+
+  if (mod->elferr == DWFL_E_NOERROR && !mod->main.valid)
+    {
+      /* Clear any explicitly reported build ID, just in case it was wrong.
+	 We'll fetch it from the file when asked.  */
+      if (mod->build_id_len > 0)
+	free (mod->build_id_bits);
+      mod->build_id_len = 0;
+    }
 }
 
 /* Search an ELF file for a ".gnu_debuglink" section.  */
@@ -237,6 +246,214 @@ load_symtab (struct dwfl_file *file, struct dwfl_file **symfile,
   return DWFL_E_NO_SYMTAB;
 }
 
+
+/* Translate addresses into file offsets.
+   OFFS[*] start out zero and remain zero if unresolved.  */
+static void
+find_offsets (Elf *elf, const GElf_Ehdr *ehdr, size_t n,
+	      GElf_Addr addrs[n], GElf_Off offs[n])
+{
+  size_t unsolved = n;
+  for (uint_fast16_t i = 0; i < ehdr->e_phnum; ++i)
+    {
+      GElf_Phdr phdr_mem;
+      GElf_Phdr *phdr = gelf_getphdr (elf, i, &phdr_mem);
+      if (phdr != NULL && phdr->p_type == PT_LOAD && phdr->p_memsz > 0)
+	for (size_t j = 0; j < n; ++j)
+	  if (offs[j] == 0
+	      && addrs[j] >= phdr->p_vaddr
+	      && addrs[j] - phdr->p_vaddr < phdr->p_filesz)
+	    {
+	      offs[j] = addrs[j] - phdr->p_vaddr + phdr->p_offset;
+	      if (--unsolved == 0)
+		break;
+	    }
+    }
+}
+
+/* Try to find a dynamic symbol table via phdrs.  */
+static void
+find_dynsym (Dwfl_Module *mod)
+{
+  GElf_Ehdr ehdr_mem;
+  GElf_Ehdr *ehdr = gelf_getehdr (mod->main.elf, &ehdr_mem);
+
+  for (uint_fast16_t i = 0; i < ehdr->e_phnum; ++i)
+    {
+      GElf_Phdr phdr_mem;
+      GElf_Phdr *phdr = gelf_getphdr (mod->main.elf, i, &phdr_mem);
+      if (phdr == NULL)
+	break;
+
+      if (phdr->p_type == PT_DYNAMIC)
+	{
+	  /* Examine the dynamic section for the pointers we need.  */
+
+	  Elf_Data *data = elf_getdata_rawchunk (mod->main.elf,
+						 phdr->p_offset, phdr->p_filesz,
+						 ELF_T_DYN);
+	  if (data == NULL)
+	    continue;
+
+	  enum
+	    {
+	      i_symtab,
+	      i_strtab,
+	      i_hash,
+	      i_gnu_hash,
+	      i_max
+	    };
+	  GElf_Addr addrs[i_max] = { 0, };
+	  GElf_Xword strsz = 0;
+	  size_t n = data->d_size / gelf_fsize (mod->main.elf,
+						ELF_T_DYN, 1, EV_CURRENT);
+	  for (size_t j = 0; j < n; ++j)
+	    {
+	      GElf_Dyn dyn_mem;
+	      GElf_Dyn *dyn = gelf_getdyn (data, j, &dyn_mem);
+	      if (dyn != NULL)
+		switch (dyn->d_tag)
+		  {
+		  case DT_SYMTAB:
+		    addrs[i_symtab] = dyn->d_un.d_ptr;
+		    continue;
+
+		  case DT_HASH:
+		    addrs[i_hash] = dyn->d_un.d_ptr;
+		    continue;
+
+		  case DT_GNU_HASH:
+		    addrs[i_gnu_hash] = dyn->d_un.d_ptr;
+		    continue;
+
+		  case DT_STRTAB:
+		    addrs[i_strtab] = dyn->d_un.d_ptr;
+		    continue;
+
+		  case DT_STRSZ:
+		    strsz = dyn->d_un.d_val;
+		    continue;
+
+		  default:
+		    continue;
+
+		  case DT_NULL:
+		    break;
+		  }
+	      break;
+	    }
+
+	  /* Translate pointers into file offsets.  */
+	  GElf_Off offs[i_max] = { 0, };
+	  find_offsets (mod->main.elf, ehdr, i_max, addrs, offs);
+
+	  /* Figure out the size of the symbol table.  */
+	  if (offs[i_hash] != 0)
+	    {
+	      /* In the original format, .hash says the size of .dynsym.  */
+
+	      size_t entsz = SH_ENTSIZE_HASH (ehdr);
+	      data = elf_getdata_rawchunk (mod->main.elf,
+					   offs[i_hash] + entsz, entsz,
+					   entsz == 4 ? ELF_T_WORD
+					   : ELF_T_XWORD);
+	      if (data != NULL)
+		mod->syments = (entsz == 4
+				? *(const GElf_Word *) data->d_buf
+				: *(const GElf_Xword *) data->d_buf);
+	    }
+	  if (offs[i_gnu_hash] != 0 && mod->syments == 0)
+	    {
+	      /* In the new format, we can derive it with some work.  */
+
+	      const struct
+	      {
+		Elf32_Word nbuckets;
+		Elf32_Word symndx;
+		Elf32_Word maskwords;
+		Elf32_Word shift2;
+	      } *header;
+
+	      data = elf_getdata_rawchunk (mod->main.elf, offs[i_gnu_hash],
+					   sizeof *header, ELF_T_WORD);
+	      if (data != NULL)
+		{
+		  header = data->d_buf;
+		  Elf32_Word nbuckets = header->nbuckets;
+		  Elf32_Word symndx = header->symndx;
+		  GElf_Off buckets_at = (offs[i_gnu_hash] + sizeof *header
+					 + (gelf_getclass (mod->main.elf)
+					    * sizeof (Elf32_Word)
+					    * header->maskwords));
+
+		  data = elf_getdata_rawchunk (mod->main.elf, buckets_at,
+					       nbuckets * sizeof (Elf32_Word),
+					       ELF_T_WORD);
+		  if (data != NULL && symndx < nbuckets)
+		    {
+		      const Elf32_Word *const buckets = data->d_buf;
+		      Elf32_Word maxndx = symndx;
+		      for (Elf32_Word bucket = 0; bucket < nbuckets; ++bucket)
+			if (buckets[bucket] > maxndx)
+			  maxndx = buckets[bucket];
+
+		      GElf_Off hasharr_at = (buckets_at
+					     + nbuckets * sizeof (Elf32_Word));
+		      hasharr_at += (maxndx - symndx) * sizeof (Elf32_Word);
+		      do
+			{
+			  data = elf_getdata_rawchunk (mod->main.elf,
+						       hasharr_at,
+						       sizeof (Elf32_Word),
+						       ELF_T_WORD);
+			  if (data != NULL
+			      && (*(const Elf32_Word *) data->d_buf & 1u))
+			    {
+			      mod->syments = maxndx + 1;
+			      break;
+			    }
+			  ++maxndx;
+			  hasharr_at += sizeof (Elf32_Word);
+			} while (data != NULL);
+		    }
+		}
+	    }
+	  if (offs[i_strtab] > offs[i_symtab] && mod->syments == 0)
+	    mod->syments = ((offs[i_strtab] - offs[i_symtab])
+			    / gelf_fsize (mod->main.elf,
+					  ELF_T_SYM, 1, EV_CURRENT));
+
+	  if (mod->syments > 0)
+	    {
+	      mod->symdata = elf_getdata_rawchunk (mod->main.elf,
+						   offs[i_symtab],
+						   gelf_fsize (mod->main.elf,
+							       ELF_T_SYM,
+							       mod->syments,
+							       EV_CURRENT),
+						   ELF_T_SYM);
+	      if (mod->symdata != NULL)
+		{
+		  mod->symstrdata = elf_getdata_rawchunk (mod->main.elf,
+							  offs[i_strtab],
+							  strsz,
+							  ELF_T_BYTE);
+		  if (mod->symstrdata == NULL)
+		    mod->symdata = NULL;
+		}
+	      if (mod->symdata == NULL)
+		mod->symerr = DWFL_E (LIBELF, elf_errno ());
+	      else
+		{
+		  mod->symfile = &mod->main;
+		  mod->symerr = DWFL_E_NOERROR;
+		}
+	      return;
+	    }
+	}
+    }
+}
+
 /* Try to find a symbol table in either MOD->main.elf or MOD->debug.elf.  */
 static void
 find_symtab (Dwfl_Module *mod)
@@ -290,11 +507,16 @@ find_symtab (Dwfl_Module *mod)
 	  break;
 
 	case DWFL_E_NO_SYMTAB:
-	  if (symscn == NULL)
-	    return;
-	  /* We still have the dynamic symbol table.  */
-	  mod->symerr = DWFL_E_NOERROR;
-	  break;
+	  if (symscn != NULL)
+	    {
+	      /* We still have the dynamic symbol table.  */
+	      mod->symerr = DWFL_E_NOERROR;
+	      break;
+	    }
+
+	  /* Last ditch, look for dynamic symbols without section headers.  */
+	  find_dynsym (mod);
+	  return;
 	}
       break;
     }
diff --git a/libdwfl/dwfl_module_report_build_id.c b/libdwfl/dwfl_module_report_build_id.c
new file mode 100644
index 00000000..4886931b
--- /dev/null
+++ b/libdwfl/dwfl_module_report_build_id.c
@@ -0,0 +1,102 @@
+/* Report build ID information for a module.
+   Copyright (C) 2007 Red Hat, Inc.
+   This file is part of Red Hat elfutils.
+
+   Red Hat elfutils is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by the
+   Free Software Foundation; version 2 of the License.
+
+   Red Hat elfutils is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License along
+   with Red Hat elfutils; if not, write to the Free Software Foundation,
+   Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA.
+
+   In addition, as a special exception, Red Hat, Inc. gives You the
+   additional right to link the code of Red Hat elfutils with code licensed
+   under any Open Source Initiative certified open source license
+   (http://www.opensource.org/licenses/index.php) which requires the
+   distribution of source code with any binary distribution and to
+   distribute linked combinations of the two.  Non-GPL Code permitted under
+   this exception must only link to the code of Red Hat elfutils through
+   those well defined interfaces identified in the file named EXCEPTION
+   found in the source code files (the "Approved Interfaces").  The files
+   of Non-GPL Code may instantiate templates or use macros or inline
+   functions from the Approved Interfaces without causing the resulting
+   work to be covered by the GNU General Public License.  Only Red Hat,
+   Inc. may make changes or additions to the list of Approved Interfaces.
+   Red Hat's grant of this exception is conditioned upon your not adding
+   any new exceptions.  If you wish to add a new Approved Interface or
+   exception, please contact Red Hat.  You must obey the GNU General Public
+   License in all respects for all of the Red Hat elfutils code and other
+   code used in conjunction with Red Hat elfutils except the Non-GPL Code
+   covered by this exception.  If you modify this file, you may extend this
+   exception to your version of the file, but you are not obligated to do
+   so.  If you do not wish to provide this exception without modification,
+   you must delete this exception statement from your version and license
+   this file solely under the GPL without exception.
+
+   Red Hat elfutils is an included package of the Open Invention Network.
+   An included package of the Open Invention Network is a package for which
+   Open Invention Network licensees cross-license their patents.  No patent
+   license is granted, either expressly or impliedly, by designation as an
+   included package.  Should you wish to participate in the Open Invention
+   Network licensing program, please visit www.openinventionnetwork.com
+   <http://www.openinventionnetwork.com>.  */
+
+#include "libdwflP.h"
+
+// XXX vs report changed module: punting old file
+int
+dwfl_module_report_build_id (Dwfl_Module *mod,
+			     const unsigned char *bits, size_t len,
+			     GElf_Addr vaddr)
+{
+  if (mod == NULL)
+    return -1;
+
+  if (mod->main.elf != NULL)
+    {
+      /* Once we know about a file, we won't take any lies about
+	 its contents.  The only permissible call is a no-op.  */
+
+      if ((size_t) mod->build_id_len == len
+	  && (mod->build_id_vaddr == vaddr || vaddr == 0)
+	  && !memcmp (bits, mod->build_id_bits, len))
+	return 0;
+
+      __libdwfl_seterrno (DWFL_E_ALREADY_ELF);
+      return -1;
+    }
+
+  if (vaddr != 0 && (vaddr < mod->low_addr || vaddr + len > mod->high_addr))
+    {
+      __libdwfl_seterrno (DWFL_E_ADDR_OUTOFRANGE);
+      return -1;
+    }
+
+  void *copy = NULL;
+  if (len > 0)
+    {
+      copy = malloc (len);
+      if (unlikely (copy == NULL))
+	{
+	  __libdwfl_seterrno (DWFL_E_NOMEM);
+	  return -1;
+	}
+      memcpy (copy, bits, len);
+    }
+
+  if (mod->build_id_len > 0)
+    free (mod->build_id_bits);
+
+  mod->build_id_bits = copy;
+  mod->build_id_len = len;
+  mod->build_id_vaddr = vaddr;
+
+  return 0;
+}
+INTDEF (dwfl_module_report_build_id)
diff --git a/libdwfl/find-debuginfo.c b/libdwfl/find-debuginfo.c
index ca1fadcb..f1ff3a4b 100644
--- a/libdwfl/find-debuginfo.c
+++ b/libdwfl/find-debuginfo.c
@@ -90,15 +90,37 @@ check_crc (int fd, GElf_Word debuglink_crc)
 	  && file_crc == debuglink_crc);
 }
 
-int
-dwfl_standard_find_debuginfo (Dwfl_Module *mod,
-			      void **userdata __attribute__ ((unused)),
-			      const char *modname __attribute__ ((unused)),
-			      GElf_Addr base __attribute__ ((unused)),
-			      const char *file_name,
-			      const char *debuglink_file,
-			      GElf_Word debuglink_crc,
-			      char **debuginfo_file_name)
+static bool
+validate (Dwfl_Module *mod, int fd, bool check, GElf_Word debuglink_crc)
+{
+  /* If we have a build ID, check only that.  */
+  if (mod->build_id_len > 0)
+    {
+      /* We need to open an Elf handle on the file so we can check its
+	 build ID note for validation.  Backdoor the handle into the
+	 module data structure since we had to open it early anyway.  */
+      mod->debug.elf = elf_begin (fd, ELF_C_READ_MMAP_PRIVATE, NULL);
+      if (likely (__libdwfl_find_build_id (mod, false, mod->debug.elf) == 2))
+	/* Also backdoor the gratuitous flag.  */
+	mod->debug.valid = true;
+      else
+	{
+	  /* A mismatch!  */
+	  elf_end (mod->debug.elf);
+	  mod->debug.elf = NULL;
+	  mod->debug.valid = false;
+	}
+
+      return mod->debug.valid;
+    }
+
+  return !check || check_crc (fd, debuglink_crc);
+}
+
+static int
+find_debuginfo_in_path (Dwfl_Module *mod, const char *file_name,
+			const char *debuglink_file, GElf_Word debuglink_crc,
+			char **debuginfo_file_name)
 {
   bool cancheck = debuglink_crc != (GElf_Word) 0;
 
@@ -181,7 +203,7 @@ dwfl_standard_find_debuginfo (Dwfl_Module *mod,
 	  default:
 	    return -1;
 	  }
-      if (!check || check_crc (fd, debuglink_crc))
+      if (validate (mod, fd, check, debuglink_crc))
 	{
 	  *debuginfo_file_name = fname;
 	  return fd;
@@ -194,4 +216,33 @@ dwfl_standard_find_debuginfo (Dwfl_Module *mod,
   errno = 0;
   return -1;
 }
+
+int
+dwfl_standard_find_debuginfo (Dwfl_Module *mod,
+			      void **userdata __attribute__ ((unused)),
+			      const char *modname __attribute__ ((unused)),
+			      GElf_Addr base __attribute__ ((unused)),
+			      const char *file_name,
+			      const char *debuglink_file,
+			      GElf_Word debuglink_crc,
+			      char **debuginfo_file_name)
+{
+  /* First try by build ID if we have one.  If that succeeds or fails
+     other than just by finding nothing, that's all we do.  */
+  const unsigned char *bits;
+  GElf_Addr vaddr;
+  if (INTUSE(dwfl_module_build_id) (mod, &bits, &vaddr) > 0)
+    {
+      int fd = INTUSE(dwfl_build_id_find_debuginfo) (mod,
+						     NULL, NULL, 0,
+						     NULL, NULL, 0,
+						     debuginfo_file_name);
+      if (fd >= 0 || errno != 0)
+	return fd;
+    }
+
+  /* Failing that, search the path by name.  */
+  return find_debuginfo_in_path (mod, file_name, debuglink_file, debuglink_crc,
+				 debuginfo_file_name);
+}
 INTDEF (dwfl_standard_find_debuginfo)
diff --git a/libdwfl/libdwfl.h b/libdwfl/libdwfl.h
index ee1b5054..5438ee2d 100644
--- a/libdwfl/libdwfl.h
+++ b/libdwfl/libdwfl.h
@@ -194,27 +194,82 @@ extern ptrdiff_t dwfl_getmodules (Dwfl *dwfl,
 extern Dwfl_Module *dwfl_addrmodule (Dwfl *dwfl, Dwarf_Addr address);
 
 
+/* Report the known build ID bits associated with a module.
+   If VADDR is nonzero, it gives the absolute address where those
+   bits are found within the module.  This can be called at any
+   time, but is usually used immediately after dwfl_report_module.
+   Once the module's main ELF file is opened, the ID note found
+   there takes precedence and cannot be changed.  */
+extern int dwfl_module_report_build_id (Dwfl_Module *mod,
+					const unsigned char *bits, size_t len,
+					GElf_Addr vaddr)
+  __nonnull_attribute__ (2);
+
+/* Extract the build ID bits associated with a module.
+   Returns -1 for errors, 0 if no ID is known, or the number of ID bytes.
+   When an ID is found, *BITS points to it; *VADDR is the absolute address
+   at which the ID bits are found within the module, or 0 if unknown.
+
+   This returns 0 when the module's main ELF file has not yet been loaded
+   and its build ID bits were not reported.  To ensure the ID is always
+   returned when determinable, call dwfl_module_getelf first.  */
+extern int dwfl_module_build_id (Dwfl_Module *mod,
+				 const unsigned char **bits, GElf_Addr *vaddr)
+  __nonnull_attribute__ (2, 3);
+
+
 /*** Standard callbacks ***/
 
-/* Standard find_debuginfo callback function.
-   This is controlled by a string specifying directories to look in.
+/* These standard find_elf and find_debuginfo callbacks are
+   controlled by a string specifying directories to look in.
    If `debuginfo_path' is set in the Dwfl_Callbacks structure
-   and the char * it points to is not null, that supplies the string.
-   Otherwise a default path is used.
-
-   If the first character of the string is + or - that says to check or to
-   ignore (respectively) the CRC32 checksum from the .gnu_debuglink
-   section.  The default is to check it.  The remainder of the string is
-   composed of elements separated by colons.  Each element can start with +
-   or - to override the global checksum behavior.  If the remainder of the
-   element is empty, the directory containing the main file is tried; if
-   it's an absolute path name, the absolute directory path containing the
-   main file is taken as a subdirectory of this path; a relative path name
-   is taken as a subdirectory of the directory containing the main file.
-   Hence for /bin/ls, string ":.debug:/usr/lib/debug" says to look in /bin,
-   then /bin/.debug, then /usr/lib/debug/bin, for the file name in the
-   .gnu_debuglink section (or "ls.debug" if none was found).  */
+   and the char * it points to is not null, that supplies the
+   string.  Otherwise a default path is used.
+
+   If the first character of the string is + or - that enables or
+   disables CRC32 checksum validation when it's necessary.  The
+   remainder of the string is composed of elements separated by
+   colons.  Each element can start with + or - to override the
+   global checksum behavior.  This flag is never relevant when
+   working with build IDs, but it's always parsed in the path
+   string.  The remainder of the element indicates a directory.
+
+   Searches by build ID consult only the elements naming absolute
+   directory paths.  They look under those directories for a link
+   named ".build-id/xx/yy" or ".build-id/xx/yy.debug", where "xxyy"
+   is the lower-case hexadecimal representation of the ID bytes.
+
+   In searches for debuginfo by name, if the remainder of the
+   element is empty, the directory containing the main file is
+   tried; if it's an absolute path name, the absolute directory path
+   containing the main file is taken as a subdirectory of this path;
+   a relative path name is taken as a subdirectory of the directory
+   containing the main file.  Hence for /bin/ls, the default string
+   ":.debug:/usr/lib/debug" says to look in /bin, then /bin/.debug,
+   then /usr/lib/debug/bin, for the file name in the .gnu_debuglink
+   section (or "ls.debug" if none was found).  */
+
+/* Standard find_elf callback function working solely on build ID.
+   This can be tried first by any find_elf callback, to use the
+   bits passed to dwfl_module_report_build_id, if any.  */
+extern int dwfl_build_id_find_elf (Dwfl_Module *, void **,
+				   const char *, Dwarf_Addr,
+				   char **, Elf **);
+
+/* Standard find_debuginfo callback function working solely on build ID.
+   This can be tried first by any find_debuginfo callback,
+   to use the build ID bits from the main file when present.  */
+extern int dwfl_build_id_find_debuginfo (Dwfl_Module *, void **,
+					 const char *, Dwarf_Addr,
+					 const char *, const char *,
+					 GElf_Word, char **);
 
+/* Standard find_debuginfo callback function.
+   If a build ID is available, this tries first to use that.
+   If there is no build ID or no valid debuginfo found by ID,
+   it searches the debuginfo path by name, as described above.
+   Any file found in the path is validated by build ID if possible,
+   or else by CRC32 checksum if enabled, and skipped if it does not match.  */
 extern int dwfl_standard_find_debuginfo (Dwfl_Module *, void **,
 					 const char *, Dwarf_Addr,
 					 const char *, const char *,
diff --git a/libdwfl/libdwflP.h b/libdwfl/libdwflP.h
index 6de87abb..4b458e1d 100644
--- a/libdwfl/libdwflP.h
+++ b/libdwfl/libdwflP.h
@@ -88,6 +88,7 @@
   DWFL_ERROR (ADDR_OUTOFRANGE, N_("address out of range"))		      \
   DWFL_ERROR (NO_MATCH, N_("no matching address range"))		      \
   DWFL_ERROR (TRUNCATED, N_("image truncated"))				      \
+  DWFL_ERROR (ALREADY_ELF, N_("ELF file opened"))			      \
   DWFL_ERROR (BADELF, N_("not a valid ELF file"))			      \
   DWFL_ERROR (WEIRD_TYPE, N_("cannot handle DWARF type description"))
 
@@ -119,6 +120,7 @@ struct dwfl_file
 {
   char *name;
   int fd;
+  bool valid;			/* The build ID note has been matched.  */
 
   Elf *elf;
   GElf_Addr bias;		/* Actual load address - p_vaddr.  */
@@ -134,6 +136,10 @@ struct Dwfl_Module
   char *name;			/* Iterator name for this module.  */
   GElf_Addr low_addr, high_addr;
 
+  void *build_id_bits;		/* malloc'd copy of build ID bits.  */
+  GElf_Addr build_id_vaddr;	/* Address where they reside, 0 if unknown.  */
+  int build_id_len;		/* -1 for prior failure, 0 if unset.  */
+
   struct dwfl_file main, debug;
   Ebl *ebl;
   GElf_Half e_type;		/* GElf_Ehdr.e_type cache.  */
@@ -253,11 +259,21 @@ extern Dwfl_Error __libdwfl_addrcu (Dwfl_Module *mod, Dwarf_Addr addr,
 
 /* Ensure that CU->lines (and CU->cu->lines) is set up.  */
 extern Dwfl_Error __libdwfl_cu_getsrclines (struct dwfl_cu *cu)
-     internal_function;
+  internal_function;
+
+/* Look in ELF for an NT_GNU_BUILD_ID note.  If SET is true, store it
+   in MOD and return its length.  If SET is false, instead compare it
+   to that stored in MOD and return 2 if they match, 1 if they do not.
+   Returns -1 for errors, 0 if no note is found.  */
+extern int __libdwfl_find_build_id (Dwfl_Module *mod, bool set, Elf *elf)
+  internal_function;
 
+/* Open a main or debuginfo file by its build ID, returns the fd.  */
+extern int __libdwfl_open_by_build_id (Dwfl_Module *mod, bool debug,
+				       char **file_name) internal_function;
 
 extern uint32_t __libdwfl_crc32 (uint32_t crc, unsigned char *buf, size_t len)
-     attribute_hidden;
+  attribute_hidden;
 extern int __libdwfl_crc32_file (int fd, uint32_t *resp) attribute_hidden;
 
 
@@ -270,17 +286,21 @@ INTDECL (dwfl_addrdwarf)
 INTDECL (dwfl_addrdie)
 INTDECL (dwfl_module_addrdie)
 INTDECL (dwfl_module_addrsym)
+INTDECL (dwfl_module_build_id)
 INTDECL (dwfl_module_getdwarf)
 INTDECL (dwfl_module_getelf)
 INTDECL (dwfl_module_getsym)
 INTDECL (dwfl_module_getsymtab)
 INTDECL (dwfl_module_getsrc)
+INTDECL (dwfl_module_report_build_id)
 INTDECL (dwfl_report_elf)
 INTDECL (dwfl_report_begin)
 INTDECL (dwfl_report_begin_add)
 INTDECL (dwfl_report_module)
 INTDECL (dwfl_report_offline)
 INTDECL (dwfl_report_end)
+INTDECL (dwfl_build_id_find_elf)
+INTDECL (dwfl_build_id_find_debuginfo)
 INTDECL (dwfl_standard_find_debuginfo)
 INTDECL (dwfl_linux_kernel_find_elf)
 INTDECL (dwfl_linux_kernel_module_section_address)
diff --git a/libdwfl/linux-kernel-modules.c b/libdwfl/linux-kernel-modules.c
index 26f185f3..6164ae74 100644
--- a/libdwfl/linux-kernel-modules.c
+++ b/libdwfl/linux-kernel-modules.c
@@ -67,6 +67,8 @@
 
 #define MODULEDIRFMT	"/lib/modules/%s"
 
+#define KNOTESFILE	"/sys/kernel/notes"
+#define	MODNOTESFMT	"/sys/module/%s/notes"
 #define KSYMSFILE	"/proc/kallsyms"
 #define MODULELIST	"/proc/modules"
 #define	SECADDRDIRFMT	"/sys/module/%s/sections/"
@@ -175,13 +177,19 @@ report_kernel (Dwfl *dwfl, const char **release,
 	  report = want > 0;
 	}
 
-      if (report
-	  && INTUSE(dwfl_report_elf) (dwfl, KERNEL_MODNAME,
-				      fname, fd, 0) == NULL)
+      if (report)
 	{
-	  close (fd);
-	  result = -1;
+	  Dwfl_Module *mod = INTUSE(dwfl_report_elf) (dwfl, KERNEL_MODNAME,
+						      fname, fd, 0);
+	  if (mod == NULL)
+	    result = -1;
+
+	  /* The kernel is ET_EXEC, but always treat it as relocatable.  */
+	  mod->e_type = ET_DYN;
 	}
+
+      if (!report || result < 0)
+	close (fd);
     }
 
   free (fname);
@@ -297,7 +305,7 @@ INTDEF (dwfl_linux_kernel_report_offline)
 
 /* Grovel around to guess the bounds of the runtime kernel image.  */
 static int
-intuit_kernel_bounds (Dwarf_Addr *start, Dwarf_Addr *end)
+intuit_kernel_bounds (Dwarf_Addr *start, Dwarf_Addr *end, Dwarf_Addr *notes)
 {
   FILE *f = fopen (KSYMSFILE, "r");
   if (f == NULL)
@@ -305,6 +313,8 @@ intuit_kernel_bounds (Dwarf_Addr *start, Dwarf_Addr *end)
 
   (void) __fsetlocking (f, FSETLOCKING_BYCALLER);
 
+  *notes = 0;
+
   char *line = NULL;
   size_t linesz = 0;
   size_t n = getline (&line, &linesz, f);
@@ -323,6 +333,14 @@ intuit_kernel_bounds (Dwarf_Addr *start, Dwarf_Addr *end)
 	      result = -1;
 	      break;
 	    }
+
+	  if (*notes == 0)
+	    {
+	      const char *sym = (strsep (&p, " \t\n")
+				 ? strsep (&p, " \t\n") : NULL);
+	      if (sym != NULL && !strcmp (sym, "__start_notes"))
+		*notes = last;
+	    }
 	}
       if ((n == 0 && feof_unlocked (f)) || (n > 1 && line[n - 2] == ']'))
 	{
@@ -345,15 +363,129 @@ intuit_kernel_bounds (Dwarf_Addr *start, Dwarf_Addr *end)
   return result;
 }
 
+
+/* Look for a build ID note in NOTESFILE and associate the ID with MOD.  */
+static int
+check_notes (Dwfl_Module *mod, const char *notesfile,
+	     Dwarf_Addr vaddr, const char *secname)
+{
+  int fd = open64 (notesfile, O_RDONLY);
+  if (fd < 0)
+    return 1;
+
+  assert (sizeof (Elf32_Nhdr) == sizeof (GElf_Nhdr));
+  assert (sizeof (Elf64_Nhdr) == sizeof (GElf_Nhdr));
+  union
+  {
+    GElf_Nhdr nhdr;
+    unsigned char data[8192];
+  } buf;
+
+  ssize_t n = read (fd, buf.data, sizeof buf);
+  close (fd);
+
+  if (n <= 0)
+    return 1;
+
+  unsigned char *p = buf.data;
+  while (p < &buf.data[n])
+    {
+      /* No translation required since we are reading the native kernel.  */
+      GElf_Nhdr *nhdr = (void *) p;
+      p += sizeof *nhdr;
+      unsigned char *name = p;
+      p += (nhdr->n_namesz + 3) & -4U;
+      unsigned char *bits = p;
+      p += (nhdr->n_descsz + 3) & -4U;
+
+      if (p <= &buf.data[n]
+	  && nhdr->n_type == NT_GNU_BUILD_ID
+	  && nhdr->n_namesz == sizeof "GNU"
+	  && !memcmp (name, "GNU", sizeof "GNU"))
+	{
+	  /* Found it.  For a module we must figure out its VADDR now.  */
+
+	  if (secname != NULL
+	      && (INTUSE(dwfl_linux_kernel_module_section_address)
+		  (mod, NULL, mod->name, 0, secname, 0, NULL, &vaddr) != 0
+		  || vaddr == (GElf_Addr) -1l))
+	    vaddr = 0;
+
+	  if (vaddr != 0)
+	    vaddr += bits - buf.data;
+	  return INTUSE(dwfl_module_report_build_id) (mod, bits,
+						      nhdr->n_descsz, vaddr);
+	}
+    }
+
+  return 0;
+}
+
+/* Look for a build ID for the kernel.  */
+static int
+check_kernel_notes (Dwfl_Module *kernelmod, GElf_Addr vaddr)
+{
+  return check_notes (kernelmod, KNOTESFILE, vaddr, NULL) < 0 ? -1 : 0;
+}
+
+/* Look for a build ID for a loaded kernel module.  */
+static int
+check_module_notes (Dwfl_Module *mod)
+{
+  char *dirs[2] = { NULL, NULL };
+  if (asprintf (&dirs[0], MODNOTESFMT, mod->name) < 0)
+    return ENOMEM;
+
+  FTS *fts = fts_open (dirs, FTS_NOSTAT, NULL);
+  if (fts == NULL)
+    {
+      free (dirs[0]);
+      return 0;
+    }
+
+  int result = 0;
+  FTSENT *f;
+  while ((f = fts_read (fts)) != NULL)
+    {
+      switch (f->fts_info)
+	{
+	case FTS_F:
+	case FTS_NSOK:
+	  result = check_notes (mod, f->fts_accpath, 0, f->fts_name);
+	  if (result > 0)	/* Nothing found.  */
+	    {
+	      result = 0;
+	      continue;
+	    }
+	  break;
+
+	case FTS_ERR:
+	case FTS_DNR:
+	  result = f->fts_errno;
+	  break;
+
+	case FTS_NS:
+	default:
+	  continue;
+	}
+
+      /* We only get here when finished or in error cases.  */
+      break;
+    }
+  fts_close (fts);
+  free (dirs[0]);
+
+  return result;
+}
+
 int
 dwfl_linux_kernel_report_kernel (Dwfl *dwfl)
 {
   Dwarf_Addr start;
   Dwarf_Addr end;
-  inline int report (void)
+  inline Dwfl_Module *report (void)
     {
-      return INTUSE(dwfl_report_module) (dwfl, KERNEL_MODNAME,
-					 start, end) == NULL ? -1 : 0;
+      return INTUSE(dwfl_report_module) (dwfl, KERNEL_MODNAME, start, end);
     }
 
   /* This is a bit of a kludge.  If we already reported the kernel,
@@ -363,14 +495,18 @@ dwfl_linux_kernel_report_kernel (Dwfl *dwfl)
       {
 	start = m->low_addr;
 	end = m->high_addr;
-	return report ();
+	return report () == NULL ? -1 : 0;
       }
 
   /* Try to figure out the bounds of the kernel image without
      looking for any vmlinux file.  */
-  int result = intuit_kernel_bounds (&start, &end);
+  Dwarf_Addr notes;
+  int result = intuit_kernel_bounds (&start, &end, &notes);
   if (result == 0)
-    return report ();
+    {
+      Dwfl_Module *mod = report ();
+      return unlikely (mod == NULL) ? -1 : check_kernel_notes (mod, notes);
+    }
   if (result != ENOENT)
     return result;
 
@@ -383,13 +519,20 @@ INTDEF (dwfl_linux_kernel_report_kernel)
 /* Dwfl_Callbacks.find_elf for the running Linux kernel and its modules.  */
 
 int
-dwfl_linux_kernel_find_elf (Dwfl_Module *mod __attribute__ ((unused)),
+dwfl_linux_kernel_find_elf (Dwfl_Module *mod,
 			    void **userdata __attribute__ ((unused)),
 			    const char *module_name,
 			    Dwarf_Addr base __attribute__ ((unused)),
-			    char **file_name,
-			    Elf **elfp __attribute__ ((unused)))
+			    char **file_name, Elf **elfp)
 {
+  if (mod->build_id_len > 0)
+    {
+      int fd = INTUSE(dwfl_build_id_find_elf) (mod, NULL, NULL, 0,
+					       file_name, elfp);
+      if (fd >= 0 || errno != 0)
+	return fd;
+    }
+
   const char *release = kernel_release ();
   if (release == NULL)
     return errno;
@@ -508,7 +651,7 @@ dwfl_linux_kernel_module_section_address
 {
   char *sysfile;
   if (asprintf (&sysfile, SECADDRDIRFMT "%s", modname, secname) < 0)
-    return ENOMEM;
+    return DWARF_CB_ABORT;
 
   FILE *f = fopen (sysfile, "r");
   free (sysfile);
@@ -559,7 +702,7 @@ dwfl_linux_kernel_module_section_address
 	      int len = asprintf (&sysfile, SECADDRDIRFMT "%s",
 				  modname, secname);
 	      if (len < 0)
-		return ENOMEM;
+		return DWARF_CB_ABORT;
 	      char *end = sysfile + len;
 	      do
 		{
@@ -620,12 +763,17 @@ dwfl_linux_kernel_report_modules (Dwfl *dwfl)
   while (getline (&line, &linesz, f) > 0
 	 && sscanf (line, "%128s %lu %*s %*s %*s %" PRIx64 " %*s\n",
 		    modname, &modsz, &modaddr) == 3)
-    if (INTUSE(dwfl_report_module) (dwfl, modname,
-				    modaddr, modaddr + modsz) == NULL)
-      {
-	result = -1;
-	break;
-      }
+    {
+      Dwfl_Module *mod = INTUSE(dwfl_report_module) (dwfl, modname,
+						     modaddr, modaddr + modsz);
+      if (mod == NULL)
+	{
+	  result = -1;
+	  break;
+	}
+
+      result = check_module_notes (mod);
+    }
   free (line);
 
   if (result == 0)