/* build-id-related functions. Copyright (C) 1991-2024 Free Software Foundation, Inc. This file is part of GDB. This program 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; either version 3 of the License, or (at your option) any later version. This program 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 this program. If not, see . */ #include "bfd.h" #include "gdb_bfd.h" #include "build-id.h" #include "gdbsupport/gdb_vecs.h" #include "symfile.h" #include "objfiles.h" #include "filenames.h" #include "gdbcore.h" #include "cli/cli-style.h" #include "gdbsupport/scoped_fd.h" #include "debuginfod-support.h" #include "extension.h" /* See build-id.h. */ const struct bfd_build_id * build_id_bfd_get (bfd *abfd) { /* Dynamic objfiles such as ones created by JIT reader API have no underlying bfd structure (that is, objfile->obfd is NULL). */ if (abfd == nullptr) return nullptr; if (!bfd_check_format (abfd, bfd_object) && !bfd_check_format (abfd, bfd_core)) return NULL; if (abfd->build_id != NULL) return abfd->build_id; /* No build-id */ return NULL; } /* See build-id.h. */ int build_id_verify (bfd *abfd, size_t check_len, const bfd_byte *check) { const struct bfd_build_id *found; int retval = 0; found = build_id_bfd_get (abfd); if (found == NULL) warning (_("File \"%ps\" has no build-id, file skipped"), styled_string (file_name_style.style (), bfd_get_filename (abfd))); else if (!build_id_equal (found, check_len, check)) warning (_("File \"%ps\" has a different build-id, file skipped"), styled_string (file_name_style.style (), bfd_get_filename (abfd))); else retval = 1; return retval; } /* Helper for build_id_to_debug_bfd. ORIGINAL_LINK with SUFFIX appended is a path to a potential build-id-based separate debug file, potentially a symlink to the real file. If the file exists and matches BUILD_ID, return a BFD reference to it. */ static gdb_bfd_ref_ptr build_id_to_debug_bfd_1 (const std::string &original_link, size_t build_id_len, const bfd_byte *build_id, const char *suffix) { tribool supports_target_stat = TRIBOOL_UNKNOWN; /* Drop the 'target:' prefix if the target filesystem is local. */ std::string_view original_link_view (original_link); if (is_target_filename (original_link) && target_filesystem_is_local ()) original_link_view = original_link_view.substr (strlen (TARGET_SYSROOT_PREFIX)); /* The upper bound of '10' here is completely arbitrary. The loop should terminate via 'break' when either (a) a readable symlink is found, or (b) a non-existing entry is found. However, for remote targets, we rely on the remote returning sane error codes. If a remote sends back the wrong error code then it might trick GDB into thinking that the symlink exists, but points to a missing file, in which case GDB will try the next seqno. We don't want a broken remote to cause GDB to spin here forever, hence a fixed upper bound. */ for (unsigned seqno = 0; seqno < 10; seqno++) { std::string link (original_link_view); if (seqno > 0) string_appendf (link, ".%u", seqno); link += suffix; separate_debug_file_debug_printf ("Trying %s...", link.c_str ()); gdb::unique_xmalloc_ptr filename_holder; const char *filename = nullptr; if (is_target_filename (link)) { gdb_assert (link.length () >= strlen (TARGET_SYSROOT_PREFIX)); const char *link_on_target = link.c_str () + strlen (TARGET_SYSROOT_PREFIX); fileio_error target_errno; if (supports_target_stat != TRIBOOL_FALSE) { struct stat sb; int res = target_fileio_stat (nullptr, link_on_target, &sb, &target_errno); if (res != 0 && target_errno != FILEIO_ENOSYS) { separate_debug_file_debug_printf ("path doesn't exist"); break; } else if (res != 0 && target_errno == FILEIO_ENOSYS) supports_target_stat = TRIBOOL_FALSE; else { supports_target_stat = TRIBOOL_TRUE; filename = link.c_str (); } } if (supports_target_stat == TRIBOOL_FALSE) { gdb_assert (filename == nullptr); /* Connecting to a target that doesn't support 'stat'. Try 'readlink' as an alternative. This isn't ideal, but is maybe better than nothing. Returns EINVAL if the path isn't a symbolic link, which hints that the path is available -- there are other errors e.g. ENOENT for when the path doesn't exist, but we just assume that anything other than EINVAL indicates the path doesn't exist. */ std::optional link_target = target_fileio_readlink (nullptr, link_on_target, &target_errno); if (link_target.has_value () || target_errno == FILEIO_EINVAL) filename = link.c_str (); else { separate_debug_file_debug_printf ("path doesn't exist"); break; } } } else { struct stat buf; /* The `access' call below automatically dereferences LINK, but we want to stop incrementing SEQNO once we find a symlink that doesn't exist. */ if (lstat (link.c_str (), &buf) != 0) { separate_debug_file_debug_printf ("path doesn't exist"); break; } /* Can LINK be accessed, or if LINK is a symlink, can the file pointed too be accessed? Do this as lrealpath() is expensive, even for the usually non-existent files. */ if (access (link.c_str (), F_OK) == 0) { filename_holder.reset (lrealpath (link.c_str ())); filename = filename_holder.get (); } } if (filename == nullptr) { separate_debug_file_debug_printf ("unable to compute real path"); continue; } /* We expect to be silent on the non-existing files. */ gdb_bfd_ref_ptr debug_bfd = gdb_bfd_open (filename, gnutarget); if (debug_bfd == NULL) { separate_debug_file_debug_printf ("unable to open `%s`", filename); continue; } if (!build_id_verify (debug_bfd.get(), build_id_len, build_id)) { separate_debug_file_debug_printf ("build-id does not match"); continue; } separate_debug_file_debug_printf ("found a match"); return debug_bfd; } separate_debug_file_debug_printf ("no suitable file found"); return {}; } /* Common code for finding BFDs of a given build-id. This function works with both debuginfo files (SUFFIX == ".debug") and executable files (SUFFIX == ""). */ static gdb_bfd_ref_ptr build_id_to_bfd_suffix (size_t build_id_len, const bfd_byte *build_id, const char *suffix) { SEPARATE_DEBUG_FILE_SCOPED_DEBUG_ENTER_EXIT; /* Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will cause "/.build-id/..." lookups. */ std::vector> debugdir_vec = dirnames_to_char_ptr_vec (debug_file_directory.c_str ()); for (const gdb::unique_xmalloc_ptr &debugdir : debugdir_vec) { const gdb_byte *data = build_id; size_t size = build_id_len; /* Compute where the file named after the build-id would be. If debugdir is "/usr/lib/debug" and the build-id is abcdef, this will give "/usr/lib/debug/.build-id/ab/cdef.debug". */ std::string link = debugdir.get (); link += "/.build-id/"; if (size > 0) { size--; string_appendf (link, "%02x/", (unsigned) *data++); } while (size-- > 0) string_appendf (link, "%02x", (unsigned) *data++); gdb_bfd_ref_ptr debug_bfd = build_id_to_debug_bfd_1 (link, build_id_len, build_id, suffix); if (debug_bfd != NULL) return debug_bfd; /* Try to look under the sysroot as well. If the sysroot is "/the/sysroot", it will give "/the/sysroot/usr/lib/debug/.build-id/ab/cdef.debug". If the sysroot is 'target:' and the target filesystem is local to GDB then 'target:/path/to/check' becomes '/path/to/check' which we just checked above. */ if (!gdb_sysroot.empty () && (gdb_sysroot != TARGET_SYSROOT_PREFIX || !target_filesystem_is_local ())) { link = gdb_sysroot + link; debug_bfd = build_id_to_debug_bfd_1 (link, build_id_len, build_id, suffix); if (debug_bfd != NULL) return debug_bfd; } } return {}; } /* See build-id.h. */ gdb_bfd_ref_ptr build_id_to_debug_bfd (size_t build_id_len, const bfd_byte *build_id) { return build_id_to_bfd_suffix (build_id_len, build_id, ".debug"); } /* Find and open a BFD for an executable file given a build-id. If no BFD can be found, return NULL. The returned reference to the BFD must be released by the caller. */ static gdb_bfd_ref_ptr build_id_to_exec_bfd (size_t build_id_len, const bfd_byte *build_id) { return build_id_to_bfd_suffix (build_id_len, build_id, ""); } /* See build-id.h. */ std::string find_separate_debug_file_by_buildid (struct objfile *objfile, deferred_warnings *warnings) { const struct bfd_build_id *build_id; build_id = build_id_bfd_get (objfile->obfd.get ()); if (build_id != NULL) { SEPARATE_DEBUG_FILE_SCOPED_DEBUG_START_END ("looking for separate debug info (build-id) for %s", objfile_name (objfile)); gdb_bfd_ref_ptr abfd (build_id_to_debug_bfd (build_id->size, build_id->data)); /* Prevent looping on a stripped .debug file. */ if (abfd != NULL && filename_cmp (bfd_get_filename (abfd.get ()), objfile_name (objfile)) == 0) { separate_debug_file_debug_printf ("\"%s\": separate debug info file has no debug info", bfd_get_filename (abfd.get ())); warnings->warn (_("\"%ps\": separate debug info file has no " "debug info"), styled_string (file_name_style.style (), bfd_get_filename (abfd.get ()))); } else if (abfd != NULL) return std::string (bfd_get_filename (abfd.get ())); } return std::string (); } /* See build-id.h. */ gdb_bfd_ref_ptr find_objfile_by_build_id (program_space *pspace, const bfd_build_id *build_id, const char *expected_filename) { gdb_bfd_ref_ptr abfd; for (unsigned attempt = 0, max_attempts = 1; attempt < max_attempts && abfd == nullptr; ++attempt) { /* Try to find the executable (or shared object) by looking for a (sym)link on disk from the build-id to the object file. */ abfd = build_id_to_exec_bfd (build_id->size, build_id->data); if (abfd != nullptr || attempt > 0) break; /* Attempt to query debuginfod for the executable. This will only get run during the first attempt, if an extension language hook (see below) asked for a second attempt then we will have already broken out of the loop above. */ gdb::unique_xmalloc_ptr path; scoped_fd fd = debuginfod_exec_query (build_id->data, build_id->size, expected_filename, &path); if (fd.get () >= 0) { abfd = gdb_bfd_open (path.get (), gnutarget); if (abfd == nullptr) warning (_("\"%ps\" from debuginfod cannot be opened as bfd: %s"), styled_string (file_name_style.style (), path.get ()), gdb_bfd_errmsg (bfd_get_error (), nullptr).c_str ()); else if (!build_id_verify (abfd.get (), build_id->size, build_id->data)) abfd = nullptr; } if (abfd != nullptr) break; ext_lang_missing_file_result ext_result = ext_lang_find_objfile_from_buildid (pspace, build_id, expected_filename); if (!ext_result.filename ().empty ()) { /* The extension identified the file for us. */ abfd = gdb_bfd_open (ext_result.filename ().c_str (), gnutarget); if (abfd == nullptr) { warning (_("\"%ps\" from extension cannot be opened as bfd: %s"), styled_string (file_name_style.style (), ext_result.filename ().c_str ()), gdb_bfd_errmsg (bfd_get_error (), nullptr).c_str ()); break; } /* If the extension gave us a path to a file then we always assume that it is the correct file, we do no additional check of its build-id. */ } else if (ext_result.try_again ()) { /* The extension might have installed the file in the expected location, we should try again. */ max_attempts = 2; continue; } } return abfd; }