mirrors/binutils-gdb
1
0
Fork 0
mirror of https://sourceware.org/git/binutils-gdb.git synced 2024-11-23 01:53:38 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
master
binutils-gdb/gdb/gdbcore.h
Andrew Burgess fa826a4bbe gdb: improve shared library build-id check for core-files 
When GDB opens a core file, in 'core_target::build_file_mappings ()',
we collection information about the files that are mapped into the
core file, specifically, the build-id and the DT_SONAME attribute for
the file, which will be set for some shared libraries.

We then cache the DT_SONAME to build-id information on the core file
bfd object in the function set_cbfd_soname_build_id.

Later, when we are loading the shared libraries for the core file, we
can use the library's file name to look in the DT_SONAME to build-id
map, and, if we find a matching entry, we can use the build-id to
validate that we are loading the correct shared library.

This works OK, but has some limitations: not every shared library will
have a DT_SONAME attribute.  Though it is good practice to add such an
attribute, it's not required.  A library without this attribute will
not have its build-id checked, which can lead to GDB loading the wrong
shared library.

What I want to do in this commit is to improve GDB's ability to use
the build-ids extracted in core_target::build_file_mappings to both
validate the shared libraries being loaded, and then to use these
build-ids to potentially find (via debuginfod) the shared library.

To do this I propose making the following changes to GDB:

(1) Rather than just recording the DT_SONAME to build-id mapping in
set_cbfd_soname_build_id, we should also record, the full filename to
build-id mapping, and also the memory ranges to build-id mapping for
every memory range covered by every mapped file.

(2) Add a new callback solib_ops::find_solib_addr.  This callback
takes a solib object and returns an (optional) address within the
inferior that is part of this library.  We can use this address to
find a mapped file using the stored memory ranges which will increase
the cases in which a match can be found.

(3) Move the mapped file record keeping out of solib.c and into
corelow.c.  Future commits will make use of this information from
other parts of GDB.  This information was never solib specific, it
lived in the solib.c file because that was the only user of the data,
but really, the data is all about the core file, and should be stored
in core_target, other parts of GDB can then query this data as needed.

Now, when we load a shared library for a core file, we do the
following lookups:

  1. Is the exact filename of the shared library found in the filename
  to build-id map?  If so then use this build-id for validation.

  2. Find an address within the shared library using ::find_solib_addr
  and then look for an entry in the mapped address to build-id map.
  If an entry is found then use this build-id.

  3. Finally, look in the soname to build-id map.  If an entry is
  found then use this build-id.

The addition of step #2 here means that GDB is now far more likely to
find a suitable build-id for a shared library.  Having acquired a
build-id the existing code for using debuginfod to lookup a shared
library object can trigger more often.

On top of this, we also create a build-id to filename map.  This is
useful as often a shared library is implemented as a symbolic link to
the actual shared library file.  The mapped file information is stored
based on the actual, real file name, while the shared library
information holds the original symbolic link file name.

If when loading the shared library, we find the symbolic link has
disappeared, we can use the build-id to file name map to check if the
actual file is still around, if it is (and if the build-id matches)
then we can fall back to use that file.  This is another way in which
we can slightly increase the chances that GDB will find the required
files when loading a core file.

Adding all of the above required pretty much a full rewrite of the
existing set_cbfd_soname_build_id function and the corresponding
get_cbfd_soname_build_id function, so I have taken the opportunity to
move the information caching out of solib.c and into corelow.c where
it is now accessed through the function core_target_find_mapped_file.

At this point the benefit of this move is not entirely obvious, though
I don't think the new location is significantly worse than where it
was originally.  The benefit though is that the cached information is
no longer tied to the shared library loading code.

I already have a second set of patches (not in this series) that make
use of this caching from elsewhere in GDB.  I've not included those
patches in this series as this series is already pretty big, but even
if those follow up patches don't arrive, I think the new location is
just as good as the original location.

Rather that caching the information within the core file BFD via the
registry mechanism, the information used for the mapped file lookup is
now stored within the core_file target directly.
2024-09-07 20:28:57 +01:00

266 lines
8.7 KiB
C++
Raw Permalink Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* Machine independent variables that describe the core file under GDB.
Copyright (C) 1986-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 <http://www.gnu.org/licenses/>. */
/* Interface routines for core, executable, etc. */
#if !defined (GDBCORE_H)
#define GDBCORE_H 1
struct type;
struct regcache;
#include "bfd.h"
#include "exec.h"
#include "target.h"
/* Nonzero if there is a core file. */
extern int have_core_file_p (void);
/* Report a memory error with error(). */
extern void memory_error (enum target_xfer_status status, CORE_ADDR memaddr);
/* The string 'memory_error' would use as exception message. */
extern std::string memory_error_message (enum target_xfer_status err,
struct gdbarch *gdbarch,
CORE_ADDR memaddr);
/* Like target_read_memory, but report an error if can't read. */
extern void read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len);
/* Like target_read_stack, but report an error if can't read. */
extern void read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len);
/* Like target_read_code, but report an error if can't read. */
extern void read_code (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len);
/* Read an integer from debugged memory, given address and number of
bytes. */
extern LONGEST read_memory_integer (CORE_ADDR memaddr,
int len, enum bfd_endian byte_order);
extern int safe_read_memory_integer (CORE_ADDR memaddr, int len,
enum bfd_endian byte_order,
LONGEST *return_value);
/* Read an unsigned integer from debugged memory, given address and
number of bytes. */
extern ULONGEST read_memory_unsigned_integer (CORE_ADDR memaddr,
int len,
enum bfd_endian byte_order);
extern int safe_read_memory_unsigned_integer (CORE_ADDR memaddr, int len,
enum bfd_endian byte_order,
ULONGEST *return_value);
/* Read an integer from debugged code memory, given address,
number of bytes, and byte order for code. */
extern LONGEST read_code_integer (CORE_ADDR memaddr, int len,
enum bfd_endian byte_order);
/* Read an unsigned integer from debugged code memory, given address,
number of bytes, and byte order for code. */
extern ULONGEST read_code_unsigned_integer (CORE_ADDR memaddr,
int len,
enum bfd_endian byte_order);
/* Read the pointer of type TYPE at ADDR, and return the address it
represents. */
CORE_ADDR read_memory_typed_address (CORE_ADDR addr, struct type *type);
/* Same as target_write_memory, but report an error if can't
write. */
extern void write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr,
ssize_t len);
/* Same as write_memory, but notify 'memory_changed' observers. */
extern void write_memory_with_notification (CORE_ADDR memaddr,
const bfd_byte *myaddr,
ssize_t len);
/* Store VALUE at ADDR in the inferior as a LEN-byte unsigned integer. */
extern void write_memory_unsigned_integer (CORE_ADDR addr, int len,
enum bfd_endian byte_order,
ULONGEST value);
/* Store VALUE at ADDR in the inferior as a LEN-byte unsigned integer. */
extern void write_memory_signed_integer (CORE_ADDR addr, int len,
enum bfd_endian byte_order,
LONGEST value);
/* Hook for "file_command", which is more useful than above
(because it is invoked AFTER symbols are read, not before). */
extern void (*deprecated_file_changed_hook) (const char *filename);
/* Whether to open exec and core files read-only or read-write. */
extern bool write_files;
/* Open and set up the core file bfd. */
extern void core_target_open (const char *arg, int from_tty);
extern void core_file_command (const char *filename, int from_tty);
extern void exec_file_attach (const char *filename, int from_tty);
/* If the filename of the main executable is unknown, attempt to
determine it. If a filename is determined, proceed as though
it was just specified with the "file" command. Do nothing if
the filename of the main executable is already known.
DEFER_BP_RESET uses SYMFILE_DEFER_BP_RESET for the main symbol file. */
extern void exec_file_locate_attach (int pid, int defer_bp_reset, int from_tty);
extern void validate_files (void);
/* Give the user a message if the current exec file does not match the exec
file determined from the target. In case of mismatch, ask the user
if the exec file determined from target must be loaded. */
extern void validate_exec_file (int from_tty);
/* The current default bfd target. */
extern const char *gnutarget;
extern void set_gnutarget (const char *);
/* Build either a single-thread or multi-threaded section name for
PTID.
If ptid's lwp member is zero, we want to do the single-threaded
thing: look for a section named NAME (as passed to the
constructor). If ptid's lwp member is non-zero, we'll want do the
multi-threaded thing: look for a section named "NAME/LWP", where
LWP is the shortest ASCII decimal representation of ptid's lwp
member. */
class thread_section_name
{
public:
/* NAME is the single-threaded section name. If PTID represents an
LWP, then the build section name is "NAME/LWP", otherwise it's
just "NAME" unmodified. */
thread_section_name (const char *name, ptid_t ptid)
{
if (ptid.lwp_p ())
{
m_storage = string_printf ("%s/%ld", name, ptid.lwp ());
m_section_name = m_storage.c_str ();
}
else
m_section_name = name;
}
/* Return the computed section name. The result is valid as long as
this thread_section_name object is live. */
const char *c_str () const
{ return m_section_name; }
DISABLE_COPY_AND_ASSIGN (thread_section_name);
private:
/* Either a pointer into M_STORAGE, or a pointer to the name passed
as parameter to the constructor. */
const char *m_section_name;
/* If we need to build a new section name, this is where we store
it. */
std::string m_storage;
};
/* Type returned from core_target_find_mapped_file. Holds information
about a mapped file that was processed when a core file was initially
loaded. */
struct core_target_mapped_file_info
{
/* Constructor. BUILD_ID is not nullptr, and is the build-id for the
mapped file. FILENAME is the location of the file that GDB loaded to
provide the mapped file. This might be different from the name of the
mapped file mentioned in the core file, e.g. if GDB downloads a file
from debuginfod then FILENAME would point into the debuginfod client
cache. The FILENAME can be the empty string if GDB was unable to find
a file to provide the mapped file. */
core_target_mapped_file_info (const bfd_build_id *build_id,
const std::string filename)
: m_build_id (build_id),
m_filename (filename)
{
gdb_assert (m_build_id != nullptr);
}
/* The build-id for this mapped file. */
const bfd_build_id *
build_id () const
{
return m_build_id;
}
/* The file GDB used to provide this mapped file. */
const std::string &
filename () const
{
return m_filename;
}
private:
const bfd_build_id *m_build_id = nullptr;
const std::string m_filename;
};
/* If the current inferior has a core_target for its process target, then
lookup information about a mapped file that was discovered when the
core file was loaded.
The FILENAME is the file we're looking for. The ADDR, if provided, is a
mapped address within the inferior which is known to be part of the file
we are looking for.
As an example, when loading shared libraries this function can be
called, in that case FILENAME will be the name of the shared library
that GDB is trying to load and ADDR will be an inferior address which is
part of the shared library we are looking for.
This function looks for a mapped file which matches FILENAME and/or
which covers ADDR and returns information about that file.
The returned information includes the name of the mapped file if known
and the build-id for the mapped file if known.
*/
std::optional<core_target_mapped_file_info>
core_target_find_mapped_file (const char *filename,
std::optional<CORE_ADDR> addr);
#endif /* !defined (GDBCORE_H) */
Reference in New Issue View Git Blame Copy Permalink